JP2000207186A - Remote object communication program generating system, remote object communication system and computer- readable recording medium with remote object communication program generating program recorded therein - Google Patents

Abstract

PROBLEM TO BE SOLVED: To easily generate a remote object communication program for performing inter-object communication between remote processes, on the basis of an existent program. SOLUTION: This remote object communication program generating system is provided with a macro call generating tool 1, according to macro generation rules stored in a macro generation rule storage part 5, a prescribed code group which includes a macro call definition is added to an object definition file 11 and an object package file 21 including a class to be defined as a remote object, and a prescribed code group which includes the macro call definition is added to a basic object package file 31 included in a remote object communication library group 7. Then, files 12, 22 and 32, to which the prescribed code group is added, and the remote object communication library group 7 are compiled and linked by a compiler 6 by expanding the macro call definition added to the files 12, 22 and 32, while referring to a macro group 8.

Description

DETAILED DESCRIPTION OF THE INVENTION

[0001]

BACKGROUND OF THE INVENTION 1. Field of the Invention The present invention relates to a distributed object-oriented technique used in a distributed system such as a client / server system, and more particularly, to an inter-object communication between remote processes based on an existing program described in an object-oriented language. The present invention relates to a remote object communication program generation system that generates a remote object communication program for performing communication, a remote object communication system, and a computer-readable recording medium that records the remote object communication program generation program.

[0002]

2. Description of the Related Art In recent years, in various information processing systems constructed by companies and the like, it is strongly desired that software specifications and system requirements are diversified and fluidized and that a more robust system is constructed. It is becoming. For this reason, the software structure of the system is changing from an architecture based on a conventional function-oriented structuring method to an architecture based on a data-centric object-oriented method. Here, the object-oriented method is to define a single object by integrating data and a method (member function) for performing processing relating to the data, and define a system architecture by a plurality of objects defined in this way. It is assumed that. Note that functions in such a system are realized by calling a method defined in an object.

By the way, such an object-oriented method has good traceability from analysis to design / implementation, so that the constructed software structure is easy to understand, and a robust system excellent in reusability and flexibility is constructed. can do. For this reason, at present, most of the new systems have been developed by the object-oriented method, and existing systems are gradually shifting to systems incorporating the object-oriented method.

[0004] Further, with the rapid development of the computer industry, the system of information processing systems constructed by companies and the like is changing every moment. Until ten years ago, as shown in FIG. 18, the processing request from each terminal 61 was
The main type was a centralized mainframe system that the two undertook at once. However, with the spread of computers and the development of network networks, the number of terminals serving as clients and the number of requests from remote clients have continued to increase. As a result, the core computer alone cannot withstand the processing load. In addition, with the advent of high-performance workstations and personal computers, several years ago, as shown in FIG. Distributed client / server systems have been constructed in which tasks are distributed in parallel and tasks are processed in parallel. In such a distributed client / server system, the processing load on the server 71 can be reduced by causing the client 71 such as a personal computer to execute processing independent of the server 71. However, in such a distributed client / server system, the processing is also executed on the client side, so that the client that continues to increase can be upgraded when the server is changed or new software can be installed on the client side. Installation and version management are required, and the management cost on the client side tends to increase. On the other hand, in recent years, in order to reduce the management cost on the client side for the spread of the Internet by the WWW (World Wide Web) and the client that is increasing in conjunction with the spread of the Internet, as shown in FIG. As a result, the system is being shifted to a Thin client type system in which software of a client 71 such as a personal computer is downloaded from the server 72 and operated when necessary.

As described above, in the computer industry, the system of the information processing system is constantly changing, and even if a server centralized system is constructed at a certain point in time, the server is multi-processed or further multi-processed. It becomes necessary to distribute tasks in a server machine environment or to divide tasks into a client and a server.

Against this background, in software development today, two viewpoints, that is, support for object orientation and support for a flexible open network, have become very important. "Object-oriented communication" has been proposed as a concept incorporating two viewpoints. Here, the object-oriented communication means realizing normal inter-object communication such as method invocation between remote processes by incorporating the feature of the object-oriented method into remote inter-process communication. Regarding the object-oriented communication, OMG, a standardization organization,
(Object Management Group, registered trademark) has CORBA (Common Object Request Broker Archi
(registered trademark), and each manufacturer provides a CORBA-compliant product. In addition, COR
The BA mainly has the following specifications: (1) an interface definition language (IDL) for commonly describing an object interface;
Language), (2) Language mapping for describing applications in a programming language such as C language,
(3) The functions and interfaces of components for providing various services such as object generation and request distribution, and (4) protocols for inter-object communication are determined.

Under the current situation where such a standard specification (CORBA) is being generalized, when realizing inter-object communication between remote processes, a CORBA-compliant product provided by any manufacturer is usually used. Will be implemented.

