JP2003241974A - Executable object generating method and program - Google Patents

Abstract

<P>PROBLEM TO BE SOLVED: To provide an XML data communication technique facilitating a mounting and enabling the general handling of XML data. <P>SOLUTION: A definition file in which the definition of a predetermined structure is described by use of a markup language is generated. The definition file is converted to a program file and header file described in a high-level language. A user program including the header file, which is described in the high-level language, is generated. The program file and the user program is compiled to generate an executable object. <P>COPYRIGHT: (C)2003,JPO

Description

Detailed Description of the Invention

[0001]

TECHNICAL FIELD The present invention relates to XML (eXten).
More particularly, the present invention relates to data communication of data described in XML.

[0002]

2. Description of the Related Art In recent years, it has been desired to construct a system for performing data communication using XML. XML is a data description language, and APIs (Applications) of XML data that are constrained by the type definition of DTD.
The Program Interface) is not specified.

Therefore, when constructing a system for communicating XML data, it is necessary to consider the communication method and API separately, and it is the current situation that the number of development man-hours must be secured for that.

[0004]

SUMMARY OF THE INVENTION The present invention has been made in view of such a situation, and the problem to be solved by the present invention is easy to implement and general-purpose XML.
It is to provide XML data communication technology capable of handling data.

[0005]

In order to solve such a problem, the present invention provides the following method and computer program.

The present invention provides a method for compiling a user program to generate an executable object, which has the following characteristics. That is, the step 1 of generating a definition file in which the definition of a predetermined structure is described using a markup language, and the definition file are
Step 2 of converting into a program file and a header file written in a high-level language, step 3 of generating a user program written in a high-level language that is a program including the header file, and a program file and a user program And a step 4 of compiling an executable object to generate an executable object.

In this executable object generation method, the markup language is, for example, XML (eXtensi).
ble Markup Language).

The structure preferably contains a type definition for the data. The data is particularly effective when it is numerical data.

Step 4 is a step of compiling a program file and a user program to generate a relocatable object, and a step of linking the relocatable object with a library prepared in advance to generate an executable object. May be included.

In step 2, the definition file may be converted into a program file and a header file written in different high level languages.

Further, the present invention is a preprocessor for causing a computer to execute a process of converting a definition file in which a definition of a predetermined structure is described in a markup language into a program file and a header file described in a high level language. Offer the program.

Further, the present invention provides a program for causing a computer to execute a process of compiling a user program written in a high-level language to generate an executable object, the program having the following characteristics.
That is, a process 1 of converting a definition file in which the definition of a predetermined structure is described in a markup language into a program file and a header file described in a high level language.
And a user program including a header file, and a process 2 of compiling a program file to generate an executable object in a computer.

In this executable object generation program, the markup language is, for example, XML (eXte).
It is a nable markup language).

The structure may also include a type definition for the data. It is particularly desirable that the data is numerical data.

Process 2 is a process of compiling a program file and a user program to generate a relocatable object, and a process of linking the relocatable object and a library prepared in advance to generate an executable object. May be included.

In the process 1, the definition file may be converted into a program file and a header file described in different high level languages.

Further, the present invention provides a recording medium storing the above program and a computer storing the recording medium.

[0018]

BEST MODE FOR CARRYING OUT THE INVENTION In XML, DTD (Docum) is used.
The data type definition can be performed using ent Type Definition). In the present invention, first, a structure that can be used by an application program is generated using DTD. In the following, Xac is used to generate a DTD that can be used by the application program.
It is referred to as tDTD. Next, using this structure, an executable program for transmitting / receiving XML format data is generated.

1. First Embodiment A process from generation of XactDTD to generation of an executable program capable of transmitting and receiving data in XML format will be described with reference to FIG.

First, the user defines a structure to be transmitted / received, describes this structure using DTD, and
Create actDTD1.

Next, XactDTD1 is replaced with XactDTD.
Apply to preprocessor 2. The XactDTD preprocessor 2 converts the XactDTD1 and generates the XactDTD program 3 and the XactDTD header file 4. These Xact DTD program 3 and Xact
Both the DTD header files 4 are described in a predetermined high level language. The high-level language may be any compiler language, such as C, C ++, and Java (registered trademark). XactDTD program 3 is XactD
Include TD header file 4 (include
e) is generated.

