JP2002132502A - Automatic creating system and method of distributed object with interpretation of language function - Google Patents

Abstract

PROBLEM TO BE SOLVED: To eliminate the need for a decision of a performing position, for IDL description of a server object, for a marshalling, for an un-marshalling process coding and the like operated conventionally by users to create distributed processing program from a user description language. SOLUTION: A client program creating part 1 comprises an object dividing part 10 to extract a class from a user description language source 6 for the decision of the performing position, a main creating part 11 to create an IDL definition 27, an implementation 26, a method 25 and a proxy object 24 for creation of a client source 23 with substituting access to the server of the part except the server object of a source 6 for a proxy, a client creating part 14 to perform a compile link of a source 23, of the object 24 and of the IDL definition 27 and a code transferring part 13, and a server program creating part 3 has a server creating means to perform the compile link of the received source.

Description

DETAILED DESCRIPTION OF THE INVENTION

[0001]

[0001] 1. Field of the Invention [0002] The present invention relates to a system and method for automatically generating a distributed object, and more particularly to a system and method for automatically generating a server-executed distributed object and a client-side program from only source code written in a user description language. About.

[0002]

2. Description of the Related Art Conventionally, as a means for developing a distributed application, CORBA which is a distributed object technology in which object orientation and a client / server are integrated.
(Common Object Request Bro
In the case of using “ker Architecture”, the development procedure includes extraction of an object operating on the server machine and ID of the object operating on the server machine.
Definition of L (interface definition language), activation of IDL compiler, and then compilation and linking using generated stub code and stub header, generation of client program on client machine, and server program on server machine Must be generated.

[0003]

However, the above-mentioned prior art has the following problems.

A first problem is that it is not easy to design an object operating on a server machine and an object operating only on a client machine while separating the object, and it is difficult to change the operating environment of the object when the function is extended. It is difficult.

The reason is that it is necessary to define IDL first, and if the IDL is modified, it is necessary to modify the program for both the server and the client.

A second problem is that the user needs to learn an IDL language in addition to a user-written language that is usually used. Also, conversion from a user-written language to argument packing conforming to the CORBA convention (hereinafter referred to as marshalling) ),
Like object call according to CORBA convention,
This means that the user needs to acquire advanced CORBA rules and IDL language knowledge.

The reason is that for developing a server object, logic must be described in a program source output from an IDL compiler, and a client program needs to describe a process of calling a proxy object output from an IDL compiler. In this case, it is necessary to temporarily convert the argument at the time of calling the function in the user description language into a marshalling description. On the contrary, the server program returns the argument packing conforming to the CORBA rules to a form understandable by the user description language. (Hereinafter referred to as unmarshalling).

A third problem is that the operation position of the object cannot be easily changed, and changing the operation position of the object requires a large man-hour for defining the IDL and modifying the program.

The reason is that the work described in the first and second problems occurs to change the operation position of the object.

A fourth problem is that it is not easy to describe an object operating between different machines across CORBA communication without errors, and that debugging is complicated.

The reason is that when an object described in a single machine or a single user language calls a routine X called by a user, the X routine is immediately called, but when the CORBA communication is interposed. Can perform the processing of the user routine X through marshalling processing, connection to the server object, server object calling, and unmarshalling processing.
This is because it is not easy to prevent all the bugs from being mixed in advance, and it is also not easy to specify a location when a bug is mixed.

A fifth problem is that in order to create an object that operates between different machines across CORBA communication, it is necessary to compile and link in accordance with the execution machine, which is inconvenient for the user. That is.

The reason is that after transferring the source code to the server machine and transferring the IDL definition, the execution of the IDL compilation, the compilation of the source code and the execution of the link on the server machine eventually complete the distributed object. For this reason, it takes much more time than writing in a single machine or a single user language.

A sixth problem is that conventionally, dividing an object that uses a global variable or uses a screen function into an object is a heavy burden on the user.

The reason is that the screen function is usually created on the assumption that the screen function is used from a client program, but it is necessary for the user to divide the function into the client side function or the server side function each time. is there.