[0008]

However, such a standard specification (CORBA) is originally intended to maintain compatibility of products provided by respective manufacturers.
This is effective when communication is performed between different products, but such compatibility is hardly required in the same system.

Further, such a standard specification (CORBA)
Various services such as those provided by are not so necessary when simple inter-object communication is to be realized between remote processes.

Further, such a standard specification (CORB
In A), a programming language and an OS (Operating
In order to realize inter-object communication that is not restricted to System), it is necessary to describe the interface of the object to be communicated in the IDL definition language and to generate a communication proxy object such as a stub or a skeleton by an IDL compiler. . For this reason, it is necessary to design in advance the objects to be communicated with consideration for implementation in CORBA.

The present invention has been made in consideration of such a point, and it is not necessary to consider cooperation with products of other manufacturers, or it is desired to simply realize inter-object communication between remote processes. In such cases, IDL
Remote processes can be performed based on an existing program written in an object-oriented language, without the need for complicated procedures such as description in a definition language, generation of a communication proxy object by an IDL compiler, and design in consideration of implementation in CORBA. A remote object communication program generation system that can easily generate a remote object communication program that performs inter-object communication with
It is an object of the present invention to provide a remote object communication system and a computer-readable recording medium recording a remote object communication program generation program.

[0012]

A first feature of the present invention is as follows.
In the remote object communication program generation system for generating a remote object communication program for performing inter-object communication between remote processes based on a local object communication program for performing inter-object communication in the same process, the system is included in the local object communication program First code adding means for adding a predetermined code group to an object definition file of an object requiring inter-object communication between remote processes among the objects; Second code adding means for adding a predetermined code group to an object implementation file of an object requiring inter-object communication between processes; Compiling means for compiling the object definition file and the object mounting file to which a predetermined code group has been added by the adding means and the second code adding means, and a remote object communication library group prepared in advance. A feature is a remote object communication program generation system.

According to a second feature of the present invention, in a remote object communication system for performing inter-object communication between remote processes, client process means including a client object, and server process means including a server object corresponding to the client object. A stream socket for transmitting and receiving binary data between the client process means and the server process means, wherein each of the client process means and the server process means requires inter-object communication between remote processes. A socket access object that holds identification information of an object to be executed, and remotely calls a method on the client object or the server object. A remote object communication system, characterized in that to realize the inter-object communication between processes.

A third feature of the present invention is a remote object communication program for generating a remote object communication program for performing inter-object communication between remote processes based on a local object communication program for performing inter-object communication in the same process. In a computer-readable recording medium on which a generation program is recorded, a predetermined object definition file and an object implementation file of an object that requires inter-object communication between remote processes among objects included in the local object communication program. Adding a code group, the object definition file and the object implementation file to which a predetermined code group has been added, and a remote object prepared in advance. A computer-readable recording medium recorded with the remote object communication program generation program, characterized in that and a step of compiling a preparative communication libraries on the computer.

According to the first to third aspects of the present invention, an object definition file and an object implementation file of an object to be defined as a remote object among existing programs described in an ordinary object-oriented language are described. By adding a predetermined code group, normal inter-object communication such as method call can be realized between remote processes.
It is possible to easily generate a remote object communication program by making the most of an existing program without modifying existing codes such as an object definition file and an object implementation file. For this reason, based on an existing program written in an object-oriented language, there is no need for complicated work such as description in an IDL definition language, generation of a communication proxy object by an IDL compiler, and design in consideration of implementation in CORBA. Thus, a remote object communication program for performing inter-object communication between remote processes can be easily generated.

[0016]

Embodiments of the present invention will be described below with reference to the drawings. FIGS. 1 to 13 are diagrams for explaining an embodiment of a remote object communication program generation system, a remote object communication system, and a computer-readable recording medium storing a remote object communication program generation program according to the present invention.

Generating a remote object communication program
System First, a remote object communication program generation system will be described with reference to FIGS.

FIG. 1 is a diagram showing the overall configuration of a remote object communication program generation system. As shown in FIG. 1, the remote object communication program generation system generates a remote object communication program 10 for performing inter-object communication between remote processes based on a local object communication program 9 for performing inter-object communication in the same process. To do
A macro call generation tool 1, a macro generation rule storage unit (macro generation rule storage unit) 5, a compiler 6, a remote object communication library group 7, and a macro group 8 are provided.

In FIG. 1, a local object communication program 9 includes an object definition file 11 and an object mounting file 21 which are source codes created by a user.
21 is provided to the macro call generation tool 1 as an input. Note that the object definition file 11 and the object mounting file 21 are described in a general object-oriented language such as C ++.