In this state, the user creates the user program 5, which is the source program of the target executable object, using a high-level language. At this time, Xac
The user program 5 is created by including the tDTD header file 22.

The user execution program 7 is generated by compiling 6 the user program 5 thus created. The user execution program 7 is a relocatable object.

On the other hand, the XactDTD program 3 is also compiled 8 to generate the XactDTD execution program 9. The XactDTD execution program 9 is a relocatable object.

The two relocatable objects thus generated, the user execution program 7 and the XactDTD execution program 9, are the library prepared in advance, Xact.
It is linked 12 together with the DTD library 10 and the communication class library 11, and finally the executable program 13 is generated as an executable object.

The Xact DTD library 10 includes element division of a telegram, a primitive type (int type, ENU).
Mutual conversion between M type) and character string representation, base class of each element, template for OF type, input / output auxiliary function are provided.

The communication class library 11 is a collection of frequently used functions related to communication. For example, the function hiString or the function hiTCPSock.
There is. The function hiTCPSock is a hiStream communication function that represents a TCP socket. The server side uses hiConnector to declare the connection port, and the client side uses the server
Specify the hiConnector name to connect.

[0028]

[Equation 1]

In DTD, the structure of data can be defined, but a method for defining data types such as integer type and floating point type is not defined. In contrast, XactDT
In D, it is possible to define these data types by giving type attributes to integer types and floating point types. Note that we did not extend the syntax rules of DTD in making this definition.

FIG. 2 shows an example of XactDTD1. The numbers arranged vertically on the right side of the figure are numbers indicating the number of lines added for convenience of description. The contents of each line will be described below. Declare MyType as the root element name (21st
line). Element MyType contains elements x and i as its child elements (line 22). Element x includes elements s and f as child elements (line 23). The value of the element i is character string data (24th line). The element i has an attribute xact and its data type is an arbitrary character string. The attribute value has a 32-bit integer type as a default value and cannot be changed from this value (lines 25 and 26). The value of the element s is character string data (27th line). The element s has an attribute xact and the data type is an arbitrary character string. Floating point type is used as the default attribute value, and it cannot be changed from this value (28th,
Line 29).

The user program 5 corresponding to the example of FIG. 2 will be described with reference to FIG. In this example, the user program 5 is written in C ++. The numbers arranged vertically on the right side of the figure are added to indicate the number of lines. First, as the XactDTD header file 4, Xact
_MyType. Include h (line 31).
Structure variable d with structure type Xact_MyType
Declare ata (line 33). Substitute 100 for the element i of the structure variable data (line 34). Structure variable d
The character string abc is substituted for the element s included in the element x of ata (line 35). 1.23 is assigned to the element f included in the element x of the structure variable data (line 36). The structure data has a file name sample. Output as xml (lines 37, 38).

The executable program 13 generated based on the user program 5 illustrated in FIG. 3 is a file samp.
le. A file as shown in FIG. 4 is output as xml.

Executable program 1 generated in this way
It is conceivable that 3 acts as an intermediary between an operating system (OS) and an application program, for example.
As a specific example, an API (Application P
program interface). Alternatively, it may be a program that can be executed independently on the OS.

In this way, the user can use the XML DTD.
By using a simple structure API,
It becomes possible to generate an execution program capable of transmitting and receiving ML data.

2. Second Embodiment Next, a monitoring system using the execution program thus generated will be described with reference to FIG. In this monitoring system, the state of the monitoring target device 50 is monitored by the monitoring device 60. The state of the monitoring target device 50 is transmitted to the monitoring device 60 as XML data.

The device to be monitored 50 includes hardware 51,
An operating system (OS) 52 operating on the hardware 51 and a monitoring target device application 53 operating on the OS 52.

The monitoring target device application 53 includes a user application 55 that monitors the monitoring information 54 indicating the status to be monitored. The user application 55 monitors the monitoring information 54 by polling, for example, and when detecting a predetermined change, passes the monitoring information 54 to the executable program 13a.

