JP3067707B2 - Client / server program generation method - Google Patents

Description

DETAILED DESCRIPTION OF THE INVENTION

[0001]

TECHNICAL FIELD The present invention relates to a client /
The present invention relates to an apparatus and method for unifying a source code at the time of developing a server program and automatically generating a client / server program from the source code.

[0002]

2. Description of the Related Art Generally, a client / server program includes an application program and an interface program, which need to be generated separately. Conventionally, as a technique relating to automatic generation of this kind of client / server program, for example, Japanese Patent Application Laid-Open
There is an “interface program automatic generation device” as disclosed in JP-A-110122. In this publication,
As shown in FIG. 10, an interface automatic generation apparatus for automatically generating, as an interface program source code, means for mutually exchanging data between computers in a system in which computers of the same model or different models are connected on a network. I have. Inputs in this automatic generation device are an interface definition 707, a language specification 708, a generalization / specialization routine 709, and a communication protocol routine 710. Outputs are a client conversion data / data type definition 711 and a server conversion data / data. A type definition 712, a client interface program 713, and a server interface program 714.

A user compiles a client application program described by himself / herself, an automatically generated client conversion data / data type definition 711 and a client interface program 713 on a client machine, and writes a server application program written by himself / herself, By compiling the automatically generated server conversion data / data type definition 712 and the server interface program 714 on a server machine, it becomes possible to execute a program for exchanging data between heterogeneous computers.

Another example is disclosed in Japanese Patent Application Laid-Open No. 6-2429.
There is an "automatic generation method of a communication processing program" as disclosed in JP-A-38. This publication describes an automatic generation method of a communication processing program for performing communication processing between computers in a distributed processing system connected by a network, as shown in FIG. Inputs in this automatic generation method include a data definition file 801, an interface definition file 802, and a mode definition file 8
03, and the output is the communication processing program 80
9 As a matter of course, the application program needs to be generated separately.

[0005]

SUMMARY OF THE INVENTION A conventional client /
Since the server program generation device is configured as described above, it is necessary to generate an application program separately from the interface program, and by operating in cooperation with a client application program or a server application program created separately by a user, For the first time, data exchange between client and server becomes possible.

SUMMARY OF THE INVENTION The present invention has been made to solve the above-mentioned problems, and a client / server program can be executed by writing client logic and server logic in the same source code. It is an object to enable automatic generation of

[0007]

According to the present invention, there is provided a method for generating a client / server program, comprising the steps of:
A step of writing the script source in the processing order by assigning an identifier for identifying the client / server to the source code for starting the server in a script format on the client side and the server side alternately; decomposing the script source into script sources for the client / server respectively Generating step, one step of the generated script source is given by “variable = variable”, and when the right side is a server side variable, the right side variable is transmitted to the client and the communication program source code to be input to the left side variable is When the right side is a client side variable, the right side variable is transmitted to the server, and the source code of the communication program to be input to the left side variable is generated.

[0008]

[0009]

[0010]

BEST MODE FOR CARRYING OUT THE INVENTION

Embodiment 1 FIG. FIG. 1 is a block diagram showing the configuration of the client / server program generation device according to the first embodiment of the present invention. In FIG. 1, reference numeral 101 denotes a script source code which is a script source created by a user, and reference numeral 102 denotes a script source code.
01 and parse it to get the client logic
Save area 105 and server logic save area 10
6 and a syntax analysis unit that outputs the external variable table 107. The syntax analysis unit 102 includes a communication logic processing unit 10
3 and an external variable processing unit 104 are included.

Reference numeral 111 denotes a client / server C source generation unit as a client / server source generation unit for converting the script format source code output from the syntax analysis unit 102 into each C source code in C language. Is the converted client-side C source, 11
Reference numeral 3 denotes a converted server-side C source. A language processing unit 114 generates each execution program from the client-side C source 112 and the server-side C source 113 by using a compiler / linker provided in advance. Reference numeral 115 denotes a generated client-side execution program, and reference numeral 116 denotes a generated server-side execution program.

FIG. 2 is a diagram showing an example of the script format source code 101 shown in FIG. This script format is executed in order from top to bottom, and client side logic and server side logic can be mixed and described. The client side logic is "CLBegi
n "to" CLEnd "and the server side logic is described between" SVBegin "and" SVEnd. "There may be any number of sets of" xxBegin "to" xxEnd "in the script. Regarding the cooperation logic between the client and the server, variables defined by “Ext”, in this example, “CA”, “CB”, “S”
It is described using external variables “X” and “SY”.

The flow of the logic of the script shown in the example will be described in detail. In “Ext CA, CB”, a client-side external variable used for the cooperation logic is defined and “INPU
The client waits for data input to the CA at "TCA", and the input data is substituted into the CA by the user inputting data. The next "Ext SX, SY" is a server-side external variable used for the cooperation logic. Definition
“SX = CA” and the client external variable CA is S
Substituted for X. In the client-side C source 112 and the server-side C source 113 shown in FIG.
The part substituted for X is converted as communication logic.