Here, the macro call generation tool 1
First code addition section (first code addition means) 2 and second code addition section
It has a code addition unit (second code addition means) 3 and should be defined as a remote object (an object that allows inter-object communication between remote processes) in accordance with the macro generation rules stored in the macro generation rule storage unit 5. A predetermined code group including a macro call definition is added to the object definition file 11 including the class and the object implementation file 21 to generate the macro call additional object definition file 12 and the macro call additional object implementation file 22, respectively. ing.

The macro call generation tool 1 further includes a third code addition section (third code addition means) 4, and a remote object communication library group according to the macro generation rules stored in the macro generation rule storage section 5. 7, a predetermined code group including a macro call definition is added to the base object implementation file 31 for the remote object included in the file 7, and a macro call added base object implementation file 32 is generated.

FIG. 2 is a diagram for explaining the details of the code group added to the object definition file 11, the object implementation file 21, and the base object implementation file 31 by the macro call generation tool 1.

As shown in FIG. 2, a code for defining a method calling function and a code for defining a member function table creation function are added to each class to be defined as a remote object in the object definition file 11. In addition, a code defining a server object calling function (SEND function) for realizing inter-object communication between remote processes is added to each of the existing member functions included in each class. Here, the method calling function is a function that retrieves a method name from the received data, searches for a member function to be called, and calls the corresponding member function (method). The member function table creation function is
This function registers the name of the member function in the table as a character string. Further, the server object call function (SEND function) is a function for making a method call on an object included in the remote process. Specifically, the server object call function is used to call the object included in the remote process according to a predetermined protocol. This is a function for transmitting data (method name, method name, argument value, etc.) related to method invocation.

As shown in FIG. 2, for the object implementation file 21, the implementation code of each member function of the class to be defined as a remote object is determined according to the position (client or server) where the object operates. Code to switch the processing content is added. Further, the base object implementation file 31
, A code for creating an instance of a class to be defined as a remote object is added to the implementation code of the remote object creation function defined in advance.

Then, the macro call additional object definition file 12, the macro call additional object implementation file 22, and the macro call additional base object implementation file 32 generated by the macro call generation tool 1 are given to the compiler 6 as input. In the compiler 6, these files 12, 22, 32 and the remote object communication library group 7 prepared in advance are
Macro call definition added to macro group 8
Compile and link while expanding with reference to.
Thereby, the object definition file 11 of the local object communication program 9 created by the user
Finally, the object implementation file 21 is the object definition file 13 corresponding to the remote object.
Then, the remote object communication program 10 is generated.

Next, the operation of the macro call generation rule 1 which is the main configuration of the remote object communication program generation system shown in FIG. 1 will be described with reference to FIGS. 3 to 5 are flowcharts for explaining a method of adding a code group to the object definition file, the object implementation file, and the base object implementation file in the remote object communication program generation system shown in FIG.
(A), (b), and (c) are diagrams illustrating an example of a code group added to an object definition file, an object implementation file, and a base object implementation file by the methods illustrated in FIGS. 3 to 5. 6 (a) and 6 (b)
In (c), the object definition file, the object implementation file, and the base object implementation file are each described in C ++, and the source code (the object definition file 1) before the code group is added.
1, the object implementation file 21 and the base object implementation file 31) are shown on the left side, and the source code (the macro call additional object definition file 12, the macro call additional object implementation file 22, and the macro call additional base) after the code group is added. The object implementation file 32) is shown on the right.
The added code group corresponds to the shaded portion of the source code on the right side, and is shown here in the form of the source code expanded from the macro call definition for simplification of the description. .

First, a method of adding a code group to the object definition file 11 will be described with reference to FIG.

As shown in FIG. 3, first, an object definition file 11 including a class to be defined as a remote object is input to the macro call generation tool 1 (step 101).

Next, the first of the macro call generation tools 1
The code adding unit 2 scans the input object definition file 11 and cuts out a token (step 102).

Then, the type of the extracted token is identified (step 103), and if it is determined that the token is a member function, the server object calling function (FIG. 6A) corresponding to the member function is determined. Symbol 12c
(See Step 10) as an inline function
4). The extracted member functions are stored in a variable table (step 105).

On the other hand, if it is determined in step 103 that the token is a class declaration terminator, the method calling function (of FIG. 6A) is determined based on the member function stored in the variable table in step 105. A reference numeral 12a) and a member function table creation function (see reference numeral 12b in FIG. 6A) are created as inline functions (steps 106 and 107).

Thereafter, when the token is a member function and the processing of steps 104 and 105 is completed, when the token is a class declaration terminator and the processing of steps 106 and 107 is completed, or when the token is a member function, the class declaration is terminated. If it is not a child, the token extracted in this way and the various inline functions created are overwritten on the original object definition file 11 as it is (step 108).