In the case where global variable references are scattered, it is necessary to take measures such as adding function call parameters, but this is simple for the user, but the program modification impact is relatively large.

[0017]

A first distributed object automatic generation system according to the present invention is a system for automatically generating a server-executed distributed object and a client-side client program only from source code written in a user description language. An object division unit that includes a client program generation unit and a server program generation unit that generates a distributed object, wherein the client program generation unit extracts a class process from the source code and determines an execution position using a keyword. , For objects determined to be server-run
Creates a DL definition, object implementation source, and server method source, generates a proxy class source to be provided on the client side corresponding to the object implementation, and includes a non-extracted portion of the user description language source and a client execution class. Main generating means for generating a client source by replacing processing of the server class of the main source as a source with access processing of the proxy class; and
Client generation means for inputting a proxy class source and IDL definition and compiling and linking them to generate an executable client program, and code transfer means for transferring the IDL definition, object implementation source and method source to a server Wherein the server program generating means has means for receiving the transferred code and server generating means for generating an executable server program by compaling and linking the received code.

A second distributed object automatic generation system according to the present invention is a system for automatically generating a server-executed distributed object and a client program on the client side only from source code written in a user description language. Means for generating class objects, a server program generating means for generating distributed objects, the client program generating means extracting class processing from the source code, and determining the execution position of the class processing by using a keyword, and the source code and the object. Global variable class generation means for extracting global variables from division information and generating IDL definitions thereof, a global variable object for managing them, and a global variable proxy class correspondingly provided in a client Creating an IDL definition, an object implementation source, and a server method source for the object determined to be server-executed by the division, creating a proxy class source provided on the client side corresponding to the object implementation, and the user description language; The non-extracted part of the source and the client execution class are set as the main source, the processing of the server class of the main source is replaced with the access processing of the proxy class, and the reference and assignment to the global variable are performed by the global variable proxy class Main generating means for generating a client source by substituting the client source, proxy class source, IDL definition, global variable proxy class, and global variable IDL definition, and compiling and retrieving them. Client generation means for generating an execution form client program by executing the IDL definition, an object implementation source, a method source, a global variable class and its IDL definition to a server. The server program generating means includes a means for receiving the transferred code and a server generating means for compiling and linking the received code to generate an executable server program.

In a third distributed object automatic generation system according to the present invention, the client program generating means converts the set of arguments called from the client source into a format defined by an object request broker. Generating the proxy implementation class, and converting the set of arguments received by the object implementation from the object request broker into the form of a server method program to generate the object implementation source. It is characterized by doing.

In a fourth distributed object automatic generation system according to the present invention, the client program generation means converts the set of arguments called by the global variable proxy class from a client source into a format defined by an object request broker. Generating the global variable proxy class, converting the set of arguments received by the global variable class from the object request broker into the form of a server method program, and generating the global variable class. It is characterized by the following.

In a fifth distributed object automatic generation system according to the present invention, the object dividing means includes keyword information for each of a plurality of types of user description languages, and each of the keyword information is one or more. It is characterized by having a keyword, a logical expression between the keywords, and an execution position designation value when the logic is established.

In a sixth distributed object automatic generation system according to the present invention, the object dividing means first executes the extracted class process in accordance with explicit execution position designation information marked on a source of a user-written language. And means for determining the execution position of the class process without explicit execution position designation based on the keyword information.

A first distributed object automatic generation method according to the present invention is a method for automatically generating a server-executed distributed object and a client program on the client side only from source code written in a user description language. A client program generation procedure that extracts a class process from the source code and determines an execution position of the class process using a keyword, and a server execution. Creates IDL definition, object implementation source, and server method source for the created object, generates a proxy class source provided on the client side corresponding to the object implementation, and A main generation procedure of using a non-extracted portion of a language source and a client execution class as a main source, replacing processing of a main source with a server class by access processing to the proxy class, and generating a client source; Class source, ID
A client generation procedure for generating an executable client program by compiling and linking the L definitions, and a code transfer procedure for transferring the IDL definition, the object implementation source, and the method source to a server. The server program generating procedure includes a procedure of receiving the transferred code and a server generating procedure of compiling and linking the received code to generate an executable server program.