The next "SY = SX * 30 + 100" is an arithmetic expression, and the calculation result is substituted for SY. When the next “CB = SY” and SY, which is a server external variable, is substituted into CB and converted into C source, it is converted as communication logic. In the next “OUTPUT CB”, the value of the CB is output to a screen or the like of the client.

As described above, since a client / server program can be described in a script format that can be easily expressed, knowledge of a specific language is not required. In addition, since the processes in the client and the server can be described alternately from top to bottom in the order of execution, data transmission / reception between the client and the server and each process in the client and the server can be described without fail. .

Next, FIG. 3 shows a client-side script format source code 109 which is obtained by parsing the example of the split format source code shown in FIG. 2 by the syntax analyzer 102 shown in FIG. It is an example of a server-side script format source code 110. Here, "CLE
“xt” represents the client-side external variable definition shown in FIG. 2, and “SVExt” represents the server-side external variable definition.
“SEND” and “RECV” are communication logics embedded corresponding to the coordination logic in the above-described split format source code. “SEND” indicates data transmission,
“RECV” indicates waiting for data reception.

FIG. 4 shows a processing flow of the syntax analyzer 102. Introduction source code 10
1 are opened (step 201), and records are sequentially input one by one from the beginning of the file (step 202). If there is no input record (EOF), the process proceeds to step 212. If one record is successfully input, the process proceeds to the next process (step 203). In step 204, it is determined whether or not the syntax of the script is “CLBegin” or “CLEnd” or “SVBegin” or “SVEnd”. When YES is “CLBegin”, the CL flag is turned on. Turn off the CL flag, turn on the SV flag when "SVBegin", and turn off the SV flag when "SVEnd".
FF is set and the process returns to step 202 (step 20).
5).

If NO in step 204, the type of the script is determined, and if "variable = variable", the process proceeds to the communication logic processing unit 103 (step 207), and returns to the process in step 202, where "Ext variable, variable・ ・ ”
In the case of, the process proceeds to the external variable processing unit 104 (step 20).
8) Return to the process of step 202, otherwise proceed to flag check (step 209) (step 2)
06). In step 209, the CL flag and the SV flag are checked for ON / OFF. When the CL flag is ON, the input record in step 202 is additionally output to the client logic save area 105 (step 21).
0), and when the SV flag is ON, the input record in step 202 is additionally output to the server logic save area 106 (step 211). After the processing of step 210 and step 211, the process returns to step 202 to input the next record.

At step 212, the external conversion table 1
07 and the contents of the client logic save area 105 are merged and output to the client side script format source code 109.
7 and the contents of the server logic save area 106 are merged into a server-side script format source code 110.
And the process ends.

Next, FIG. 5 shows a processing flow of the communication logic processing unit 103. First, ON / OFF check of the CL flag and the SV flag is performed. When the CL flag is ON, the process proceeds to step 303, and when the SV flag is ON, the process proceeds to step 308 (step 301). Step 3
At 03, if the right-hand variable of “variable = variable” is a server-side variable in the contents of the record input at step 202 in FIG. 4, “RECV right-hand variable” is input to the client logic save area 105 as 202. The record contents are additionally output as they are, and “SEND right side variable” is additionally output to the server logic save area 106 (step 304, step 305, step 306). If NO in step 303, the record does not require communication processing, so the client logic save area 10
Only the contents of the record input at 202 in step 5 are additionally output as they are (step 307).

In step 308, if the variable on the right side of "variable = variable" is a client-side variable in the contents of the record input in 202, "RECV right-side variable" is stored in the server logic save area 106 as shown in FIG. 20
The contents of the record input in step 2 are additionally output as they are, and “SEND right-side variable” is additionally output to the client logic save area 105 (step 309, step 3)
10, step 311). If NO in step 308, since the record does not require communication processing, the record content input in 202 in the server logic save area 106 is additionally output as it is (step 312).

FIG. 6 shows a processing flow of the external variable processing unit 104. First, turn on the CL flag and SV flag
/ OFF check, and if the CL flag is ON, the process proceeds to step 402. If the SV flag is ON, the process proceeds to step 4
03 (Step 401). Step 402
Then, the variable specified after “Ext” in the contents of the record input in step 202 of FIG. 4 is additionally output to the external variable table 107 as a client-side external variable.
In step 403, the variable specified next to "Ext" in the contents of the record input in step 202 of FIG. 4 is additionally output to the external variable table 107 as a server-side external variable.

FIG. 7 shows a processing flow of the client / server C source generation unit 111. First, the client-side script format source code 109 is opened as an input file (Step 601), the client-side C source 112 is opened as an output file (Step 602), and the external variable information of the input file is output to the output file in C language format. The data is output (step 603), and records are sequentially input one by one from the top of the logic section of the input file (step 604). When there is no record in the logic part of the input file (EOF), step 613 is executed.
If one record is successfully input, the process proceeds to step 606 (step 605).