Note that the above steps 102 to 108 are repeated until a file terminator appears (step 109). When the file terminator appears, the macro call definition as shown in FIG. Then, a macro call additional object definition file 12 to which a predetermined code group including “.” Is added is generated.

Next, a method of adding a code group to the object mounting file 21 will be described with reference to FIG.

As shown in FIG. 4, first, an object implementation file 21 including a class to be defined as a remote object is input to the macro call generation tool 1 (step 201).

Next, the second macro call generation tool 1
The code adding unit 3 scans the input object mounting file 21 to cut out a token (step 202).

Then, the type of the extracted token is identified (step 203). If it is determined that the token is a member function implementation initiator of the class, the position of its own object other than the client is determined after the start declaration. Is a conditional branch start code (reference numeral 22a in FIG. 6B)
(See step 204).

On the other hand, if it is determined in step 203 that the token is a member function implementation terminator,
As a conditional branch code, a code for calling a server object calling function (SEND function) corresponding to this member function when the client is a client (see reference numeral 22b in FIG. 6B) is created (step 207).

Thereafter, when the token is a member function implementation starter and the process of step 204 is completed, when the token is a member function implementation end and the process of step 205 is completed, or when the token is a member function implementation initiator, the member function is not implemented. If it is not an implementation terminator, the token cut out in this way and the created code are overwritten on the original object implementation file 21 as it is (step 206).

Note that the above steps 202 to 206 are repeated until a file terminator appears (step 207). When the file terminator appears, the macro call definition as shown in FIG. A macro call additional object implementation file 22 to which a predetermined code group including “.” Is added is generated.

Next, a method of adding a code group to the base object definition file 31 will be described with reference to FIG.

As shown in FIG. 5, first, a base object mounting file 31 for a remote object included in the remote object communication library group 7 is input to the macro call generation tool 1 (step 301).

Next, after inputting the class name of the class to be defined as the remote object into the macro call generation tool 1 (step 302), the third code addition unit 4 of the macro call generation tool 1 inputs the class name in step 301. The token is extracted by scanning the base object mounting file 31 (step 303).

Then, the type of the extracted token is identified (step 304), and when it is determined that the token is a declaration of a remote object creation function, the class input in step 302 is included in the function. A code for creating an instance corresponding to the name (see reference numeral 32a in FIG. 6C) is created (step 305).

Thereafter, if the processing of step 305 is completed with the token being a declaration of a remote object creation function, or if the token is not a declaration of an object creation function, the token cut out in this way and the created code Is directly overwritten on the original base object mounting file 31 (step 306).

The above steps 303 to 306 are repeated until a file terminator appears (step 307). When the file terminator appears, the macro call definition as shown in FIG. A macro call additional base object implementation file 32 to which a predetermined code group including “.” Is added is generated.

As described above, according to the remote object communication program generation system according to the present embodiment, the object definition file 11 of the object to be defined as the remote object among the existing programs described in the ordinary object-oriented language, By adding a predetermined code group to the object implementation file 21 and the base object implementation file 31 for remote objects included in the remote object communication library group 7, normal inter-object communication such as method invocation can be performed between remote processes. Can be implemented without modifying the existing codes of the object definition file 11, the object implementation file 21, and the base object implementation file 31 at all. The remote object communication program using the large limit can easily be generated. Therefore, there is no need for complicated work such as description in an IDL definition language, generation of a communication proxy object by an IDL compiler, and design in consideration of implementation in CORBA.
It is possible to easily generate a remote object communication program for performing inter-object communication between remote processes based on an existing program described in an object-oriented language.

According to the remote object communication program generation system according to the present embodiment, a macro call definition is added to the object definition file 11, the object implementation file 21, and the base object implementation file 31 instead of the source code. Thus, it is possible to prevent the code from being complicated.

Remote Object Communication System Next, a remote object communication system generated by the remote object communication program generation system shown in FIGS. 1 to 6 will be described with reference to FIGS.

FIG. 7 is a diagram showing the overall configuration of the remote object communication system. As shown in FIG. 7, the remote object communication system performs inter-object communication between a remote process operating on a client 40 and a server 50. The remote object communication system includes a client process (client process means) 41 and a server process (server process). Means) 51, and a stream socket 55 for transmitting and receiving binary data between the client process 41 and the server process 51.

Here, each of the client process 41 and the server process 51 has a client object 42 and a server object 52 generated from the same class, and the client object 42 operates as a proxy object of the server object 52. It has become.

Each of the client process 41 and the server process 51 has socket access objects 43 and 53 for storing identification information (object names and addresses) of objects performing inter-object communication between remote processes. By imitating binary data communication via the socket 55 as inter-object communication (method call communication), a method call from the client object 42 or the server object 52 is realized as inter-object communication between remote processes. . The socket access objects 43 and 53
Is a remote object communication library group 7 of the remote object communication program generation system shown in FIG.
It corresponds to.