The second distributed object automatic generation method according to the present invention is a method for automatically generating a server-executed distributed object and a client-side client program from only source code written in a user description language. A server program generation procedure for generating a distributed object, wherein the client program generation procedure extracts a class process from the source code and determines an execution position using a keyword, and the source code and the object. A global variable class generation procedure for extracting global variables from the division information and generating their IDL definitions, a global variable object for managing them, and a corresponding global variable proxy class provided in the client; IDL defines the object determined with the server running on the split, the object implementation source, to create a server method sources,
Create a proxy class source provided on the client side corresponding to the object implementation, and use the non-extracted part of the source of the user description language and the client execution class as the main source and process the main source into the server class to the proxy class. Main generation procedure for generating a client source by replacing the access processing of the global variable with reference and assignment processing to the global variable proxy class, and generating the client source, the client source, the proxy class source, the IDL definition, and the global A client generating procedure for generating an executable client program by inputting a variable proxy class and a global variable IDL definition, and compiling and linking them;
DL definition, object implementation source, method source, global variable class and its IDL
And a code transfer procedure for transferring the definition to a server. The server program generation procedure includes a procedure for receiving the transferred code and a server generation for compiling and linking the received code to generate an executable server program. And a procedure.

In a third distributed object automatic generation method according to the present invention, the client program generation procedure includes
The proxy class generates the proxy class by including a process of converting a set of arguments called from a client source into a format defined by an object request broker, and the object implementation receives the set of arguments from the object request broker. Generating the object implementation source by including a process of converting the set of arguments into a server method format.

In a fourth distributed object automatic generation method according to the present invention, the client program generation procedure comprises the following steps:
The global variable proxy class includes a process of converting a set of arguments called from a client source into a format defined by an object request broker, generating the global variable proxy class, and the global variable class The method includes generating a global variable class by including a process of converting a set of arguments received from a broker into a server method program format.

In a fifth distributed object automatic generation method according to the present invention, the object division procedure is provided with keyword information for each type corresponding to a plurality of types of user description languages. It is characterized by having a keyword, a logical expression between the keywords, and an execution position designation value when the logic is established.

In a sixth distributed object automatic generation method according to the present invention, in the object division procedure, the extracted class processing is executed according to explicit execution position designation information marked on a source of a user description language. And a step of determining the execution position of the class process without the explicit execution position designation based on the keyword information.

[0029]

DETAILED DESCRIPTION OF THE PREFERRED EMBODIMENTS A system and method for automatically generating a distributed object by interpreting a language function according to the present invention receives a program described in a user description language operable on a single machine, performs a semantic analysis on the program, and performs automatic analysis. The client program and the server object are automatically determined, and the client program automatically generates a marshalling process, a connection process, and a server method invocation process (hereinafter, referred to as a proxy object control description) for the client proxy object. Provides a configuration that can automatically generate unmarshalling processing and method invocation processing (hereinafter, referred to as server implementation).

At this time, what must be managed by the user is a program described in a user description language operable on a single machine, and includes an IDL definition, a proxy object control description, and a server implementation. Provides a configuration that does not require management.

Further, the present configuration is not limited to simply converting a source program described in a user description language.
An object of the present invention is to provide a configuration in which an executable client program is automatically generated on a client machine, and a distributed object is automatically generated as an executable format on a server machine.

Also, by arranging specific characters, symbols, or words on the source of the user description language, the user can explicitly specify whether to allocate the function to the server or the client. Thus, the object arrangement position can be instantaneously switched.

Further, it is possible to automatically determine the execution position of the class process by using a keyword whose search target is a user description language source.

Next, embodiments of the present invention will be described with reference to the drawings. Referring to FIG. 1, an embodiment of a system and method for automatically generating a distributed object by interpreting a language function according to the present invention operates under program control.