In step 606, the type of the script which is the record data input in step 604 is determined. For example, in the case of "INPUT", the input logic is additionally output to the output file in C language (step 607).
In the case of "OUTPUT", the output logic is additionally output to the output file in C language (step 608), and "SEN" is output.
In the case of "D", the synchronous transmission logic is additionally output to the output file in C language (step 609). In the case of "RECV", the synchronous reception logic is additionally output to the output file in C language (step 610). In the case of, additional arithmetic logic is added to the output file in C language (step 6
11) Perform conversion output to C language using different subroutines according to the type of script,
From the logic section of the input file to the new record input.

In step 613, it is determined whether or not the client-side script format source code 109 and the client-side C source 112 are open. If YES, the files are closed (step 614, step 615) and input files are set. The server-side script format source code 110 is newly opened (step 616), and the server-side C source 1 is output as an output file.
13 is opened (step 617), and step 603 is executed.
Return to If NO, the server-side script source code 110 and the server-side C source 1 that are currently open
13 and the process of the generating unit is terminated.

Next, FIGS. 8 and 9 show step 60 in FIG.
9 is an output example in which the script of the communication part between the client and the server shown in the processing of Step 9 and Step 610 is converted into C language. In these examples, the communication protocol is TCP
/ IP is used. FIG. 8 is a conversion example of the script “SEND CA” when “CA” is character string data, and FIG. 9 is a conversion example of the script “RECV CA” when “CA” is character string data.

Next, the client-side execution program 11
5 and the server-side execution program 116 are generated by inputting the client-side C source 112 and the server-side C source 113 to the language processing unit 114 and using the C compiler / linker provided in advance. And the server-side execution program 108 is output.

As described above, in the present embodiment, the client unit and the server unit are described in the script format source code 101, and the coordination logic (data communication unit) is defined as an external variable. Generation is possible, the source can be unified, and there is no need to be aware of communication logic, so that productivity can be improved. In addition, the user modifies the client-side / server-side C source before the language processing unit 114 generates the executable format program, thereby adding logic that cannot be automatically generated by the script format source code 101 with the C language code. This allows fine-grained customization of the generated execution program.

In the first embodiment, a communication protocol definition for defining a communication protocol between the client-side / server-side programs to be generated may be provided. Thereby, the communication protocol between the client-side / server-side program generated according to the definition is determined, and the communication protocol definition can be floated. Therefore, each generated program can be operated on various networks. The environment can be varied.

Further, in the above embodiment, the client / server C source 11 which is generated as an intermediate file by recreating the client / server C source generation unit 111 and the language processing unit 114 so as to correspond to another language other than C language.
2. The server-side C source 113 can output as a source code of another language regardless of the C language, and the customization of the intermediate file can be performed in another language regardless of the C language. It can make it possible to increase the number of developers to perform.

[0031]

Since the present invention is configured as described above, it has the following effects.

[0032]

Since the source code of the communication program is generated by the script source given by “ variable = variable”, the execution program can be automatically generated without considering the communication logic, and the productivity is improved. I do.

[Brief description of the drawings]

FIG. 1 is a configuration diagram illustrating a client / server program generation device according to a first embodiment of the present invention.

FIG. 2 is a schematic diagram showing an example of a script format source code according to the first embodiment of the present invention.

FIG. 3 is a schematic diagram showing an example of a disassembled script format source code according to the first embodiment of the present invention.

FIG. 4 is a flowchart showing processing of a syntax analysis unit according to the first embodiment of the present invention.

FIG. 5 is a flowchart illustrating processing of a communication logic unit according to the first embodiment of the present invention.

FIG. 6 is a flowchart illustrating processing of an external variable processing unit according to the first embodiment of the present invention.

FIG. 7 is a flowchart showing processing of a client / server source generation unit according to the first embodiment of the present invention.

FIG. 8 is a diagram illustrating a script from the first embodiment of the present invention to C
It is a C source code showing an example of language conversion.

FIG. 9 is a diagram illustrating a script from the first embodiment of the present invention to C
It is a C source code showing an example of language conversion.

FIG. 10 is a configuration diagram showing a conventional client / server program generation device.

FIG. 11 is a configuration diagram showing a conventional communication processing program generation device.

[Explanation of symbols]

101 script format source code, 102 syntax analyzer, 111 client / server source generator.

Continuation of the front page (56) References JP-A-7-141179 (JP, A) JP-A-4-111022 (JP, A) JP-A-6-242938 (JP, A) IPSJ “39th ( 2nd 1989) National Convention Lecture Papers (▲ II ▼), Nomura and two other authors, "Conversion from Input Specifications to Programs in LOTOS Execution System", p. 1586-1587 (58) Field surveyed (Int.Cl. ⁷ , DB name) G06F 9/06 530 G06F 9/44 320 G06F 15/16

Claims (1)

(57) [Claims] 1. A step of writing a script source in a processing order alternately with a client side and a server side by attaching an identifier for identifying a client / server in a script format to a source code for starting the client / server. The step of decomposing and generating the script source for each server. If one step of the decomposed script source is given by "variable = variable" and the right side is a server side variable, send the right side variable to the client and input it to the left side variable A source code of a communication program to generate a source code of a communication program to generate a source code of a communication program to be transmitted, and to transmit a variable of the right side to a server when the right side is a variable on the client side and to input the variable to a variable on the left side. Generation method.