More specifically, for example, when a method call of the client object 42 is performed in the client process 41, data (object) relating to the method call is transmitted from the client object 42 to the stream socket 55 in accordance with a predetermined protocol (data structure). Name, method name and argument value). Here, the member function for transmitting data from the client object 42 to the stream socket 55 is a server object call function (FIG. 6A) added to the object definition file 11 by the remote object communication program generation system shown in FIG. This is a function that does not need to be created by the user.

On the other hand, in the server process 51 to which such data has been transmitted, the socket access object 53 receives the binary data via the stream socket 55, and is determined in advance by the data extraction method of the socket access object 53. The data is decomposed according to the protocol (data structure) to extract the object name and other data, and the data is passed to the corresponding object. Then, the server object 52 to which the data is passed extracts a method name from the received data and executes the corresponding method. Here, the member function for extracting the method name and calling the corresponding method in the server object 52 is the object definition file 1 by the remote object communication program generation system shown in FIG.
This is a method call function (see reference numeral 12a in FIG. 6A) added to 1 and is a function that does not need to be created by the user.

Note that such a client process 4
1 and the server process 51, it is necessary to register the names and addresses of the remote objects with respect to the socket access objects 43 and 53. Here, the member function for registering the name and address of the remote object with respect to the socket access objects 43 and 53 is a member function table creation function added to the object definition file 11 by the remote object communication program generation system shown in FIG. FIG.
(See reference numeral 12b in (a)), which is a function that does not need to be created by the user.

Next, the operation of the remote object communication system shown in FIG. 7 will be described with reference to FIGS. Here, FIGS. 8 to 11 are flowcharts for explaining operations on the client side and the server side of the remote object communication system shown in FIG.

First, referring to FIGS. 8 and 9, the client 40 of the remote object communication system shown in FIG.
The operation on the side will be described.

FIG. 8 is a flowchart for explaining the procedure for preparing for initialization on the client 40 side. As shown in FIG. 8, when creating a remote object on the client 40 side, first, an object name given to the remote object on the server 50 side to be called and an object created on the client 40 side (a proxy object) ) To create an object (step 401). Next, a socket access object 43 for accessing the stream socket 55 is created, and the name and address of the remote object created in step 401 are registered in the socket access object 43 (step 402). Finally, a preparation function for performing a predetermined initialization process on the client 40 side is called for the socket access object 43 (step 4).
03).

FIG. 9 is a flowchart for explaining the communication procedure on the client 40 side. As shown in FIG. 9, when a method of a remote object is called from the client 40, a normal method is called on the client 40 (step 501). At this time, the client object 42 recognizes that the position where the object operates is on the client side, and calls a server object call function (SEND function) corresponding to the called member function.
The remote object on the server 50 side is called (step 502).

FIG. 10 is a flowchart for explaining the procedure for preparing for initialization on the server 50 side. As shown in FIG. 10, when creating a remote object on the server 50 side, first, an object name and a value indicating creation on the server 50 side are given to create an object (step 601). Next, stream socket 5
5 to create a socket access object 53 for accessing
, The name and address of the remote object created in step 601 are registered (step 60).
2). Finally, the server 50 calls a preparation function for performing a predetermined initialization process on the socket access object 53 (step 603).

FIG. 11 is a flowchart for explaining the communication procedure on the server 50 side. As shown in FIG. 11, when a method is called from the client 40 to the remote object on the server 50 side, after the stream socket 55 receives the data (step 701), the data of the socket access object 53 is read. Call the retrieval method (step 70)
2). Then, an object name and other data are extracted from the received data by a data extraction method of the socket access object 53 according to a predetermined protocol, and the data is passed to the corresponding object (step 703). Finally, the method name of the corresponding object is used to retrieve the method name from the received data, search for a member function to be called, and call the corresponding member function (method) (step 704).

As described above, according to the remote object communication system according to the present embodiment, the socket access objects 43 and 53 holding the identification information (object names and addresses) of the objects performing the inter-object communication between the remote processes. Since binary data communication via the stream socket 55 is made to appear as inter-object communication (method call communication), description in the IDL definition language, generation of a communication proxy object by the IDL compiler, CORB
A normal inter-object communication such as a method call can be realized between the remote processes without a troublesome work such as a design conscious of the implementation in A.

Generation of remote object communication program
Computer-readable record of the program
Medium A computer-readable recording medium that records a program corresponding to the remote object communication program generation system shown in FIG. 1 will now be described with reference to FIGS.