The client machine 100 and the server machines 200 and 201 are connected by a network 300. The client machine 100 has a client program generator 1, and the server machines 200 and 201 have a server program generator 3.

The client program generation unit 1 is a client program 2 for making a request to a distributed object.
Is a means for generating The server program generation unit 3
This is means for generating server distributed objects 4 and 5 that receive requests from the client program 2.

FIG. 2 shows a client program generator 1,
FIG. 3 is a block diagram illustrating a configuration of a server program generation unit 3 and input / output contents thereof.

The client program generation section 1 has an object division section 10, a main generation section 11, a global variable class generation section 12, a code transfer section 13, and a client generation section 14.

The server program generating section 3 has a receiving section of the code transfer section 13 and a server generating section 30.

The object division unit 10 receives the user description language source file 6 as input and determines an object to be arranged on the server and an object to be arranged on the client.
To divide. To this end, a keyword definition 101 is provided for each type corresponding to a plurality of types of user description languages, and each keyword definition includes one or more keywords, a logical expression between the keywords, and an execution position designation value when the logic is established. A plurality of these are provided in units of information consisting of (server / client).

The main generation unit 11 has a client source 23
And a server method source 25 are automatically generated.

At this time, a proxy object source 24 having a proxy object control description and an object implementation 26 for managing the server implementation are automatically generated in accordance with the contents of the object to be arranged in the server. IDL definition 2 for connecting distributed objects
7 is automatically generated.

The global variable class generation unit 12 integrates only proxy object control descriptions for global variables and server object implementations.
A global variable class and IDL definition 28 are automatically generated.

The client generation unit 14 receives the client source 23, the proxy object source 24, the IDL definition 27, the global variable class and the IDL definition 28, and automatically generates the client program 2.

The code transfer unit 13 transfers a file necessary for generating a server program to the server, and the receiving unit sends a server method source 25 ′ and an object implementation 2 to the server generation unit 30.
6 ', IDL definition 27', global variable class and I
Enter the DL definition 28 '.

The server generation unit 30 automatically generates a server distributed object 4 and a global variable (server) 5.

In this way, it is possible to automatically generate a client program and a server program from a user description language operable on a single machine.

Next, the overall operation of this embodiment will be described in detail with reference to the flowchart of FIG.

The object division unit 10 reads the user-defined language source file 6, performs language syntax analysis and semantic analysis, extracts classes, and classifies server-operable ones into server classes and client classes.

The main generator 11 creates the files of the IDL definition 27, global variable class and IDL definition 28, object implementation 26, proxy object source 24, server method source 25, and client source 23 in FIG. (Step 1).

The code transfer unit 13 is a server method source 2 shown in FIG. 2 necessary for generating a server object.
5. Object implementation 26, IDL
Each file of the definition 27, the global variable class, and the IDL definition 28 is transferred to the server (step 2).

The receiving unit of the code transfer unit 13 passes the server method source 25 ′, the object implementation 26 ′, the IDL definition 27 ′, the global variable class and the IDL definition 28 ′ to the server generation unit 30 and generates a server program. Request (step 3).

The client generation unit 14 includes a client source 23, a proxy object source 24, an IDL definition 2
7. The global variable class and the IDL definition 28 are input and compiled to automatically generate the client program 2 (step 4).

Next, a specific example will be described. In particular, the processing of step 1 which is a feature of the present application will be described in detail.

As shown in FIG. 4, first, the user description language source file 6 is read (step 1-1). Next, it is automatically determined whether the object description should be located in the server or the client (step 1-2). Step 1
As shown in FIG. 5, the details of -2 are extracted at the class processing level, the object mounting position is determined when the user explicitly specifies the execution position, and the user is not specified. Classes that cannot be placed on the server due to language functions are picked up and processed as client classes.

For example, explicit execution position specification by the user is specified in the comment field of the user description language source. The character following the start definition character (! Etc.) of the comment (S /
C / space) to distinguish between server, client, and no designation.

