JP2004038319A - Program source code generation method and program - Google Patents

Abstract

<P>PROBLEM TO BE SOLVED: To reduce a labor required for generating a program source code for materializing functions of serializing and deserializing data. <P>SOLUTION: A program source code automatic generation part 20 (20a, 20b, and the like) refers a set showing units of serializing and deserializing the data and a definition file 22 of data structure defined with elements for serializing and deserializing in the set, generates the program source code for serializing and deserializing the data based on the elements included in the set, classifies the program source codes produced based on the elements, and generates the program source code file 24 including the program source code for serializing and deserializing the set. <P>COPYRIGHT: (C)2004,JPO

Description

[0001]
TECHNICAL FIELD OF THE INVENTION
The present invention relates to a program source code generation method for generating a program source code, and a program source code generation program.
[0002]
[Prior art]
Generally, in an information processing apparatus such as a computer, when data managed on a predetermined data structure and recorded on a recording medium is transmitted through a communication path and recorded on another recording medium, the information processing apparatus has a predetermined data structure. A process is performed in which data is serialized (serialized) and then transmitted through a communication path, and the serialized data is deserialized (structured) and structured to have an original data structure.
[0003]
For example, in a personal computer, when data to be processed is written back to a hard disk device, the data is serialized according to a data structure (for example, a hierarchical structure) managed by the program, and the serialized data is structured. Structuring by
[0004]
Conventionally, when creating a program for serializing and structuring data having such a predetermined data structure, a programmer creates a program source code while referring to a specification or the like in which the definition of the data structure is described. In the definition of the data structure, for example, the definition of an aggregate corresponding to each of the program source code files to be created and information on data (size and data type (character string, numeric value, etc.)) in the aggregate are defined. .
[0005]
In accordance with the definition of the data structure, the programmer writes a program source code for serializing and structuring data by a predetermined method using a target programming language.
[0006]
Japanese Patent Application Laid-Open No. 5-216683 describes a non-language-dependent filing procedure automatic generation method for automatically generating a filing procedure without depending on a program description language. This generation method creates a target file of a target machine from a source program, and refers to configuration definition data that defines files related to the target file defined in the database, and automates the file creation procedure. Means for generating.
[0007]
[Problems to be solved by the invention]
As described above, conventionally, when generating a program source code for realizing a function of serializing and structuring data, a programmer refers to a defined data with reference to a specification or the like in which a definition of a data structure is described. It is necessary to input a program source code corresponding to a structure, that is, a description that defines an aggregate and elements in each aggregate.
[0008]
For this reason, if the number of aggregates and elements is large in the definition of the data structure, or the data structure is a multi-level hierarchical structure or the definition of elements is complicated such that the definition of another aggregate is cited. By the time, programmers had to enter the program source code with great effort.
[0009]
Further, when the definition of the data structure is partially changed, it is necessary to regenerate the program source code or to extract and change the source code that needs to be changed. Further, even when the method of serialization and structuring is changed, or the target programming language is changed, the program source code may need to be regenerated, which requires a great deal of labor.
[0010]
Further, the method for automatically generating a filing procedure disclosed in Japanese Patent Application Laid-Open No. 5-216683 enables human error prevention and time reduction by automating the filing procedure creation. It created the target file for the machine, not the program source code.
[0011]
SUMMARY OF THE INVENTION The present invention has been made in view of the above circumstances, and has a program source code capable of reducing an effort required to generate a program source code for realizing a function of serializing and deserializing data. It is an object to provide a generation method and a program source code generation program.
[0012]
[Means for Solving the Problems]
The present invention is a program source code generation method for generating a program source code for realizing a function of serializing and deserializing data. Referring to the information in which the elements to be serialized and deserialized in the aggregate are defined, a program source code for serializing and deserializing data based on the elements included in the aggregate is referred to. And generating a program source code for serializing and deserializing the set with respect to the aggregate by combining the generated program source codes based on the elements.
[0013]
When a plurality of aggregates are defined in the information, a program source code is generated for each aggregate.
[0014]
BEST MODE FOR CARRYING OUT THE INVENTION
Hereinafter, embodiments of the present invention will be described with reference to the drawings. FIG. 1 is a block diagram showing a functional configuration for realizing the program source code generation method according to the present embodiment. The program source code generation method according to the present embodiment is realized by executing a program source code generation program on a computer. The computer may be, for example, reads a semiconductor memory, CD-ROM, DVD, program source code generation program recorded in a recording medium such as a magnetic disk, the operation by the program is controlled.
[0015]
As shown in FIG. 1, the program source code generation method includes functions of a source code generation processing unit 10, a definition file storage unit 12, a source code file storage unit 14, a definition file change unit 16, and a change unit 18.
[0016]
The source code generation processing unit 10 executes a process of generating a program source code based on information defining a data structure, and has a function of a program source code automatic generation unit 20 (20a, 20b,...). The program source code automatic generation unit 20 implements a function of referring to the definition file 22 of the data structure stored in the definition file storage unit 12 and serializing and structuring data according to the data structure defined in the definition file 22. Generate program source code for
[0017]
Note that the source code generating unit 10, a plurality of program source code automatic generation unit 20a, a 20b ... provided. Each of the program source code automatic generation units 20a, 20b,... Is provided with a function of generating a program source code according to a difference in a programming language of a program source code to be generated or a difference in a method of serialization and structure. Is selected and executed.
[0018]
The definition file storage unit 12 stores a definition file 22 of a data structure based on a program source code generated by the source code generation processing unit 10 (program source code automatic generation unit 20). The data structure definition file 22 includes an aggregate indicating units for serializing (serializing) and structure (deserializing) data and information defining elements to be serialized and structured in the aggregate. .
[0019]
Source code file storage unit 14 stores a program source code file 24 generated by the source code generation process unit 10 (program source code automatic generation unit 20).
[0020]
The definition file changing unit 16 changes the definition file 22 of the data structure stored in the definition file storage unit 12, and when the program source code for a different data structure is regenerated, the data in the definition file is changed. Change the structure definition.
[0021]
The changing unit 18 generates the program source code according to the difference in the programming language of the program source code or the method of serialization and structure, based on the definition file 22 of the data structure as necessary. changing the program source code automatic generation unit 20 for generating a code file 24, i.e. a plurality of program source code automatic generation unit 20a, 20b ... or selected and to execute the. .. Are provided in the source code generation processing unit 10 and a plurality of program source code automatic generation units 20a, 20b... Are not selected and used. The generator 20 may be changed or replaced with another program source code automatic generator 20.
[0022]
Next, an operation of creating a program source code in the present embodiment will be described with reference to a flowchart shown in FIG.
[0023]
FIG. 3 shows an example of information defined in the definition file 22 of the data structure from which the program source code file 24 is generated. The data structure definition file 22 includes an aggregate indicating units for serializing and structuring data, and information defining elements to be serialized and structured in the aggregate. In the example shown in FIG. 3, one aggregate “aggregate 1” is defined, and two elements “element A” and “element B” are defined in the “aggregate 1”. In the element, for example, information on data size and data type (character string, numerical value, etc.) is defined.
[0024]
First, the program source code automatic generation unit 20 refers to the definition file 22 of the data structure, and determines the presence or absence of the defined element in the aggregate defined in this file (step A1). If an element is defined in the aggregate, the element is read (step A2). In the example shown in FIG. 3, the "element A" to "assembly 1""PartB" is defined, first reads the definition of "element A".
[0025]
The program source code automatic generation unit 20 generates a program source code for serializing and structuring data by a predetermined method based on element information (that is, data size and data type) (step A3).
[0026]
For example, in a program source code for serializing data, a procedure for sequentially storing data defined in each element on the stack while sequentially updating the position of the stack is described. Also, the program source code that structures the data reads the data stored in the stack while sequentially updating the position of the stack so as to reverse the serialization procedure, and constructs the data defined by each element. The procedure is described (note that specific examples are shown in FIGS. 5 and 6).
[0027]
Next, the program source code automatic generation unit 20 refers to the definition file 22 in the same manner as described above, determines the presence or absence of the defined element in the aggregate defined in this file (step A1), If an element is defined in the body, the element is read (step A2). In the example shown in FIG. 3, next, the definition of “element B” is read.
[0028]
The program source code automatic generation unit 20, based on the information elements, the program source code to produce for serializing and structuring the data by a predetermined method (step A3).
[0029]
Hereinafter, similarly, the above-described processing is repeatedly executed by the number of elements defined in the aggregate, and a program source code for serializing and structuring data of each element is generated (steps A1 to A3).
[0030]
In this way, when the program source code for serializing and structuring the data of each element included in the aggregate defined in the data structure definition file 22 is generated, the program source code for serializing and structuring the aggregate collectively is generated. A code is generated and stored in the source code file storage unit 14 as a program source code file 24 (step A4).
[0031]
In this way, the program source code automatic generation unit 20 refers to, for example, the definition file 22 having the data structure shown in FIG. 3, and as shown in FIG. 4, the elements A and B described in the definition file 22. data can handle, it is possible to program source code file 24 of program source code to serialize and structuring the assembly 1 automatically generates.
[0032]
Next, a specific example of a program source code for serializing and structuring data will be described.
FIG. 5 is a diagram showing a specific example of definition contents corresponding to the definition file 22 of the data structure shown in FIG. 3, and FIG. 6 is a program source code automatically generated according to the definition of the definition file 22 of the data structure shown in FIG. FIG. 3 is a diagram showing a specific example of a program source code file 24 generated by a unit 20.
[0033]
As shown in FIG. 5, in the definition file 22 of the data structure, “element A” has data of “long” size (for example, 4 bytes) as described in “<type> long </ type>”. It is defined that “element B” is character string data as described in “<type> String </ type>”.
[0034]
Program source code automatic generation unit 20, to the description of the definition file 22 shown in FIG. 5, to generate a program source code file 24 as shown in FIG. The program source code file 24 shown in FIG. 6 includes the serialized program source code shown in (1) and the structure program source code shown in (2).
[0035]
The serialization of program source code (1), includes a source code (1B) is for the data of the source code (1A) and the element B with respect to the data elements A.
[0036]
In the source code (1A), the data of the element A is stored in the stack position indicated by “stack [count]” while securing the data size for the data of the element A (description of the line “memcpy ...”). includes a source code indicating that the location to store the next data stack data content update element a (described in the line of "count = ...").
[0037]
In the source code (1B), the length of the data (character string) of the element B is defined (description of the line of “size = ...”), and the length is defined at the stack position indicated by “stack [count]”. Data indicating the length of the data of the element B (“size”) is secured and stored for this data (description of the line “memcpy (& stack ... sizeof (size)”)), and the data is stored after the stack Includes a source code indicating that the position to be updated is updated by the data indicating the length of the data of the element B (description of the line of "count = ..."), that is, before the data of the element B is stored in the stack. A source code for storing data indicating the length of the data (character string) of the element B. Next, the source code is stored at the stack position indicated by “stack [count]”. The data of B is stored while securing the data size for the data of the element B (description of the line of “memcpy (& stack ... size)”), and the position where the data is stored next to the stack is updated by the data of the element B. (Description of the line of “count =...”) Is included.
[0038]
On the other hand, the structure of the program source code (2) includes a source code (2B) is for the data of the source code (2A) and the element B with respect to the data elements A.
[0039]
In the source code (2A), data is read from the stack as element A data in a procedure reverse to the description of the program source code (1A) for serializing element A, and similarly, the source code (2B) , A program source code that reads data from the stack and sets it as element B data in a procedure reverse to the description of the serialization program source code (1B) for element B. The data elements B, reads data indicating the length of data of the previous element B (string), and reads out the length of the data in accordance with this data.
[0040]
By preparing the definition file 22 having the data structure as shown in FIG. 5 in this manner, the data as shown in FIG. 6 can be serialized and structured according to the contents defined in the definition file 22. Program source code file can be automatically generated.
[0041]
The description of the elements in the definition file 22 shown in FIG. 5 is merely an example, and can be described in various formats. The program source code automatic generation unit 20 is provided with a function of generating a program source code for serialization and structuring according to the definitions based on these various descriptions.
[0042]
Next, a case where a data structure including a plurality of aggregates is defined in the definition file 22 will be described.
In the above description, the aggregate is directed to the data structure of one simple pattern. However, the program source code automatic generation unit 20 in the present embodiment has a plurality of aggregates, and the definition of the elements in the aggregate is It is also possible to target a complicated pattern data structure that cites the definition of another aggregate.
[0043]
FIG. 7 is a flowchart illustrating an operation of creating a program source code when the definition file 22 having a data structure in which a complicated pattern data structure is defined according to the present embodiment is targeted.
[0044]
FIG. 8 shows an example of a definition file 22 having a complicated pattern data structure in which there are a plurality of aggregates, and the definitions of the elements in the aggregates refer to the definitions of other aggregates. The data structure definition file 22 includes information defining a plurality of aggregates 1 and 2 and elements to be serialized and structured in the aggregates 1 and 2. In the example shown in FIG. 8, two elements “element A” and “element B” are defined in “aggregation 1”, and three elements “element A”, “element B” and “element C” are defined in “aggregation 2”. Is defined. Incidentally, elements C of the assembly 2 (shown in FIG. 10 (23) for example) is assumed to be a definition of reference in its entirety assembly 1.
[0045]
First, the program source code automatic generation unit 20 refers to the definition file 22 of the data structure, and determines the presence or absence of an aggregate defined in this file (step B1). Here, if an aggregate is defined, the aggregate is read (step B2). In the example shown in FIG. 8, the two "assemblies 1", "assembly 2" is defined, first I read the "assembly 1".
[0046]
Then, the program source code automatic generation unit 20, this read assembly, to determine the presence or absence of elements defined (step B3). Note that the following processes of steps B3 to B6 shown in FIG. 7 are executed in the same manner as the processes of steps A1 to A4 of the flowchart shown in FIG.
[0047]
When the program source code automatic generation unit 20 generates the program source code file 24 for one aggregate, the program source code automatic generation unit 20 refers to the definition file 22 in the same manner as described above, and determines whether there is another aggregate defined in this file. It is determined (step B1), and if an aggregate is defined, the aggregate is read (step B2). Similarly, a program source code file 24 for this aggregate is generated (steps B3 to B5). In the example shown in FIG. 8, then load the assembly 2, to generate a program source code file 24 for this assembly 2.
[0048]
In the same manner, and repeatedly executes the processes described above the number of the aggregate to produce the program source code file 24 for each aggregate.
[0049]
In this way, the program source code automatic generation unit 20 refers to, for example, the data structure definition file 22 shown in FIG. 8 and obtains the aggregate described in the data structure definition file 22 as shown in FIG. 1,2 it is possible to automatically generate a program source code file 24 made from program source code to serialize and structure respectively. That is, a program source code file 24 that can handle the data of elements A and B for the aggregate 1 and can handle the data of the elements A, B and C for the aggregate 2 can be generated. .
[0050]
Next, a specific example of a program source code for serializing and structuring data, which corresponds to FIGS. 8 and 9, will be described.
FIG. 10 is a diagram showing a specific example of definition contents corresponding to the definition file 22 of the data structure shown in FIG. 8, and FIG. 11 is a diagram showing the definition of the aggregate 1 of the definition file 22 of the data structure shown in FIG. FIG. 12 shows a specific example of a program source code file 24 generated by the program source code automatic generation unit 20. FIG. 12 is generated according to the definition of the aggregate 2 of the definition file 22 having the data structure shown in FIG. FIG. 3 is a diagram showing a specific example of a program source code file 24.
[0051]
As shown in FIG. 10, the definition file 22 of the data structure describes the definition (1) of the aggregate 1 and the definition (2) of the aggregate (2).
The definition (1) of the aggregate 1 includes a definition (11) for the element A and a definition (12) for the element B. The description of the definitions (11) and (12) of the elements A and B is the same as the specific example of the program source code file 24 shown in FIG.
[0052]
On the other hand, the definition (2) of the aggregate 2 includes a definition (21) for the element A, a definition (22) for the element B, and a definition (23) for the element C. The description of the definitions (21) and (22) of the elements A and B is the same as the specific example of the program source code file 24 shown in FIG. For the definition (23) of the element C, as described in “<className> Class1 </ className>”, refer to the definition described in “Class1”, that is, the definition (1) of the aggregate 1 Is defined.
[0053]
The program source code automatic generation unit 20 generates a program source code file 24 as shown in FIG. 11 for the aggregate 1 with respect to the description of the definition file 22 shown in FIG. A program source code file 24 as shown in FIG. The example of the program source code file 24 shown in FIG. 11 will be omitted since it is identical to the embodiment shown in FIG. In the example of the program source code file 24 shown in FIG. 12, the serialized program source code (1) includes the source code (1A) for the data of the element A, the source code (1B) for the data of the element B, and the data of the element C. Is included in the source code (1C). In the source code (1C), a serialized program source code “count = count + elementC.Serialize (& stack [count])” is generated according to the definition in the definition file 22.
[0054]
In the structure program source code (2), a source code (2C) “count = count + elementC.Structure (& stack [count])” corresponding to the serialization source code (1C) is generated.
[0055]
The definition file 22 of the data structure shown in FIG. 10 shows an example in which two aggregates are defined and only the element C of the aggregate 2 refers to another description. Even if it is defined and the citation relation is complicatedly defined, the program source code automatic generation unit 20 refers to those definitions and generates an exactly corresponding program source code.
[0056]
In this manner, the program source code file 24 for serializing and structuring based on the aggregates defined in the data structure definition file 22 by the program source code automatic generation unit 20 and the element definitions in each aggregate. Can be generated. Therefore, the definition content of the data structure is a complex definition such that the number of aggregates and elements is large, and further, as shown in FIG. 10 (23), the definition of the element refers to the definition of another aggregate. Even if it is, the program source code can be generated without error. By using the program source code automatic generation unit 20, it is possible to eliminate programming work for manually creating source code, thereby eliminating human correction errors and greatly reducing the work required for the work. It becomes possible.
[0057]
Note that when the content of the definition described in the definition file 22 of the data structure need to be changed can be changed by the definition file changing section 16. Once the definition in the definition file 22 has been changed, the program source code automatic generation unit 20 is executed as described above, so that the program source code file 24 corresponding to the changed definition file 22 of the data structure can be easily automatically generated. Can be generated.
[0058]
When it is necessary to change the method of data serialization and structure, among the plurality of program source code automatic generation units 20a, 20b,... The change unit 18 changes the program source code automatic generation unit 20 that executes the program. This makes it possible to easily cope with a case where the data serialization and the structure method are changed. Similarly, even when the program language is changed, it can be dealt with by changing the program source code automatic generation unit 20 corresponding to the changed program language to be executed.
[0059]
In the above description, the program source code file 24 is generated based on the data structure definition file 22. However, it is not a dedicated file created for defining the data structure, but a data file. if the long represents the structure with reference to the other data it can also be configured to generate a program source code file 24.
[0060]
In addition, the method described in the above-described embodiment can be executed on a recording medium such as a magnetic disk (such as a flexible disk or a hard disk), an optical disk (such as a CD-ROM or a DVD), or a semiconductor memory as a program that can be executed by a computer. It can be written and provided to various devices. Further, it is also possible to transmit the data via a communication medium and provide the data to various devices. A computer that realizes the present apparatus reads the program recorded on the recording medium or receives the program via the communication medium, and executes the above-described processing by controlling the operation of the program.
[0061]
Further, the present invention is not limited to the above-described embodiment, and can be variously modified in an implementation stage without departing from the gist of the invention. Furthermore, the embodiments include inventions at various stages, and various inventions can be extracted by appropriately combining a plurality of disclosed constituent elements. For example, in a case where an effect can be obtained even if some components are deleted from all the components shown in the embodiment, a configuration in which the components are deleted can be extracted as an invention.
[0062]
【The invention's effect】
As described in detail above, according to the present invention, referring to information defining an aggregate indicating a unit for serializing and deserializing data and elements for serializing and deserializing in the aggregate, Based on the elements included in the aggregate, generate a program source code for serializing and deserializing data, collect the program source code generated based on the elements, serialize By generating the program source code for deserialization, it is possible to reduce the labor required for generating the program source code for realizing the functions of serializing and deserializing data.
[Brief description of the drawings]
FIG. 1 is a block diagram showing a functional configuration for realizing a program source code generation method according to an embodiment.
FIG. 2 is a flowchart for explaining an operation of creating a program source code in the embodiment.
FIG. 3 is a diagram showing an example of information defined in a definition file 22 of a data structure from which a program source code file 24 is generated.
FIG. 4 is a view showing an example of a program source code file 24 including program source codes for serializing and structuring the aggregate 1 corresponding to the definition file 22 shown in FIG. 3;
5 is a view showing a specific example of definition contents corresponding to a definition file 22 having the data structure shown in FIG. 3;
6 is a view showing a specific example of a program source code file 24 generated according to the definition of the definition file 22 having the data structure shown in FIG. 5;
FIG. 7 is a flowchart for explaining an operation of creating a program source code in a case where a definition file 22 having a data structure in which a complicated pattern data structure is defined according to the embodiment is targeted.
FIG. 8 is a view showing an example of a definition file 22 of a data structure of a complicated pattern according to the embodiment.
9 is a diagram showing a specific example of a program source code file 24 including program source codes for serializing and structuring the aggregates 1 and 2 described in the definition file 22 having the data structure shown in FIG.
10 is a diagram showing a specific example of definition contents corresponding to the definition file 22 having the data structure shown in FIG. 8;
11 is a diagram showing a specific example of a program source code file 24 generated according to the definition of the aggregate 1 of the definition file 22 having the data structure shown in FIG.
12 is a view showing a specific example of a program source code file 24 generated according to the definition of the aggregate 2 of the definition file 22 having the data structure shown in FIG.
[Explanation of symbols]
10 Source code generation processing unit
12. Definition file storage unit
14. Source code file storage
16 ... Definition file change unit
18 ... Change section
20: Program source code automatic generation unit
22: Data structure definition file
24 ... Program source code file

Claims (5)

A program source code generation method for generating a program source code for realizing a function of serializing and deserializing data,
Refer to the aggregate that indicates the unit to serialize and deserialize the data and the information that defines the elements to serialize and deserialize in this aggregate,
Based on the elements included in the aggregate, generate a program source code for serializing and deserializing data,
A program source code generation method, comprising: combining program source codes generated based on the elements to generate a program source code for serializing and deserializing the aggregate. 2. The method according to claim 1, wherein when a plurality of aggregates are defined in the information, a program source code is generated for each aggregate. 2. The program source code generation method according to claim 1, wherein a generated program source code is changed according to a method of serializing and deserializing data. 2. The method according to claim 1, wherein the generated program source code is changed according to the programming language of the program source code. A program source code generation program for generating a program source code for realizing a function of serializing and deserializing data,
Computer
Refer to the aggregate that indicates the unit for serializing and deserializing data and the information that defines the elements to serialize and deserialize in this aggregate,
Based on the elements included in the aggregate, to generate a program source code for serializing and deserializing data,
A program source code generation program for collecting program source codes generated based on the elements to generate a program source code for serializing and deserializing the aggregate.

Images