In the remote object communication program generation system shown in FIG. 1, the first to third code addition units 2, 3, and 4 and the compiler 6 of the macro call generation tool 1 are composed of a computer system 6 as shown in FIG.
0 can be implemented as a program module that runs on the Internet. At this time, data necessary for processing in the first to third code addition units 2, 3, and 4 of the macro call generation tool 1 and the compiler 6 (the macro generation rule stored in the macro generation rule storage unit 5, the remote object Communication library group 7 and macro group 8 etc.)
Are stored in the hard disk unit 68 (see FIG. 13) of the computer system 60 or the like.

Here, a remote object communication program generation program including such a program module, data of the macro generation rule 5, the remote object communication library group 7 and the macro group 8, and the like are recorded on a predetermined recording medium. Computer system 6
0, and the generation processing of the remote object communication program as described above is performed.

As shown in FIG. 12, the computer system 60 includes a computer main body 61 housed in a housing such as a mini tower and a CRT (Cathode Ray Tube).
And a printer 6 as a recording output device
3, a keyboard 64a and a mouse 64b as input devices, a floppy disk drive 66 for reading information from a floppy disk 71 as a recording medium, and a CD-ROM (Compact Diode) as a recording medium.
and a CD-ROM drive device 67 for reading information from a sk-Read Only Memory (72).

When these structures are shown as a block diagram,
As shown in FIG. 13, an internal memory 65 such as a RAM (Random Access Memory) and an external storage device such as a hard disk unit 68 are further provided in a housing in which the computer main body 61 is stored. The floppy disk (recording medium) 71 on which the remote object communication program generating program is recorded is inserted into a slot of the floppy disk drive 66 as shown in FIG.
1 is installed. The recording medium on which the remote object communication program generation program is recorded is not limited to the floppy disk 71, but may be a CD-ROM.
72, an internal memory 65, a hard disk unit 68, etc., a MO (Magneto Optical) disk, an optical disk, and a DVD (Digital Versatile Disk) not shown.
And so on.

[0068]

Next, specific examples of the remote object communication program generation system according to the above-described embodiment and the remote object communication system generated by the system will be described. In the present embodiment, a case where an existing program is described in C ++ which is a general object-oriented language will be described as an example.

In this embodiment, the language used is C +
Since + has a macro expansion function, a code group added to the object definition file 11, the object implementation file 21, and the base object implementation file 31 of the local object communication program 9 is as follows.
Add a macro call definition corresponding to the macro group according to the following syntax rules.

Macro Syntax An example of the syntax of the macro call definition is shown below.

(1) Method call function added to the object definition file 11 <method call function> :: = METHODCALL (<CASE statement>) <CASE statement> :: = CASE (<method call name>(<argument macro
>), <Order>) | <CASE statement> CASE (<method invocation name>(<argumentmacro>),<order>)<method invocation name> :: = name of member function defined in class ( <Argument macro> :: = <Argument type>(<Order>), | <Argument type>(<Classname>,<Order>), | <Argument macro><Argumenttype>(<Order>), | <
Argument macro><Argumenttype>(<Classname>,<Order>),<Order> :: = Order number of member function <Argument type> :: = INT | DOUBLE | FLOAT | CHAR | INTARRAY | DOUBLE
ARRAY | FLOATARRAY | CHARARRAY | OBJ

(2) Member function table creation function added to object definition file 11 <Member function table creation function> :: = CREATETABLE (<TABLE
Statement>) <TABLE statement> :: = TABLE ("<member function declaration>", <order.>) | <TAB
LE statement> TABLE ("<member function declaration>", <order.>) <Member function declaration> :: = Name of the member function defined in the class (not including the argument) <order> :: = member Function ordering number

(3) Server object call function (SEND function) added to object definition file 11 <server object call function> :: = REMETHOD (<return value type>, <member function declaration>, <variable macro>, <Order>) <Return value type> :: = Return value type used in the member function declaration <Member function declaration> :: = Name of the member function defined in the class (excluding arguments) < Variable macro> :: = <variable type>(<member function declaration argument>) | <
Variable type>(<member function declaration argument>, <number of arrays>) | <variable macro><variabletype>(<member function declaration argument>, <number of arrays>) | <variable macro><variabletype>(<member Function declaration argument>) <variable type> :: = INTVAR | DOUBLEVAR | FLOATVAR | CHARVAR | INT
ARRAYVAR | DOUBLEARRAYVAR | FLOATARRAYVAR | CHARARRAYVAR
| OBJVAR <argument of member function declaration> :: = argument used in member function declaration <number of arrays> :: = number of arrays <order> :: = ordering number of member function)

(4) Base Object Implementation File 31
Remote object creation function added to <remote object creation> :: = CLASSNAME (<class name>) <class name> :: = name of class to create