A class without designation is set as a client class according to the keyword definition table 101 corresponding to the description language. "OUT" and "DISPLAY" in the definition table
If AND is satisfied and the client is designated, a class that satisfies these conditions is a client class.

Returning to FIG. 4, when the extraction of the server object is completed in step 1-2, the main generator 11 automatically generates an IDL definition for the server object (step 1-3). In the server object, a server object implementation responsible for unmarshalling between the IDL language and the user description language is automatically generated (step 1-4).

Next, a proxy class that makes it appear as if the server object exists in the client is automatically generated (step 1-5). The proxy class is responsible for marshalling between the user description language and the IDL language.

The details of steps 1-7 to 1-9 performed by the global variable class generation unit 12 are as shown in FIG. 6, and the global variables are extracted from the user description language source and its division information, and the global variables are managed. Automatically generate server objects. There is a proxy class responsible for marshalling and a global variable server implementation responsible for unmarshalling so that global variables can be referenced transparently from both the server and the client.

In step 1-10, the processing of the user description language source is replaced. As shown in FIG. 7, a code for performing a reference to a global variable or setting a value to a global variable is extracted, and a corresponding part is automatically converted into a process description for a global variable proxy object.

In step 1-6, processing for accessing an object located on the server is automatically converted to processing for accessing a proxy object.

In S1-11, an initial process and an end process required for executing the CORBA distributed object are inserted into the client main source. Further, a process for activating the server object of the global variable is inserted in the initial process so that the global variable object can be used immediately after execution.

Each file generated in this manner is automatically compiled and linked as shown in FIG. 3 described above, and is ready to be executed.

FIG. 9 shows the relationship between the files at the time of execution. R1 in FIG. 9 is an example of the main processing of the client program. The automatically generated initial processing is inserted in the main processing, and the CORBA initial processing, R2,.
One global variable management object is activated as shown in the processing up to this point.

When the global variable reference G1 occurs in the client program, the value is transferred to the global variable management object located on the server by the function of the converted global variable proxy object in FIG. Also, the R6 client class that is not or cannot be located on the server executes on the client machine by using the normal language function of the user description language.

The process of accessing the server object generated so as to be automatically located at the server according to the present invention is as follows.
The processing is executed by the server through the processing of R7 to R11. R1
The processing result of 1 returns to R7 via R10 to R8, and the user does not need to be aware of the existence of the server object on the source code.

The system and method for automatically generating a distributed object according to the present invention is applicable not only to an object-oriented source file as the user description language source file 6 but to any description language. For example, C
Language, COBOL, Java, and the like.

Further, the distributed object automatic generation system and method of the present invention is not an invention specializing in CORBA, but targets any distributed object base. For example, DCE (Distributed Computing)
g environment, DCOM (distr)
ibuted component object m
model).

[0070]

As described above, the system and method for automatically generating a distributed object according to the present invention interpret a user description language and automatically generate a distributed object and a client program. There is a first effect that it is not necessary to learn a new IDL language other than the user description language.

Further, since it is possible to omit the source code transfer for compiling and linking by the user, there is a second effect that the implementation of the IDL language function and the compiling and linking can be completely hidden from the user. .

The system and method for automatically generating a distributed object according to the present invention generates a server object and a client object in accordance with a mark on a user description language source file, and automatically performs global variable extraction, marshalling, and unmarshalling processing. Therefore, there is a third effect that the user can easily change the operation position of the object.

That is, there are many processes that are usually required to describe a distributed object. In order to enable an object operating on a conventional client to operate on a server, an ID is required.
L is defined and marshalling and unmarshalling are performed by the user himself, but these operations are not required.

When a prototype is created or execution performance is to be compared, it is necessary to change the object execution position with a large number of man-hours. The present invention can eliminate the man-hour burden.

Since the distributed object automatic generation system and method according to the present invention automatically generates a distributed object without modifying a source code described in a user language, the input file according to the present invention is an ordinary single machine. The fourth effect is that the program can be created as a program that operates on the above, and the user can use a familiar debugger.