The executable program 13a is a program corresponding to the executable program 13 described in the first embodiment, and converts the monitoring information 54 into XML data. Further, by using socket communication or the iostream function, the monitored device application 53, the OS 52,
Also, the XML data is transmitted to the monitoring device 60 via the hardware 51.

The monitoring device 60 comprises hardware 61, an OS 62 operating on the hardware 61, and a monitoring device application 63 operating on the OS 62. The monitoring device 60 includes the hardware 61, the OS from the monitored device 50.
62 via the monitor application 63 and the monitor application 63
When the data is received, XM is executed by the executable program 13b.
The L data is converted into a desired data format. The executable program 13b is also a program corresponding to the executable program 13 described in the first embodiment. The converted data is passed to the user application 64. The user application 64 is a program that constitutes the monitoring device application 63, performs predetermined processing on the received data, and passes the data to the user interface application 65. The user interface application 65 is the monitoring device application 6
3, which is one program constituting the data No. 3, and displays the received data on the display 66.

In this way, the monitoring information 54 acquired by the monitored device 50 is transmitted to the monitoring device 60 as XML data and displayed on the display 66. Thus
The user of the monitoring system can know the monitoring information 54 acquired by the monitored device 50 at a remote location.

When operating the monitoring information from the user, the user interface application 6 needs to be input by the user.
5 receives and sends to the user application 64.
The user application 64 is the executable program 1
3b is used to send the XML data to the monitored device application 53. In the monitoring target device application 53, the user application 55 converts the received XML data using the executable program 13a,
The monitoring information 54 is updated according to the received contents. Alternatively, through the monitoring target device application 53, O
It controls S52 and further controls the hardware 51.

In this way, the monitoring target device application 53 and the monitoring device application 63 can communicate with each other by XML data and handle the XML data respectively.

3. Third Embodiment In the monitoring system of the second embodiment, the monitored device 5
0 and the monitoring device 60 have a one-to-one correspondence. On the other hand, in the monitoring system of the third embodiment, the correspondence between the monitoring target devices and the monitoring devices is not constant, and an unspecified number of monitoring target devices are monitored by the unspecified number of monitoring devices. Here, for convenience of description, a system including two monitoring target devices and two monitoring devices is illustrated.

Referring to FIG. 6, in the third embodiment, two monitoring target devices 50a and 50b and two monitoring devices 60a and 60b are connected to the network 7.
It is connected through 0. Network 70 is a LAN
(Local Area Network), WAN
(Wide Area Network), the Internet, etc. are considered. The monitoring device 60a can monitor both of the monitoring target devices 50a and 50b as necessary. Similarly, the monitoring device 60b can monitor both of the monitoring target devices 50a and 50b as necessary.

The monitored device 50 corresponding to the monitored devices 50a and 50b will be described with reference to FIG. Compared to the monitored device 50 in the second embodiment, the difference is that the input / output destination of the XML data is the network 70 and the monitored device application 53 includes the communication management application 56.

The monitoring device 60 corresponding to the monitoring devices 60a and 60b will be described with reference to FIG. Second
Compared with the monitoring device 60 according to the embodiment, similarly, the input / output destination of the XML data is the network 70, and the monitored device application 63 includes the communication management application 67.

Communication management applications 56 and 67
Is a program for managing communication via the network 70, and specifically, for managing a plurality of connections,
Performs processing such as encryption check. When receiving the data, the executable program 13 is used to convert the XML format data into a desired data format, and the converted data is passed to the user application 55 or 64. On the other hand, when transmitting data, when the data is received from the user application 55 or 64, the executable program 1
3 is used to convert the data into XML format, and then the data is sent to the network 70.

According to the third embodiment, since complicated communication management can be performed, an unspecified number of devices can be arbitrarily combined, and XML data can be transmitted and received between the combined devices.

Although the present invention has been described based on the embodiments, the present invention is not limited to this, and modifications and improvements can be made within the scope of ordinary knowledge of those skilled in the art. Of course.

[0050]

According to the present invention, a simple API is provided from the DTD definition, and the API has a communication function, so that the following effects can be obtained.