Data Structure of Binary Data In this embodiment, a data structure as shown in FIG. 14 is used for binary data communication using the stream socket 55. That is, the structure and union (data stream, data element, data, and class data) shown in FIG. 14 are the protocols of the binary data communication between the client process 41 and the server process 51, and the transmitting side The data is transmitted in the order of the data structure shown in FIG. 14, and the receiving side retrieves the data according to this data structure.

FIGS. 15A and 15B are schematic diagrams schematically showing a relationship between a local object communication program and a remote object communication program. FIG.
In the local object communication program shown in (a), an object of the Test class is created from the Main function, and SetD, which is a member function of the created object, is created.
ata () and Print () are called. When such a local object communication program is divided into a client process and a server process, as shown in FIG. 15B, it is an object generated in the client process and a proxy object of the server object. Via the Test class object, the method of the Test class object created in the server process is called.

FIGS. 16 and 17 show class configuration diagrams in the case where the remote object communication program shown in FIG. 15B is implemented using the above-described macro syntax and the data structure of binary data.

In FIGS. 16 and 17, the procedure for calling the member function of the Test object on the server process side via the Test object on the client process side (the procedure corresponding to the flowcharts shown in FIGS. 11 to 14) is 1) to FIG. 9). FIG.
In FIG. 6 and FIG. 17, the Test class is a class redefined as a remote object, the RemoteObj class is a base class for defining a remote object,
The ckInitial class is a socket access class. As shown in FIGS. 16 and 17, the client process side and the server process side have basically the same class configuration, and the Test class has the role of both the client object (proxy object) and the server object. By using the same Test class on the client process side and the server process side in this way, even if one process is divided into a client process and a server process, there is no change to a normal method call for the Test class object. Need not be added. It is also possible to send a message from the server process to a remote object created in the client process.

In the above-described embodiment, the case where C ++ is used as the language to be used has been described as an example. However, any other object-oriented language can be used, and programming languages which cannot use macro expansion are also used. This can be handled by adding source code directly instead of the macro call definition.

[0080]

As described above, according to the present invention, a remote object communication program can be easily generated by making the most of an existing program without modifying the existing code.

[Brief description of the drawings]

FIG. 1 is a block diagram showing an embodiment of a remote object communication program generation system according to the present invention.

FIG. 2 is a view for explaining details of a code group added by the remote object communication program generation system shown in FIG. 1;

FIG. 3 is a flowchart for explaining a method of adding a code group to an object definition file in the remote object communication program generation system shown in FIG. 1;

FIG. 4 is a flowchart for explaining a method of adding a code group to an object mounting file in the remote object communication program generation system shown in FIG. 1;

FIG. 5 is a flowchart for explaining a method of adding a code group to a base object mounting file in the remote object communication program generation system shown in FIG. 1;

FIG. 6 is a diagram showing an example of a code group added to an object definition file, an object implementation file, and a base object implementation file by the methods shown in FIGS. 3 to 5;

FIG. 7 is a block diagram showing one embodiment of a remote object communication system according to the present invention.

FIG. 8 is a flowchart for explaining a procedure for client-side initialization preparation in the remote object communication system shown in FIG. 7;

FIG. 9 is a flowchart illustrating a communication procedure on the client side in the remote object communication system shown in FIG. 7;

FIG. 10 is a flowchart for explaining a procedure for preparing for initialization on the server side in the remote object communication system shown in FIG. 7;

11 is a flowchart for explaining a communication procedure on the server side in the remote object communication system shown in FIG. 7;

FIG. 12 is an exemplary perspective view showing a computer system using a computer-readable recording medium on which a remote object communication program generation program is recorded.

13 is a block diagram showing a hardware configuration of the computer system shown in FIG.

14 is a diagram showing an example of a data structure of binary data transmitted and received in the remote object communication system shown in FIG.

FIG. 15 is a schematic diagram schematically showing the relationship between a local object communication program and a remote object communication program.

FIG. 16 is a view showing a client-side class configuration in a specific implementation example of the remote object communication system generated by the remote object communication program generation system shown in FIG. 1;

FIG. 17 is a diagram showing a class configuration on the server side in a specific implementation example of the remote object communication system generated by the remote object communication program generation system shown in FIG. 1;

FIG. 18 is a diagram showing an example of a conventional information processing system (centralized mainframe type system).

FIG. 19 is a diagram showing another example (distributed client / server system) of a conventional information processing system.