[Brief description of the drawings]

FIG. 1 is a block diagram showing an overall configuration of an embodiment of a distributed object automatic generation system and method according to the present invention.

FIG. 2 is a block diagram showing a configuration of a client program generation unit 1 and a server program generation unit 3 of FIG. 1 and their input / output contents.

FIG. 3 is a flowchart showing the entire operation of the embodiment of the distributed object automatic generation system of the present invention, and showing the entire steps of the distributed object automatic generation method of the present invention.

FIG. 4 is a flowchart showing an operation of the client program generation unit 1 and detailed steps of a client program generation procedure.

FIG. 5 is a flowchart showing processing steps of object division.

FIG. 6 is a flowchart showing global variable class generation processing steps.

FIG. 7 is a view showing a specific processing example of step 1-10 in FIG. 4;

FIG. 8 is a view showing a specific processing example of step 1-6 in FIG. 4;

FIG. 9 is a diagram showing each execution module of a program generated in a client and a server and a state at the time of execution.

[Explanation of symbols]

 DESCRIPTION OF SYMBOLS 1 Client program generation part 10 Object division part 101 Keyword definition 11 Main generation part 12 Global variable class generation part 13 Code transfer part 14 Client generation part 2 Client program 23 Client source 24 Proxy object source 25 Server method source 26 Object implementation 27 IDL definition 28 Global variable class and IDL definition 3 Server program generator 30 Server generator 4 Server distributed object 6 User description language source file 100 Client machine 200, 201 Server machine 300 Network

Claims (12)