(1) By the Xact DTD compiler,
Since a structure with strict type checking is generated,
Handling of XML data and implementation of applications become easy.

(2) Since the API has a communication function, it becomes easy to send and receive XML data.

(3) By defining a PRIMITIVE type definition such as INT type within the range of the DTD definition,
Easy to implement application.

[Brief description of drawings]

FIG. 1 is a flowchart illustrating a method for generating an executable program according to a first embodiment of this invention.

FIG. 2 is an example of XactDTD definition 1.

FIG. 3 is an example of a user program 5 written in C ++.

4 is an X output when an executable program 13 generated by compiling the user program 5 of FIG. 3 is executed.
It is ML data.

FIG. 5 is a functional block diagram of a monitoring system according to a second embodiment of the present invention.

FIG. 6 is a diagram illustrating a network configuration of a monitoring system according to a third embodiment of this invention.

FIG. 7 is a functional block diagram of a monitoring target device 50 according to the third embodiment.

FIG. 8 is a functional block diagram of a monitoring device 60 according to a third embodiment.

[Explanation of symbols]

1 XactDTD definition 2 Xact DTD preprocessor 3 Xact DTD program 4 XactDTD header file 5 user program 6, 8 compiler 7 user execution program 9 XactDTD execution program 10 Xact DTD Library 11 Communication class library 12 links 13 executable programs 50, 50a, 50b Monitored device 51, 61 hardware 52, 62 Operating System (OS) 53 Monitored device application 54 Monitoring information 55, 64 User application 60, 60a, 60b monitoring device 63 Monitoring device application 65 User Interface Application 66 display 70 network

   ─────────────────────────────────────────────────── ─── Continued front page    (72) Inventor Kiyoshi Hiura             Kamirenjaku 1-1-5-506, Mitaka City, Tokyo F-term (reference) 5B081 AA10 CC01 CC41

Claims (15)

[Claims] 1. A method of compiling a user program to generate an executable object, the step 1 of generating a definition file in which a definition of a predetermined structure is described using a markup language, and the definition file. Is converted into a program file and a header file described in a high-level language, and a step 3 is a program including the header file and a user program described in the high-level language is generated. A step 4 of compiling a file and a user program to generate an executable object. 2. The executable object generation method according to claim 1, wherein the markup language is XML (e.
Xtensible Markup Languag
e) An executable object generation method characterized in that 3. The executable object generation method according to claim 1, wherein the structure includes a data type definition. 4. The executable object generation method according to claim 3, wherein the data is numerical data. 5. The executable object generation method according to claim 1, wherein the step 4 is a step of compiling the program file and a user program to generate a relocatable object. A method of generating an executable object, comprising the step of linking a relocatable object with a library prepared in advance to generate the executable object. 6. The method for generating an executable object according to claim 1, wherein the step 2 converts the definition file into the program file and header file described in different high level languages. An executable object generation method characterized by the above. 7. A preprocessor program for causing a computer to execute a process of converting a definition file in which a definition of a predetermined structure is described in a markup language into a program file and a header file described in a high level language. 8. In a program for causing a computer to execute a process of compiling a user program written in a high-level language to generate an executable object, a definition of a predetermined structure written in a markup language. Process 1 for converting a file into a program file and a header file described in the high-level language; a process for compiling the user program including the header file and the program file to generate an executable object 2. An executable object generation program characterized by causing a computer to execute 2 and. 9. The executable object generation program according to claim 8, wherein the markup language is XM.
L (eXtensible Markup Language)
An executable object generation program characterized by being ge). 10. The executable object generation program according to claim 8, wherein the structure includes a data type definition. 11. The executable object generation program according to claim 10, wherein the data is numerical data. 12. The executable object generation program according to claim 8, wherein the processing 2 compiles the program file and a user program to generate a relocatable object, An executable object generation program including a process of linking a relocatable object and a library prepared in advance to generate the executable object. 13. The executable object generation program according to claim 8, wherein the processing 1 converts the definition file into a program file and a header file described in different high level languages. An executable object generation program characterized by: 14. A recording medium storing the program according to claim 7. 15. A computer in which the recording medium according to claim 14 is stored.