FIG. 20 shows still another example of the conventional information processing system (T
FIG. 2 is a diagram showing a (hin client type system).

[Explanation of symbols]

DESCRIPTION OF SYMBOLS 1 Macro call generation tool 2 1st code addition section 3 2nd code addition section 4 3rd code addition section 5 Macro generation rule storage section 6 Compiler 7 Remote object communication library group 8 Macro group 9 Local object communication program 10 Remote object communication program 11 Object Definition File 12 Macro Call Addition Object Definition File 13 Remote Object Support Object Definition File 21 Object Implementation File 22 Macro Call Addition Object Implementation File 23 Remote Object Support Object Implementation File 31 Base Object Implementation File 32 Macro Call Addition Base Object Implementation File 40 Client 41 Client process 50 Server 51 Server process 42, 52 Remote object 43, 53 Socket access object 55 Stream socket 65 Recording medium (internal memory) 68 Recording medium (hard disk unit) 71 Recording medium (floppy disk) 72 Recording medium (CD-ROM)

 ──────────────────────────────────────────────────続 き Continuation of the front page (54) [Title of the invention] Remote object communication program generation system, remote object communication system, and computer readable recording of remote object communication program generation program Recording media

Claims (9)

[Claims] 1. A remote object communication program generation system for generating a remote object communication program for performing inter-object communication between remote processes based on a local object communication program for performing inter-object communication in the same process, First code adding means for adding a predetermined code group to an object definition file of an object requiring inter-object communication between remote processes among objects included in the communication program; Code addition means for adding a predetermined code group to an object implementation file of an object for which inter-object communication between remote processes is required among objects to be executed. Compiling means for compiling the object definition file and the object mounting file to which a predetermined code group has been added by the first code adding means and the second code adding means, and a remote object communication library group prepared in advance. A remote object communication program generation system, comprising: 2. The apparatus according to claim 1, further comprising: a macro generation rule storage unit for storing a macro call definition generation rule corresponding to a source code to be added to the object definition file and the object implementation file; 2 code adding means for adding a predetermined code group including a macro call definition to the object definition file and the object mounting file according to the macro generation rule stored in the macro generation rule storage means; The object definition file and the object mounting file to which a predetermined code group has been added by the first code addition unit and the second code addition unit, and a remote object communication library group prepared in advance; Claim 1 remote object communication program generating system, wherein the compiling while deploying macro call definitions added to object definition file and the object implementation file. 3. A third object for adding a predetermined code group to a base object mounting file for remote objects included in the remote object communication library group.
The object definition file and the object mounting file to which a predetermined code group has been added by the first code adding means and the second code adding means; and a remote controller prepared in advance. 2. The remote object communication program generation system according to claim 1, wherein the base object implementation file to which the predetermined code group is added by the third code adding unit is compiled together with the object communication library group. 4. A macro generation rule storage means for storing a macro call definition generation rule corresponding to a source code to be added to the object definition file, the object implementation file, and the base object implementation file, The code addition unit, the second code addition unit, and the third code addition unit store the object definition file, the object implementation file, and the base object implementation file according to the macro generation rule stored in the macro generation rule storage unit. A predetermined code group including a macro call definition is added thereto, and the compiling means includes a predetermined code group added by the first code adding means, the second code adding means, and the third code adding means. Object definition File, the object implementation file and the base object implementation file, and the prepared remote object communication library group, and expands the object definition file, the object implementation file and the macro call definition added to the base object implementation file. 4. The remote object communication program generation system according to claim 3, wherein the compilation is performed while the program is being compiled. 5. A remote object communication system for performing inter-object communication between remote processes, wherein: a client process means including a client object; a server process means including a server object corresponding to the client object; A stream socket for transmitting and receiving binary data to and from a server process means, wherein the client process means and the server process means each include identification information of an object that requires inter-object communication between remote processes. Having a socket access object that holds a call, and invoking a method call on the client object or the server object between remote processes. A remote object communication system implemented as inter-object communication. 6. The remote object communication system according to claim 5, wherein said client object and said server object are generated from the same class. 7. The remote object communication system according to claim 5, wherein the binary data transmitted and received via said stream socket has a predetermined data structure including an object name and a method name. 8. A computer which records a remote object communication program generating program for generating a remote object communication program for performing inter-object communication between remote processes based on a local object communication program for performing inter-object communication in the same process. Adding a predetermined code group to an object definition file and an object implementation file of an object that requires inter-object communication between remote processes among objects included in the local object communication program, on a possible recording medium; The object definition file and the object implementation file to which a predetermined code group is added, and a remote object communication library group prepared in advance A computer-readable recording medium recorded with the remote object communication program generation program for causing and a step to the computer to compile. 9. The object definition file to which a predetermined code group is further added to a remote object base object implementation file included in the remote object communication library group, wherein the predetermined code group is added. 9. The remote object communication program generation program according to claim 8, wherein the base object implementation file to which a predetermined code group is added is compiled together with the object implementation file and a remote object communication library group prepared in advance. A computer-readable recording medium on which is recorded.