[Claims] 1. A system for automatically generating a server-executed distributed object and a client-side client program from only source code written in a user description language, comprising: a client program generating means and a server program generating means for generating a distributed object. And
The client program generation means includes: an object division means for extracting a class process from the source code and determining an execution position using a keyword; an IDL definition, an object implementation source, and a server method source for an object determined to be executed on a server. To generate a proxy class source provided on the client side corresponding to the object implementation, and to process the main source server class with the non-extracted portion of the user description language source and the client execution class as the main source. Main generating means for generating a client source by substituting for access processing to a proxy class;
It has client generation means for inputting DL definitions, compiling and linking them to generate an executable client program, and code transfer means for transferring the IDL definition, object implementation source and method source to a server. Wherein the server program generating means comprises means for receiving the transferred code and server generating means for generating an executable server program by compaling and linking the received code. . 2. A system for automatically generating a server-executed distributed object and a client-side client program from only source code written in a user description language, comprising: a client program generating means and a server program generating means for generating a distributed object. And
The client program generating means extracts the class process from the source code and determines the execution position by using a keyword. The client program generating means extracts global variables from the source code and the object division information, and defines the IDL definitions and these. Global variable class generation means for generating a global variable object to be managed and a global variable proxy class correspondingly provided to the client; IDL definition, object implementation source, server method for the object determined to be server-executed in the division Create a source, create a proxy class source provided on the client side corresponding to the object implementation, and create a non-extracted part of the source of the user description language and the client execution class. Generates a client source by replacing the process of the main source server class with the access process to the proxy class and replacing the reference and assignment process to global variables with the access process to the global variable proxy class. Main generating means for inputting the client source, proxy class source, IDL definition, global variable proxy class, and global variable IDL definition, and compiling and linking these to generate an executable client program; Code transfer means for transferring an IDL definition, an object implementation source, a method source, a global variable class, and the IDL definition to a server, wherein the server program generation means receives the transferred code; Recieved Distributed object automatic generation system characterized by having a a server generating means for generating an executable server program to compile and link over de. 3. The client program generating means generates the proxy class by including a process in which the proxy class converts a set of arguments called from a client source into a format defined by an object request broker. Generating the object implementation source by including a process in which the object implementation converts a set of arguments received from an object request broker into a server method program format. 3. The distributed object automatic generation system according to 2. 4. The client program generating means includes a process in which the global variable proxy class converts a set of arguments called from a client source into a format defined by an object request broker. 3. The method according to claim 2, further comprising the step of: generating a global variable class by converting the set of arguments received by the global variable class from an object request broker into a server method program. Automatic object generation system. 5. The object dividing means includes keyword information for each of a plurality of types of user description languages, and each type of the keyword information includes one or more keywords and a logical expression between the keywords and a logical expression. 3. The distributed object automatic generation system according to claim 1, wherein the distributed object automatic generation system has an execution position designation value. 6. The object division unit determines an execution position of the extracted class processing according to explicit execution position designation information marked on a source of a user description language. 3. The distributed object automatic generation system according to claim 1, further comprising: means for determining an execution position of a class process having no keyword based on the keyword information. 7. A method for automatically generating a server-executed distributed object and a client-side client program from only source code written in a user description language, comprising: a client program generating procedure; and a server program generating procedure for generating a distributed object. The client program generation procedure includes: an object division procedure for extracting a class process from the source code and determining an execution position using a keyword; an IDL definition for an object determined to be executed on a server; an object implementation source; , A server method source, a proxy class source corresponding to the object implementation and provided on the client side, and a non-extracted portion of the user description language source and a client execution class. A main generation procedure of generating a client source by replacing the processing of the server class of the main source with the processing of accessing the proxy class, and the client source, the proxy class source, and the ID
A client generation procedure for generating an executable client program by compiling and linking the L definitions, and a code transfer procedure for transferring the IDL definition, the object implementation source, and the method source to a server. Wherein the server program generating procedure includes a procedure of receiving the transferred code and a server generating procedure of compiling and linking the received code to generate an executable server program. . 8. A method of automatically generating a server-executed distributed object and a client-side client program from only source code written in a user description language, comprising a client program generating procedure and a server program generating procedure for generating a distributed object. The client program generation procedure includes: an object division procedure for extracting class processing from the source code and determining the execution position using a keyword; and extracting global variables from the source code and object division information and A global variable class generation procedure for generating a definition, a global variable object for managing them, and a corresponding global variable proxy class provided in the client; Create DL definition, object implementation source, server method source,
Create a proxy class source provided on the client side corresponding to the object implementation, and use the non-extracted part of the source of the user description language and the client execution class as the main source and process the main source into the server class to the proxy class. Main generation procedure for generating a client source by replacing the access processing of the global variable with reference and assignment processing to the global variable proxy class, and generating the client source, the client source, the proxy class source, the IDL definition, and the global A client generation procedure for inputting a variable proxy class and a global variable IDL definition, compiling and linking them, and generating an executable client program;
DL definition, object implementation source, method source, global variable class and its IDL
And a code transfer procedure for transferring the definition to a server. The server program generation procedure includes a procedure for receiving the transferred code and a server generation for compiling and linking the received code to generate an executable server program. Automatically generating a distributed object. 9. The client program generating step includes generating the proxy class by including a process in which the proxy class converts a set of arguments called from a client source into a format defined by an object request broker. And generating the object implementation source by including a process of converting the set of arguments received by the object implementation from the object request broker into a server method format. The distributed object automatic generation method described. 10. The client program generating step includes the step of the global variable proxy class converting a set of arguments called from a client source into a format defined by an object request broker. 9. The global variable class according to claim 8, wherein said global variable class includes a process of converting a set of arguments received from an object request broker into a server method program format. Distributed object automatic generation method. 11. The object dividing procedure includes keyword information corresponding to a plurality of types of user description languages, each type of which includes one or more keywords and a logical expression between the keywords and a logical expression when the logic is established. 9. The distributed object automatic generation method according to claim 7, further comprising: an execution position designation value. 12. The object dividing step includes: a step of determining an execution position of the extracted class processing in accordance with explicit execution position designation information marked on a source of a user description language; and an explicit execution position designation. 9. The method according to claim 7, further comprising: a step of determining an execution position of a class process having no keyword based on the keyword information.