JP2010086218A - Computer system executing program including java (r) code converted from cobol code, its method, and computer program - Google Patents

Abstract

<P>PROBLEM TO BE SOLVED: To provide a data structure for satisfying specifications of JAVA code, executing the JAVA code with high speed and efficiency; and to provide an execution method of the JAVA code using the data structure, since there is a great difference in language specifications between a COBOL language and a JAVA (R) language, and when converting a COBOL code into a JAVA code, how the JAVA code efficiently achieves processing described on the COBOL code greatly depends on the design of the data structure. <P>SOLUTION: A computer system executing a program including a JAVA code converted from a COBOL code includes a storage unit storing a program including a JAVA code having at least one declaration of an object of which the data type is a wrapper class that is declaration converted from each declaration of data items included in the COBOL code; and a CPU reading out the program from the storage unit to execute the program. <P>COPYRIGHT: (C)2010,JPO&INPIT

Description

  The present invention relates to a computer system that executes a program including JAVA ™ code converted from COBOL code, and a method and computer program therefor.

  So-called legacy migration refers to porting a system built on the mainframe to a platform such as UNIX or Windows (trademark). As one aspect of legacy migration, the demand for code conversion from COBOL to JAVA (trademark) is increasing year by year. For code conversion from COBOL to JAVA (trademark), a developer generally uses an automatic conversion program called a translator, and subsequently performs some manual tuning on the converted code. . Therefore, the execution performance of the JAVA ™ code after conversion largely depends on the quality of the conversion code of the translator and the performance of the runtime library.

One of the features of COBOL is that a data item declaration is associated with a data area. Therefore, the execution performance of the JAVA (trademark) code after conversion can vary greatly depending on how the management of data items and memory is implemented by JAVA (trademark).
In conventional translators, numeric data that does not include a decimal point has been converted to an int type or a long type, numeric data that includes a decimal point has been converted to a BigDecimal type, and character data has been converted to a String type. Hierarchical group data items have been defined as internal or external class objects for each hierarchy.
The problem with such an implementation is that each data item is represented as a separate JAVA ™ data type. When data type objects that cannot change their state after creation, such as String type and BigDecimal type, are used, a large number of objects are newly created each time a variable is assigned or displayed, and a large number of copies are made. The operation is performed. Such inefficient object generation or copy operations are frequently found in large-scale commercial applications that implement JAVA ™ code that has been converted from COBOL code and put into practical use. This is a major cause of poor performance of the JAVA ™ code after conversion.

  There is a large gap in terms of language specifications between the COBOL language and the JAVA (trademark) language. When a COBOL code is converted into a JAVA (trademark) code, how efficiently the processing described on the COBOL code is realized with the JAVA (trademark) code depends largely on the design of the data structure. Accordingly, there is a need for a data structure that satisfies the specifications of JAVA (trademark) code and enables high-speed and efficient execution, and a JAVA (trademark) code execution method using the data structure.

The present invention provides a computer system for executing a program including JAVA ™ code converted from COBOL code. The computer system
A storage unit for holding a program including JAVA (trademark) code having at least one declaration of an object whose data type is a wrapper class, wherein each of the declarations is converted from a declaration of a data item included in the COBOL code. The above memory part,
A CPU that reads the program from the storage unit into the memory and executes the program.

  In one embodiment of the present invention, the wrapper class has a function of managing data (hereinafter referred to as second data) corresponding to data (hereinafter referred to as first data) of a data item declared in the COBOL code. Have.

In one embodiment of the invention, the wrapper class is
A first char array for storing the second data;
A variable for storing the number of characters of the second data;
And a variable for storing an offset value representing a position where the second data is stored.

In one embodiment of the present invention, an object generated from the wrapper class (hereinafter referred to as a first object) is
Managing third data corresponding to the second data, and a second char array corresponding to the first char array;
A first variable corresponding to the variable for storing the number of characters of the third data;
And a second variable corresponding to the variable storing an offset value representing a position where the third data is stored.

In one embodiment of the present invention, the second char array is
Storing the third data, or
In the hierarchical structure to which the first object belongs, share a memory area for a third char array included in an object (hereinafter referred to as a second object) that is higher in the hierarchy and is generated from the wrapper class,
Here, the second object includes the third char array corresponding to the first char array, and the highest layer in which the memory area is allocated to the third char array. Object
The third char array includes the memory area in which the third data is stored.

  In one embodiment of the present invention, the first variable stores the number of characters of the third data.

  In one embodiment of the present invention, the second variable stores an offset value representing a position where the third data is stored in the memory area.

In one embodiment of the invention, the wrapper class is
A variable that stores numeric data,
An object variable of 0 or 1 for performing mutual conversion between the numeric data and the data on the first char array;
A flag indicating the validity of the variable for storing the numeric data, and
and a flag indicating the validity of the char array representation.

In one embodiment of the present invention, an object generated from a wrapper class (first object) is
Managing third data corresponding to the second data, and a second char array corresponding to the first char array;
A first variable corresponding to the variable for storing the number of characters of the third data;
A second variable corresponding to the variable storing an offset value representing a position where the third data is stored;
A third variable corresponding to the variable for storing the numeric data;
A first flag corresponding to the flag indicating the validity of a variable storing the numeric data;
A second flag corresponding to the flag indicating the validity of the char array representation, and
When the wrapper class includes an object for performing the mutual conversion, the wrapper class further includes a first mutual conversion object corresponding to the object for performing the mutual conversion.

In one embodiment of the present invention, the wrapper class further includes an instruction sharing a memory area for the first char array,
The first object includes a second char array corresponding to the first char array and the shared instruction;
The instruction shared by the first object is
The fourth char array included in the third object having a fourth char array generated from the wrapper class and corresponding to the first char array, the memory area for the second char array Instructions shared with the memory area for.

In one embodiment of the present invention, the second data is data corresponding to the first data declared in the REDEFINES clause of COBOL,
The instruction shared by the first object is included in a constructor executed in the generation of the first object.

In one embodiment of the present invention, the wrapper class is at a lower level in the hierarchical structure to which the first object belongs and is generated from the wrapper class (hereinafter, fourth object). Further including the definition of
The CPU further executes the following instruction, and the instruction is:
An instruction to execute the third data set or get instruction;
If the memory area for the second char array is not allocated,
An instruction for allocating a memory area for the second char array;
An instruction for sharing a memory area for a fifth char array included in the fourth object,
The fourth object is
Managing the fourth data corresponding to the second data, and the fifth char array corresponding to the first char array;
A fourth variable corresponding to the variable storing the number of characters of the fourth data;
The shared instruction including: a fifth variable corresponding to the variable storing an offset value representing a position where the fourth data is stored;
An instruction for setting a position in the memory area for the second char array of the fourth data with respect to the fifth variable.

In one embodiment of the invention, the shared instruction is
When a memory area is allocated to the fifth char array, the CPU further includes an instruction to copy the fourth data stored in the fifth char array to the second char array.

In one embodiment of the present invention, the wrapper class is defined in at least one object (fourth object) that is in a lower hierarchy in the hierarchical structure to which the first object belongs and is generated from the wrapper class. Further including
The CPU further executes the following instruction, and the instruction is:
An instruction to execute the third data set or get instruction;
If the memory area for the second char array is not allocated,
An instruction for allocating a memory area for the second char array;
An instruction for sharing a memory area for a fifth char array included in the fourth object,
The fourth object is
Managing the fourth data corresponding to the second data, and the fifth char array corresponding to the first char array;
A fourth variable corresponding to the variable storing the number of characters of the fourth data;
A fifth variable corresponding to the variable storing an offset value representing a position where the fourth data is stored;
A sixth variable corresponding to the variable for storing the numeric data;
A second mutual conversion object corresponding to the object for performing the mutual conversion;
A third flag corresponding to the flag indicating the validity of the variable storing the numeric data;
The shared instruction comprising: a fourth flag corresponding to the flag indicating the validity of the char array representation;
An instruction for setting a position in the memory area for the second char array of the fourth data with respect to the fifth variable.

In one embodiment of the invention, the shared instruction is
When a memory area is allocated to the fifth char array, the CPU further includes an instruction to copy the fourth data stored in the fifth char array to the second char array.

In one embodiment of the invention, the instruction to copy is
A command for invalidating the third flag of the fourth object;

In one embodiment of the invention,
When numerical data is given as the data to be set, the CPU further executes the following command,
An instruction to set the numeric data in the third variable;
And an instruction for setting the second flag to be invalid.

In one embodiment of the present invention, an instruction to set the numeric data in the third variable is
Further included is an instruction for effectively setting the first flag.

In one embodiment of the invention, execution of the instruction is a get instruction,
The CPU further executes the following instruction, and the instruction is:
An instruction for fetching the fourth data from the fifth char array sharing the memory area;

In one embodiment of the invention, execution of the instruction is a get instruction,
The CPU further executes the following instruction, and the instruction is:
An instruction for acquiring the fourth flag and confirming that the acquired fourth flag is set to be valid is included.

In one embodiment of the present invention, the CPU further executes the following instruction:
An instruction to obtain numeric data from the third variable;
An instruction for converting the acquired data into character type data using the first mutual conversion object;
An instruction to set the converted character type data in the second char array;
And an instruction for effectively setting the second flag.

In one embodiment of the present invention, the CPU further executes the following instruction:
An instruction to obtain character type data from the second char array;
Using the first mutual conversion object, an instruction for converting the acquired character type data into numeric type data;
An instruction to set the converted numeric data to the third variable;
And an instruction for effectively setting the first flag.

In one embodiment of the invention,
When obtaining numerical data as data to be obtained, the CPU further executes the following instruction, and the instruction confirms that the first flag is set to be valid;
An instruction for obtaining the numeric data from the third variable.

The present invention provides a method for executing a program including JAVA ™ code converted from COBOL code. The method includes causing a computer system to perform the following steps. The step is
Reading the program having at least one declaration of an object whose data type is a wrapper class from the storage unit into the memory, wherein each of the declarations is a declaration converted from each of the declarations of the data items included in the COBOL code. The step of reading out,
Executing the read program.

  In one embodiment of the present invention, the wrapper class has a function of managing data (second data) corresponding to data (first data) of a data item declared in the COBOL code, The method includes causing the computer system to further perform the following steps. The step includes the step of providing the managing function to the first object in response to the generation of the first object.

In one embodiment of the invention, the wrapper class is
A first char array for storing the second data;
A variable for storing the number of characters of the second data;
A variable for storing an offset value representing a position where the second data is stored, and
The method includes causing the computer system to further perform the following steps. The step is
In response to the generation of an object (first object) generated from the wrapper class, the method includes providing the first object with:
A second char array corresponding to the first char array;
A first variable corresponding to the variable storing the number of characters of the third data; and a second variable corresponding to the variable storing an offset value representing a position where the third data is stored.

In one embodiment of the invention, the method includes causing the computer system to further perform the following steps. The step includes the second char array,
Storing the third data, or
Sharing a memory area for a third char array included in an object (second object) that is in an upper hierarchy in the hierarchical structure to which the first object belongs and is generated from the wrapper class,
Here, the second object includes the third char array corresponding to the first char array, and the highest layer in which the memory area is allocated to the third char array. Object
The third char array includes the memory area in which the third data is stored.

  In one embodiment of the invention, the method includes causing the computer system to further perform the following steps. The step includes a step of storing the number of characters of the third data in the first variable.

  In one embodiment of the invention, the method includes causing the computer system to further perform the following steps. The step includes a step of storing, in the second variable, an offset value representing a position where the third data is stored on the memory area.

In one embodiment of the invention, the wrapper class is
A variable that stores numeric data,
An object of 0 or 1 for performing mutual conversion between the numeric data and the data on the first char array;
A flag indicating the validity of the variable for storing the numeric data, and
a flag indicating the validity of the char array representation, and
The method includes causing the computer system to further perform the following steps. The step is
In response to the generation of an object (first object) generated from the wrapper class, the method includes providing the first object with:
A second char array corresponding to the first char array;
A first variable corresponding to the variable storing the number of characters of the third data;
A second variable corresponding to the variable storing an offset value representing a position where the third data is stored;
A third variable corresponding to the variable storing the numeric data;
A first flag corresponding to the flag indicating the validity of the variable storing the numerical data; and a second flag corresponding to the flag indicating the validity of the char array representation.
The step of providing to the first object includes:
When the wrapper class includes an object for performing the mutual conversion,
Providing the first object with a first interconversion object corresponding to the object for performing the interconversion.

  In one embodiment of the invention, the method includes causing the computer system to further perform the following steps. The step includes a step of storing third data corresponding to the second data in the first object.

In one embodiment of the invention, the wrapper class further includes instructions that share a memory area for the first char array, and the method further includes causing the computer system to perform the following steps. The step includes a step of providing an instruction for sharing the memory area to the first object in response to generation of an object (first object) generated from the wrapper class.
Here, the first object includes a second char array corresponding to the first char array and the shared instruction, and the shared instruction of the first object is related to the second char array. Is shared with the memory area for the fourth char array included in the third object that is generated from the wrapper class and has a fourth char array corresponding to the first char array. Includes instructions.

In one embodiment of the present invention, the second data is data corresponding to the first data declared in the COBOL REDEFINES clause, and the method further causes the computer system to perform the following steps: including. The step is
In response to the generation of the first object,
Instructions shared by the first object are provided to a constructor that is executed in the creation of the first object.

In one embodiment of the present invention, the definition of at least one object (fourth object) in which the wrapper class is in a lower hierarchy in the hierarchical structure to which the first object belongs and is generated from the wrapper class Further includes. The method includes causing the computer system to further perform the following steps. The step is
Executing the third data set or get instruction;
If the memory area for the second char array is not allocated,
Allocating a memory area to the second char array;
A step of sharing a memory area for a fifth char array included in the fourth object,
The fourth object is
Managing the fourth data corresponding to the second data, and the fifth char array corresponding to the first char array;
A fourth variable corresponding to the variable storing the number of characters of the fourth data;
The sharing step including: a fifth variable corresponding to the variable storing an offset value representing a position where the fourth data is stored;
Setting a position in the memory area for the second char array of the fourth data for the fifth variable.

In one embodiment of the invention, the method includes causing the computer system to further perform the following steps. The step includes the step of sharing,
When a memory area is assigned to the fifth char array, the method further includes a step of copying the fourth data stored in the fifth char array to the second char array.

In one embodiment of the present invention, the wrapper class is defined in at least one object (fourth object) that is in a lower hierarchy in the hierarchical structure to which the first object belongs and is generated from the wrapper class. Further includes. The method includes causing the computer system to further perform the following steps. The step is
Executing the third data set or get instruction;
If the memory area for the second char array is not allocated,
Allocating a memory area for the second char array;
Sharing a memory area for a fifth char array included in the fourth object,
The fourth object is
Managing the fourth data corresponding to the second data, and the fifth char array corresponding to the first char array;
A fourth variable corresponding to the variable storing the number of characters of the fourth data;
A fifth variable corresponding to the variable storing an offset value representing a position where the fourth data is stored;
A sixth variable corresponding to the variable for storing the numeric data;
A second mutual conversion object corresponding to the object for performing the mutual conversion;
A third flag corresponding to the flag indicating the validity of the variable storing the numeric data;
The sharing step, including: a fourth flag corresponding to the flag indicating the validity of the char array representation;
Setting a position in the memory area for the second char array of the fourth data for the fifth variable.

In one embodiment of the invention, the method includes causing the computer system to further perform the following steps. The step includes the step of sharing,
When a memory area is assigned to the fifth char array, the method further includes a step of copying the fourth data stored in the fifth char array to the second char array.

In one embodiment of the invention, the method includes causing the computer system to further perform the following steps. The step includes the step of copying,
The method further includes the step of invalidating the third flag of the fourth object.

In one embodiment of the invention, the method includes causing the computer system to further perform the following steps. When the numerical data is given as the data to be set,
Setting the numeric data in the third variable;
Setting the second flag to invalid.

In one embodiment of the invention, the method includes causing the computer system to further perform the following steps. In this step, the step of setting the numeric data in the third variable includes
The method further includes the step of effectively setting the first flag.

In one embodiment of the invention, the get instruction is executed in the step of executing the third data set or get instruction. The method includes causing the computer system to further perform the following steps. The step is
The step of fetching the fourth data from the fifth char array sharing the memory area is further included.

In one embodiment of the invention, the get instruction is executed in the step of executing the third data set or get instruction. The method includes causing the computer system to further perform the following steps. The step is
The method further includes the step of acquiring the fourth flag and confirming that the acquired fourth flag is set to be valid.

In one embodiment of the invention, the method includes causing the computer system to further perform the following steps. The step is
Obtaining numeric data from the third variable;
Converting the acquired data into character type data using the first mutual conversion object;
Setting the converted character type data in the second char array;
Setting the second flag valid.

In one embodiment of the invention, the method includes causing the computer system to further perform the following steps. The step is
Obtaining character type data from the second char array;
Using the first mutual conversion object, converting the acquired character type data into numeric type data;
Setting the converted numeric data to the third variable;
Setting the first flag valid.

In one embodiment of the invention, the method includes causing the computer system to further perform the following steps. The step is
If you want to get numeric data as the data to get,
Confirming that the first flag is enabled;
Obtaining the numeric data from the third variable.

The present invention provides a method for executing a program including JAVA ™ code converted from COBOL code. The method includes causing a computer system to perform the following steps. The step is
Reading a program including JAVA (trademark) code having at least one declaration of an object whose data type is a wrapper class from a storage unit into a memory;
Each of the declarations is a declaration converted from each of the declarations of the data items included in the COBOL code, and the wrapper class includes data (first data) corresponding to data (first data) declared in the COBOL code. (Second data) management function,
The above wrapper class is
A first char array for storing the second data;
A variable for storing the number of characters of the second data;
A variable for storing an offset value representing a position where the second data is stored;
A variable of 0 or 1 that stores numeric data,
An object of 0 or 1 for performing mutual conversion between the numeric data and the data on the first char array;
A 0 or 1 flag indicating the validity of a variable for storing the numeric data;
a 0 or 1 flag indicating the validity of the char array representation;
Including zero or more object definitions generated from the wrapper class,
The object (first object) generated from the wrapper class is
Managing third data corresponding to the second data, and a second char array corresponding to the first char array;
A first variable corresponding to the variable for storing the number of characters of the third data;
A second variable corresponding to the variable storing an offset value representing a position where the third data is stored;
In the hierarchical structure to which the first object belongs, at least one object that is in the lower hierarchy and is generated from the wrapper class (lower hierarchy object: where the lower hierarchy object corresponds to the fourth object Including) and
The lower hierarchy objects are
Managing the fourth data corresponding to the second data, and the third char array corresponding to the first char array;
A third variable corresponding to the variable for storing the number of characters of the fourth data;
A fourth variable corresponding to the variable storing an offset value representing a position where the fourth data is stored;
A fifth variable corresponding to the variable for storing the numeric data;
A second mutual conversion object corresponding to the object for performing the mutual conversion;
A first flag corresponding to the flag indicating the validity of a variable storing the numeric data;
A second flag corresponding to the flag indicating the validity of the char array representation, and
The reading step;
Executing the third data set or get instruction;
If the memory area for the second char array is not allocated,
Allocating a memory area to the second char array;
Sharing a memory area for a third char array included in the lower layer object;
Setting a position in the memory area for the second char array of the fourth data for the fourth variable.

  The present invention further provides a computer program including JAVA ™ code converted from COBOL code. The computer program includes causing a computer system to execute each step of the method described above.

The present invention provides a method for executing a program including JAVA ™ code converted from COBOL code. The method includes causing a computer system to perform the following steps. The step is
Converting COBOL code to JAVA ™ code, the converting step comprising:
Reading the COBOL code into the memory from the storage unit holding the COBOL code;
Replacing the declaration of the group data item with the declaration of the wrapper class for the structure in the COBOL code read into the memory;
Converting the declaration of the data item in the lower hierarchy of the group data item with a declaration of the wrapper class, and converting the data,
Reading out the program including the converted JAVA (trademark) code from the storage unit into the memory, wherein the program has at least one declaration of an object of the wrapper class, and each of the declarations is included in the COBOL code. The above-mentioned reading step, which is a declaration converted from the declaration of each data item
Executing the read program.

  According to the embodiment of the present invention, the readability and maintainability of JAVA ™ code converted from COBOL code is improved. In addition, a data structure capable of sharing a data body such as REDEFINES, which is a function of COBOL, and a hierarchical data structure is realized on the JAVA (trademark) code. With this data structure, generation of useless copy operations is suppressed, and execution performance is improved because a useless memory area is not secured when executing the JAVA (trademark) program.

In the embodiment of the present invention, the “wrapper class” is a class that defines a unique data type. The wrapper class has a function of managing data of data items declared in the COBOL code on the JAVA (trademark) code. The function of managing the data is provided to an object whose data type is the wrapper class. The wrapper class includes member variables and methods for managing the data item data on JAVA (trademark) code. The object generated from the wrapper class manages the data item data on JAVA (trademark) code.
The wrapper class has, as member variables, a char array that stores character data, a variable that stores the number of characters of the data, and a variable that stores an offset value indicating a position where the data is stored. These member variables are defined in a common class for providing a common function, for example. The wrapper class can have the member variables by extending the common class.
The above wrapper class includes a wrapper class corresponding to the definition of the COBOL character string, a wrapper class corresponding to the definition of the numerical value including the decimal point of the COBOL, a wrapper class corresponding to the definition of the numerical value not including the decimal point of the COBOL, and the group of the COBOL. There is a wrapper class corresponding to the data item definition. The wrapper class corresponding to the definition of the numerical value including the decimal point and the wrapper class corresponding to the definition of the numerical value not including the decimal point are the mutual conversion between the variable storing the numerical data, the numerical data and the data on the char array. The member variable includes an object for performing the above, a flag indicating the validity of the variable storing the numerical data, and a flag indicating the validity of the char array expression. In addition, a wrapper class that provides a function for managing data of a data item declared in a COBOL REDEFINES clause on JAVA (trademark) code is a memory class for the char array, and is generated by another wrapper class generated from the wrapper class. It has a method for sharing with the memory area for the char array contained in the object.
The wrapper class can be provided as a library.

  In the embodiment of the present invention, a “data item” is a name given to a memory area for storing data so that the data handled in the COBOL is stored for a certain period and can be used when necessary. It is a thing. Data items correspond to variables in JAVA ™. In the embodiment of the present invention, an object of the wrapper class is generated for each data item.

  In the embodiment of the present invention, the “char array” is an array for handling char-type character data. The char array is defined by a wrapper class. Each of the objects generated from the wrapper class has the char array. The internal memory of the data type supported by the wrapper class is handled uniformly by the char array. The char array body is a char array in which a memory area is uniquely allocated, or the allocated memory area is shared with other objects generated from the wrapper class. The pointer to the char array is a reference to the char array body.

  In the embodiment of the present invention, the “number of characters of data” is the number of characters of data corresponding to the data of the COBOL data item and managed by the wrapper class object. The variable that stores the number of characters of the data is defined in the wrapper class. Each of the objects generated from the wrapper class has a variable in which the number of characters of the data is stored. The number of characters is the number of characters in the char type. For example, in COBOL, numeric data with an integer part of 2 digits and a decimal part of 2 digits requires 2 characters for the integer part, 2 characters for the decimal part, and 1 character for the decimal point. The number of characters is 5.

  In the embodiment of the present invention, the “offset value indicating the position where data is stored” is a value indicating the position of data to be managed on the main body of the char array shared by objects having the offset value. The variable in which the offset value is stored is defined in the wrapper class. Each variable generated from the wrapper class has a variable in which the offset value is stored. The offset value is, for example, the element number of the char array body.

In the embodiment of the present invention, the “hierarchical structure” refers to a structure of data items that are hierarchically declared in multiple stages in a COBOL group data item (Group Data Item). In the embodiment of the present invention, the data managed by the wrapper class object (hereinafter referred to as object 1) is a data structure that is a part of the data managed by another wrapper class object (hereinafter referred to as object 2). Expressed. Here, the objects 1 and 2 are objects belonging to a hierarchical structure. The object 1 is an object in a lower hierarchy as viewed from the object 2, and the object 2 is an object in an upper hierarchy as viewed from the object 1.
Further, the hierarchy of the hierarchical structure can be in the range of 2 to 49. For example, the data managed by the object 2 may be a part of data managed by another wrapper class object (hereinafter, object 3). In this case, the objects 1 to 3 are objects belonging to a hierarchical structure. The object 1 is the object in the lowest hierarchy as viewed from the object 3, and the object 3 is the object in the highest hierarchy as viewed from the object 1.

  In the embodiment of the present invention, “sharing a memory area” means that a memory area allocated to a char array storing data managed by an object of a wrapper class is used from one or more other wrapper class objects Is to be able to do it.

In the embodiment of the present invention, the “variable for storing numerical data” is a variable for storing data managed by the wrapper class object in numerical form. The variable for storing the numeric data is defined by a wrapper class that handles numeric data. Each of the objects generated from the wrapper class that handles the numeric data has a variable for storing the numeric data. The numeric type data is a value object or primitive type data that is an object indicating a value.
In the embodiment of the present invention, the wrapper class corresponding to the definition of the numerical value including the decimal point of the COBOL has the value object as a variable for storing the numerical data. The value object is, for example, a BigDecimal object. In addition, a wrapper class corresponding to the definition of a numerical value that does not include a decimal point of COBOL, and when converted to a numerical value, the wrapper class corresponding to the definition of the numerical value within the range of the primitive type data is As a variable for storing data, a variable for storing the primitive type data is included. Note that the wrapper class object for managing the numeric data with a large number of digits that does not include a decimal point in COBOL and overflows the range when stored in the primitive type variable is the primitive. Does not have a variable to store type data. Only when it is guaranteed that the number of characters of data in the COBOL is within the range of the variable storing the primitive data, the wrapper class corresponding to the definition of the numerical value not including the decimal point of the COBOL is the data of the primitive type. Has a variable for storing. Here, the variable for storing the primitive type data is an int type or long type variable. Note that the wrapper class object that manages the numerical data with a large number of digits that would overflow the range when stored in the primitive type variable is a wrapper class corresponding to the definition of the numerical value including the decimal point of COBOL. Similarly, it has a value object. The value object is, for example, a BigInteger object.

  In the embodiment of the present invention, the “object for performing mutual conversion” is an object for converting char-type array data into numeric-type data or converting numeric-type data into char-type array data. is there. An object for performing the above mutual conversion is defined by a wrapper class that handles numeric data including a decimal point. The objects for performing the above-described mutual conversion are included in each object generated from a wrapper class that handles numeric type data including a decimal point. The object for performing the mutual conversion is, for example, a DecimalFormat object.

  In the embodiment of the present invention, the “flag indicating the validity of a variable for storing numerical data” indicates that the data stored in the variable for storing the numerical data is valid or invalid. Flag. The “flag indicating the validity of the char array representation” is a flag indicating that the data stored in the char array body is valid or invalid. The above two flags are defined in a wrapper class that handles numeric type data. Each of the two flags has an object generated from a wrapper class that handles numeric data.

  In an embodiment of the present invention, a “constructor” is an instruction that is executed when an object is created.

  In the embodiment of the present invention, the “set or get instruction” is an instruction (method) for writing or reading data managed in an object of the wrapper class.

  In the embodiment of the present invention, “the memory area for the char array is not allocated” indicates that no memory area is allocated to the char array.

  Embodiments of the present invention will be described below with reference to the drawings. It should be understood that this embodiment is for the purpose of illustrating a preferred embodiment of the invention and is not intended to limit the scope of the invention to what is shown here. Further, throughout the following drawings, the same reference numerals denote the same objects unless otherwise specified.

FIG. 1 shows an example of the description of the data part in COBOL.
In COBOL, a programmer declares a data item to be used in a program in the data part using a PICTURE clause. The following is an explanation of the above declaration in COBOL, taking the second line of the COBOL statement (101) as an example.
The first item (102) on the second line of the COBOL statement (101) indicates that the hierarchical level to which the data item defined on the second line belongs is “02”. The hierarchical level will be described later.
The second item (103) on the second line of the COBOL statement (101) indicates that the name of the data item defined on the second line is “Name”.
The third item (104) on the second line of the COBOL statement (101) indicates that the data item defined on the second line is an arbitrary 10-character string. “PIC” indicates a PICTURE phrase. The description following the PIC indicates the size and type in the data area of the data item. X is an arbitrary character string, A is an alphabetic character, and 9 is a numerical value. The description in parentheses indicates the number of digits. V indicates the position of the decimal point. For example, if the description is 999, the data item is a three digit number. If the description is A (20), the data item is 20 alphabetic characters. If the description is 9 (10) V99, the data item is a numeric value with 10 digits and 2 digits after the decimal point.
The fourth item (105) on the second line of the COBOL statement (101) indicates that the initial value given to the data item defined on the second line is a space. “VALUE” indicates a VALUE phrase and represents an initial value. The VALUE clause can be arbitrarily specified. If there is no such designation, a space is set for character data and 0 is set for numeric data.

  In COBOL, an array is defined using an OCCURS clause. For example, the first line of the COBOL statement (101) defines a structure array StudentRecord having 40 elements.

  COBOL specifications that are considered to have a particularly large effect on program performance when converting COBOL code to JAVA (trademark) code include the following.

In COBOL, several basic data items declared in a PICTURE clause can be collected into a collective data item. Furthermore, the sequence is also one of the population data items. The collective data item is declared as a hierarchical data structure. For example, in the COBOL statement (101), the hierarchical level of the first line (106) is “01”, and the hierarchical level of the second to fifth lines is “02”. This indicates that the group data item obtained by collecting the data items Name, MathScore, ScienceScore, and AvgScore defined in the second to fifth lines is a structure array StudentRecord defined in the first line.
The element of the group data item may include another group data item. For example, in the COBOL statement (101), the name of the data item in the second line can be further changed to a collective data item that is a collection of the data items FamilyName and PersonalName. The FamilyName and PersonalName are defined as data items having a hierarchical level of “03” or more and “49” or less. The reason why the upper limit of the hierarchy level is “49” is that the hierarchy can be stacked up to 49 levels in COBOL. In this way, in data items having a hierarchical data structure, a data item having a small hierarchical level value is a higher hierarchical data item, and a data item having a large hierarchical level value is a lower hierarchical data item.
In COBOL, data set and get operations on collective data items are applied to all data items that are elements of the collective data item. For example, in the COBOL statement (101), data “ABCDEFGHIJ12345678901” is set to the n element of the structure array StudentRecord (MOVE DATA TO StudentRecord (n)). When the data item MathScore of the nth element of the structure array StudentRecord is obtained after the set, the obtained data is “123”. Thus, in COBOL, data of individual data items of data set in a batch is acquired. Then, processing is executed using the acquired data.
Further, it is assumed that the data item MathScore of the nth element of the structure array StudentRecord is changed from “123” to “987”. When the n-th element of the structure array StudentRecord is obtained after the change, the obtained data is “ABCDEFGHIJ98774567801”. In this way, in COBOL, data set for individual data items can be collectively acquired using a collective data item. Then, using the acquired data, for example, a process of totaling the whole is executed.
In addition, the above data set and get operations can be performed on data items at any hierarchical level. In the above data set and get operations, when the data size is specified, the operation corresponding to the size is applied to the data.

The COBOL has a function of sharing a data area reserved for a certain data item as a data area for other data items. The function is defined using the REDEFINES clause. With the sharing function, the same data area can be accessed using different data item names.
The COBOL statement (107) shows an example of the REDEFINES phrase. The first line of the COBOL statement (107) defines MonthDef which is a data item of a character string of 36 characters. In the data area for MonthDef, “JANFEBMARAPRMAYJUNJULAUGSEPOCTNOVDEC” is set as an initial value. The data area for the MonthDef is shared as the data area for the MonthName by the REDEFINES phrase in the second line of the COBOL statement (107).
The third line of the COBOL statement (107) defines an array “Month” in the lower hierarchy of “MonthName”. The array Month is a three-character string. The number of elements in the array “Month” is 12. Here, the data area for MonthName is shared with the data area for MonthDef. Therefore, the data area for the array “Month”, which is a data item in the lower hierarchy of “MonthName”, is also shared with the data area for “MonthDef”. Thus, for example, the following command for substituting “XXX” for the third element of MonthName, “Month (3)”, and displaying the data item “MonthDef”:
MOVE “XXX” TO Month (3)
DISPLAY “MonthDef =” MonthDef
When Def is executed, the displayed value of MonthDef is “JANFEBXXXAPRMAYJUNJULAUGSEPOCTNOVDEC”.

  In the embodiment of the present invention, the following structure is used as a data structure corresponding to the hierarchical data structure that is the specification of the COBOL.

The data item data in COBOL is used after being converted into char array data in JAVA (trademark). The data type of JAVA (trademark) is not directly used for the definition of data other than numerical data whose hierarchy is the highest data item and does not include a decimal point. Here, the data type of JAVA (trademark) refers to a basic data type prepared in advance in JAVA (trademark) such as String or BigDecimal. When data corresponding to a data item is defined, a wrapper class is used for the definition. The wrapper class can be provided as a library. The wrapper class is created by inheriting a common class including a char array in a field. The common class has the following internal fields:
public class COMMON_DATA {
private char [] _body; // char array body of the value
private final int _length; // number of characters
private int _start; // offset to char array}
The common class has a char array (_body) that stores character data, a variable (_length) that stores the number of characters of data, and a variable (_start) that stores an offset value indicating the position where the data is stored. The variable (_body) is an area for storing a pointer to the char array. The variable (_length) is an area for storing the number of characters of data. The variable (_start) is an area for storing the position where data is started in the char array body.

When data of a character string data item is defined in JAVA (trademark) code, a wrapper class CHARS is used for the definition. Here, the data item of the character string is a data item in which “X” or “A” is designated as the type in the PICTURE clause of the COBOL. Specifically, “Name”, “MonthDef”, and “Month” in the COBOL statement (FIGS. 1, 101, and 107) are applicable.
The wrapper class CHARS is implemented as a class that inherits the common class. The field of the wrapper class CHARS is composed of only the common class field. The object generated from the wrapper class CHARS is a char array that stores character data internally as a data body, a variable that stores the number of characters, and an offset, similar to a String object that operates a data type representing a character string in JAVA (trademark). Has a variable that stores the value.

When data of a numerical data item including a decimal point is defined in JAVA (trademark) code, a wrapper class DECIMAL is used for the definition. Here, a numerical data item including a decimal point is a data item including “V” that is designated as “9” as a type in the PICTURE clause of COBOL. Specifically, AvgScore in the COBOL sentence (FIGS. 1, 101 and 107) corresponds.
The wrapper class DECIMAL is implemented as an inheritance of the common class. By the inheritance, the object generated from the wrapper class DECIMAL has a char array for storing a numerical value including a decimal point as a character string, a variable for storing the number of characters, and a variable for storing an offset value. Furthermore, the wrapper class DECIMAL has the following internal fields in addition to the fields of the common class.
public class DECIMAL extends COMMON_DATA {
private BigDecimal _value; // value object
private DecimalFormat _format; // format
private boolean _validValue; / Validity flag of the value object
private boolean _validChar; // Validity flag of char array representation of value}
The wrapper class DECIMAL has the value object (_value), the mutual conversion object (_format), the validity flag of the value object (_validValue), and the validity flag (_validChar) of the char array representation of the value in addition to the variables of the common class. Have in the field. The value object (_value) is a BigDecimal type object for having a data body with a numerical type. BigDecimal is a class for manipulating a data type representing an arbitrary-precision signed decimal number in the JAVA (trademark) language. The mutual conversion object (_format) is a DecimalFormat type object having a function of mutually converting a numerical value and a character string. It is desirable from the viewpoint of execution efficiency that the mutual conversion object (_format) is the same instance in units of threads for each numerical format. The validity flag (_validValue) of the value object is a flag indicating that the data held by the value object (_value) is no longer the latest state due to the update of the data set in the char array. The validity flag (_validChar) of the char array representation of the value is a flag indicating that the data set in the char array is no longer in the latest state due to the update of the data of the value object (_value).

When data of a numerical data item that is a lower-level data item and does not include a decimal point is defined in the JAVA (trademark) code, a wrapper class INT is used for the definition. Here, a numerical data item not including a decimal point is a data item in which “9” is specified as the type and does not include “V” in the PICTURE clause of COBOL. Specifically, MathScore and ScienceScore in the COBOL statement (FIGS. 1, 101, and 107) are applicable.
The wrapper class INT is implemented as an inheritance of the common class. By the inheritance, the object of the wrapper class INT has a char array for storing a numerical value not including a decimal point as a character string, a variable for storing the number of characters, and a variable for storing an offset value. Further, the wrapper class INT has the following internal fields in addition to the fields of the common class.
public class INT extends COMMON_DATA {
private int _value; // value
private boolean _validValue; // Value validity flag
private boolean _validChar; // Validity flag of char array representation of value}
The wrapper class INT has a value variable (_value), a value validity flag (_validValue), and a value char array representation validity flag (_validChar) in addition to the variables of the common class. The value variable (_value) is an int type variable for having a data body with a numeric type. The value validity flag (_validValue) is a flag indicating that the data in the value variable (_value) is no longer in the latest state due to the update of the data set in the char array. The validity flag (_validChar) of the char array representation of the value is a flag indicating that the data set in the char array is not in the latest state due to the update of the data of the value variable (_value).

  When data corresponding to a numerical data item whose hierarchy is the highest data item and does not include a decimal point is defined, int and long which are primitive data types representing signed integers are used for the definition. Note that a wrapper class INT may be used instead of the int.

When data corresponding to a group data item is defined, a wrapper class STRUCT is used for the definition.
The wrapper class STRUCT is implemented as an internal or external class that inherits the common class. An object of the wrapper class STRUCT has a char array for storing character data, a variable for storing the number of characters, and a variable for storing an offset value in order to collectively represent lower layer data. Furthermore, the wrapper class STRUCT has the following internal fields in addition to the fields of the common class.
public class STRUCT extends COMMON_DATA {
private Object [] _fields; // Lower layer data object}
The wrapper class STRUCT has a lower layer data object (_fields) in the field in addition to the variables of the common class. The lower hierarchy data object (_fields) holds the data objects of the directly lower hierarchy as an array. In the present specification, the wrapper class STRUCT is also referred to as a hierarchical class.

  In the constructor of the object generated from the wrapper class, basically, only the variable (_length) on the field of the common class is set with the value specified by the PICTURE clause of the COBOL. Further, except when the initial value is explicitly given in the VALUE clause of the COBOL code, the char array body and the value object which are the entities of the char array are not generated. In the JAVA (trademark) language, when an initial value is not given to a variable, a blank character is implicitly set for a character string variable and 0 is implicitly set for a numeric variable. For example, when data is acquired for a null char array body, the char array body is generated lazily at the time of acquisition, and a blank character is returned.

The data area corresponding to the hierarchical data structure is shared when the JAVA (trademark) code is executed and the data corresponding to the group data item having the hierarchy is set / getted. If the hierarchical class corresponding to the group data item having the hierarchy has not yet pointed to the char array, a new char array body is generated and the above data is set. Further, the char array is shared with all data items in the lower hierarchy of the group data item. That is, in the object of the wrapper class in the lower level hierarchy, the given char array is pointed, and the offset value is set while shifting the position by the number of characters of each item. If the char array body has already been generated in the lower level hierarchy, if the above value is obtained, the data is copied to the new char array. The memory area is reserved only for upper layer data. A unique memory area is not secured for lower-layer data.
When a char array is set for the DECIMAL class, a flag indicating that the corresponding BigDecimal object cannot be used is set (_validValue = false). The flag is a value validity flag. When numeric data is required, BigDecimal for storing data in the numeric type is newly generated from the character string set in the latest char array and the DecimalFormat object.
When the char array is set for the INT class, a flag indicating that the corresponding INT object cannot be used is set (_validValue = false). The flag is a value validity flag. When numeric data is required, new int type numeric data is generated from a character string set in the latest char array using a standard library function of JAVA (trademark).
Conversely, when the DECIMAL class value object or INT class value data (_value) is updated, a flag indicating that the corresponding char array is invalid is set (_validChar = false). This flag is a validity flag of the char array representation of the value. When data is acquired from an upper layer, it must be confirmed that the char arrays of all DECIMAL objects and INT objects in the lower layer are valid.

  In addition, a wrapper class object that manages data corresponding to a data item whose data area is shared by using the REDEFINES clause in COBOL is shared with a char array that is a data area when the object is generated. In order to realize the sharing, a method redefine () is implemented in the constructor of each wrapper class. redefine () is a method that points to the char array prepared in the sharing source object.

  Once the char array has been shared, the data get set operation on the collective data item or REDEFINES data structure does not create a new object, but only updates the required part of the char array data. Processing can be completed. With the above method, useless processing such as useless object generation and a plurality of copy operations can be avoided, and a significant performance improvement and a reduction in heap usage can be achieved.

The data set corresponding to the basic data item is executed on the char array when the data is character data.
When the data is numeric data handled by the DECIMAL class, numeric format data is stored in the value object (_value). When the numerical data is given in a char array, the numerical data given as a character string by the mutual conversion object (_format) may be converted into a numeric type and stored in the value object (_value).
If the data is numeric data handled by the INT class, numeric format data is stored in the value variable (_value). When the numerical data is given in a char array, the numerical data given as a character string by a standard library function of JAVA (trademark) may be converted into a numerical type and stored in a value variable (_value).
When new data is stored in the value object (_value) or the value variable (_value), the validity flag of the variable storing the numeric type data is set to valid, and the validity flag of the char array representation of the value Is disabled.
If the data to be obtained is numeric data, if the validity flag of the variable is set to invalid, it is necessary to regenerate the numeric data from the char array data and set it to the value object (_value) or value variable (_value) There is. In order to acquire data from the value object (_value) or the value variable (_value), it is necessary that the validity flag of the variable for storing the numerical data is set to be valid.

FIG. 2A shows an example of a flow when a set instruction to an object of a hierarchical class is executed according to an embodiment of the present invention.
When the program is executed, when an instruction to set data corresponding to a group data item having a hierarchy is executed, it is determined whether or not a char array for storing the data is pointed (step 201).
When the char array is not pointed to, the memory area of the char array is not secured. Therefore, a char array body is generated to secure an area for storing the data (step 202). The size of the char array body generated here is the total size of the number of characters set in the variables of all the wrapper class objects in the lower hierarchy of the hierarchy class.
Next, the data is set in the char array body (step 203).
Next, the following processing is executed for all the wrapper class objects in the lower hierarchy (step 204).
The char array of all the wrapper class objects in the lower hierarchy is shared with the above char array body of the hierarchy class object. First, the char array body is pointed to in the wrapper class objects of all the lower layers (step 205). Further, the offset value is set while shifting the position by the designated length of each item (step 206). The specified length is obtained, for example, by sequentially adding the number of characters set in the variable of the object in the lower hierarchy.
Next, if the data of the object of the lower layer wrapper class is numeric data, the validity flag of the variable storing the numeric data is set to invalid, and the validity flag of the char array representation is set to valid (step) 208). The above two flags are set when the wrapper class object already holds data of a numerical type. When the lower-level wrapper class object is a STRUCT type, the above processing (steps 205 to 208) is recursively executed.
When the above steps 205 to 208 are completed for all the wrapper class objects in the lower hierarchy, the processing of the set in the hierarchy class object is completed.

FIG. 2B shows an example of a flow in the case where a get instruction to an object of a hierarchical class, which is an embodiment of the present invention, is executed.
When a get instruction for data corresponding to a group data item having a hierarchy is executed during program execution, it is determined whether or not a char array for acquiring the data is pointed (step 221).
When the char array is pointed, the memory area of the char array is secured. Therefore, data is obtained from the char array body (step 228), and the process ends. In the acquisition, the validity flag of the char array expression included in all numerical wrapper class objects in the lower hierarchy must be confirmed. If the flag is invalid, it is necessary to convert the variable that stores the numerical data held by the wrapper class object into a char type array and validate it.
When the char array is not pointed to, the memory area of the char array is not secured. Therefore, a char array body is generated to secure an area for storing the data (step 222). The size of the char array body generated here is the total size of the number of characters set in the variables of all the wrapper class objects in the lower hierarchy of the hierarchy class.
Next, the following processing is executed for all the wrapper class objects in the lower hierarchy (step 223).
The char array of all the wrapper class objects in the lower hierarchy is shared with the above char array body of the hierarchy class object. First, the char array body is pointed to in all the wrapper class objects in the lower hierarchy (step 224). The offset value is set while shifting the position by the designated length of each item (step 225). The specified length is obtained, for example, by sequentially adding the number of characters set in the variable of the object in the lower hierarchy.
Furthermore, if a char array has already been generated in the lower-level wrapper class object, the data of the lower-level wrapper class object is copied to the char array body generated in step 222. (Step 227). Here, if the lower-level wrapper class object is a numerical type, the validity flag of the char array representation is checked. If the flag is set to invalid, character data converted from numerical data is copied. In addition, the validity flag of the char array expression is set to valid. The position of the copied data on the char array body is obtained from the offset value of the lower-level wrapper class object. The conversion from numerical data to character data is realized by a JAVA (trademark) standard library function for an INT class object, and by a mutual conversion object for a DECIMAL class object. It should be noted that the char array body for the lower layer object may be released.
For all wrapper class objects in the lower hierarchy, when the above steps 224 to 227 are completed, data is obtained from the char array body (step 228), and the processing of the get in the hierarchical class object is completed.

FIG. 2C shows an example in which a COBOL statement (FIG. 1, 101) as an example of a structure array, which is an embodiment of the present invention, is converted into a JAVA (trademark) code.
The structure array represented by the COBOL statement (FIG. 1, 101) is converted into a structure array represented by the JAVA (trademark) code (231). When the char array is shared for the structure, the structure is internally shown in the object structure (232). In the object structure (232), each object of CHARS, INT, and DECIMAL points to its own area using a pointer to a char array and an offset value. The char array is shared only when it is accessed in units of the upper-level class object StudentRecord [x]. Therefore, if the object in the lower hierarchy has been directly updated before that, the previous data area is discarded as shown by the dotted line in the figure. Then, the pointer is replaced with a new one. In addition, data is copied if necessary.

FIG. 2D shows an example in which a COBOL statement that is an example of a REDEFINES phrase is converted into a JAVA (trademark) code.
A COBOL statement (FIG. 1, 107), which is an example of a REDEFINES phrase, is converted into a JAVA (trademark) code (241).
MonthDef, which is an object on the side where the data area is shared, is generated as an object of the wrapper class CHARS. An initial value is specified in the generation of the object. Therefore, the char array is also allocated, and the data “JANFEBMARAPRMAYJUNJULAUGSEPOCTNOVDEC” is set.
A monthName that is an object sharing the data area is generated as an object of a MonthName that is a class that inherits the wrapper class STRUCT. In the definition of the class, an array for storing the array month is defined, but no data is set. Instead, in the constructor executed when the object is generated, monthDef that is an object on the side where the data area is shared is passed to the redefine () method. A char array is shared by the above methods.
The object structure (242) indicates the relationship between monthName and monthDef and the char array.
monthDef points to a char array.
The monthName is composed of 12 months. month points to the corresponding location in the char array. Corresponding locations are the 0th element, the 3rd element,..., The 33rd element of the char array. This is because month is an array with 3 characters. Pointing means pointing to an element of the char array using a pointer and offset to the char array included in the common class field.

  The body of the hierarchical data structure is expressed as a char array on the JAVA (trademark) code. Further, sharing of data by the REDEFINES clause and the hierarchical data structure in the COBOL code is realized in the JAVA (trademark) code. Therefore, useless object generation and data copy operations can be omitted in the JAVA (trademark) code. As a result, a high-performance implementation that saves heap memory consumption is possible.

  The sharing of the char array is performed at a timing when data for the collective data item is obtained or set. This is because not all data included in the structure is accessed in the program. In particular, COBOL has a function of including an external source program and a data structure declaration into code by using a copy statement. The import function is a function used when defining a data structure often used in a plurality of programs. However, it is general that only a part of the fetched data structure is used, and it is not efficient to use the memory to secure all the memory areas corresponding to the declared data structure first. . In a large-scale commercial application, when converting a COBOL code to a JAVA (trademark) code, there is an example in which performance is greatly reduced by performing a conversion that secures a memory area that is not actually used. In order to make efficient use of memory, the generation of a char array of wrapper class objects for managing the data body is also performed through the get or set of data. Therefore, when the data is accessed, an instance is created in a lazy manner.

  As an example of optimization, a method of performing program analysis such as data flow analysis on the COBOL code or the converted JAVA (trademark) code in advance may be considered. If it is found from the analysis that the execution path includes a process for accessing upper-layer data in the hierarchical data structure, the JAVA (trademark) code to be converted is first a member of the upper-layer object. Inserts an instruction that defines a char array first. As a result, waste of object generation can be further reduced without taking a char array for lower-level variables first.

FIG. 3 shows an example of converting the data definition portion of the COBOL code into a JAVA (trademark) code in the embodiment of the present invention.
A location where a data item is defined in the COBOL code can be converted into a JAVA (trademark) code. The conversion procedure is shown below.
First, “WORKING-STORAGE SECTION.”, Which is a section in which a data item is defined, is searched in the COBOL code (step 301). When the “WORKING-STORAGESECTION.” Is found, the COBOL code is scrutinized line by line. The scrutiny is performed until the current row being scrutinized (hereinafter referred to as the first row) does not include the “hierarchy level” that is characteristic of the hierarchical data structure in the next row (hereinafter referred to as the second row). Performed (step 302). In the scrutiny, first, the “hierarchy level” values of the first row and the second row are compared. (Step 303).
When the “hierarchy level” value in the first row is smaller than the “hierarchy level” value in the second row, the data item defined in the first row is a collective data item. Therefore, the first line is converted into a line that defines an object of the wrapper class STRUCT (step 304). The conversion is, for example, the following conversion.
public class (name of data item) extends STRUCT {
Next, it is checked whether or not “REDEFINE” is included in the first row (step 305). When the “REDEFINE” is included, information for outputting the method redefine () is stored in the stack (step 306). The information is, for example, the name of a data item necessary for creating the constructor part. Next, information necessary for closing the structure is stored (step 307). The information is the name of the data item required to define and generate the hierarchy level and object of the first row. If the data item corresponds to an array, the number of elements in the array is also included in the information.
When the value of the “hierarchy level” in the first row is equal to or greater than the value of the “hierarchy level” in the second row, the data item defined in the first row is A data item that does not have a data item. Therefore, the first line is converted into a line for defining and generating a wrapper class object corresponding to the type of the data item (step 308). The conversion is, for example, the following conversion.
private wrapper class (data item name) = new wrapper class (number of characters);
Here, the object corresponding to the data item in which “X” or “A” is specified as the type in the PICTURE PICTURE clause is defined by the wrapper class CHARS. Further, in the PICTURE PICTURE clause, an object corresponding to a data item in which “9” is specified as the type and includes “V” is defined by the wrapper class DECIMAL. In the PICTURE clause of COBOL, an object corresponding to a data item in which “9” is specified as a type and does not include “V” is defined by the wrapper class INT.
Next, post-processing of the structure (step 309) is executed. In the post-processing, the hierarchical level of the first row and the second row is compared with the hierarchical level of the row converted into the structure stored in the stack. And
Second parent level = <Number of closed parenthesis and structure object generation processes that satisfy the condition of the hierarchical level stored in the stack are output. In addition, when information for outputting the method redefine () is stored, the information is also output.
When the number of lines to be scrutinized is one remaining line, a process of scrutinizing the last line (step 311) is executed. In the processing, processing for defining and generating an object of the wrapper class corresponding to the data item type (step 308) and post-processing of the structure (step 309) are executed.

  4A-C show examples of sample programs used to measure the effect on JAVA ™ code converted according to an embodiment of the present invention.

FIG. 4A shows a COBOL sample program to be converted into JAVA ™ code.
The COBOL program (401) is a program that counts products for each product number of a product factory. The program reads data sorted by product number from a file and outputs a count result for each product number.

FIG. 4B shows an example of the JAVA ™ code (402) obtained by converting the COBOL program (401) of FIG. 4A by a conventional method.
The conventional method is a method of converting a COBOL data type into a corresponding JAVA (trademark) data type. Specifically, PIC X (*) is converted to a String type. PIC 9 (*) converts to BigDecimal type or int type. In addition, the hierarchical structure is converted into a structure defined by using an internal class created independently. The data area included in the structure is defined redundantly outside the structure. Note that the input reading process, which is the process performed by the getdata () method in the JAVA (trademark) program (402), is executed as an inline process at the time of measurement.

  FIG. 4C shows an example of the JAVA ™ code (403) obtained by converting the COBOL program (401) of FIG. 4A according to the embodiment of the present invention.

FIG. 4D shows the verification result of the JAVA ™ program (402, 403) according to the embodiment of the present invention.
The verifier used 100,000 records for the verification, and measured heap memory usage and execution time. In addition, IBM (trademark) JAVA (trademark) 5.0 was used for the measurement. To eliminate JIT compilation time and GC (garbage collection) time, the verifier modifies the main () method, and in the execution of the JAVA ™ program (402, 403), the same as the warm-up run first. The execution of the program was repeated 10 times using the input size record. Further, the verifier implemented System.gc (), which is an instruction for executing garbage collection, after the repetition, and then started the measurement. Further, the verifier specified -Xjit: optLevel = hot, count = 3 -Xms512m -Xmx512m as an execution option of JAVA (trademark). The verifier also confirmed that no GC occurred during the measurement.
A table (404) shows the result of the verification.
When the conversion code according to the embodiment of the present invention was used, the execution time was 218 milliseconds and the usage of the heap memory was 131.3 megabytes.
When the conversion code according to the conventional method is used, the execution time is 282 milliseconds and the usage of the heap memory is 192.2 megabytes.
From the above results, when the conversion code according to the embodiment of the present invention is used, the execution time is reduced by 20% or more and the heap memory usage amount is 30% or more compared with the case of using the conversion code by the conventional method. Was reduced.

FIG. 5 shows an example of a system configuration that is an embodiment of the present invention.
The computer system (501) includes a CPU (502) and a memory (503). The memory (503) holds the program (504). The program (504) includes JAVA (trademark) code. The JAVA code includes a set or get instruction included in the wrapper class object, and data handled by the object corresponds to a data item in the COBOL language.
The CPU (502) reads and executes the program (504) held in the memory (503). The CPU (502) calls the wrapper class object in the program. When a higher-order char array of the char array to be accessed by the object is generated, the CPU (502) holds a pointer, the number of characters, and an offset indicating the upper-layer char array. The CPU (502) generates the char array that is the access target of the object when the char array of the upper layer of the char array that is the access target of the object has not been generated. Further, the CPU (502) causes each object for accessing the char array in the lower hierarchy of the char array that is the access target of the object to hold a pointer, the number of characters, and an offset indicating the char array.

6A to 6E are diagrams for facilitating the understanding of the invention described in the claims.
FIG. 6A shows the relationship between the COBOL code, the wrapper class, and the first to fourth objects.
FIG. 6B shows the relationship between the wrapper class and the first object. The constituent elements of claims 4 and 9 correspond to the constituent elements of claim 3. Each component of claim 9 corresponds to each component of claim 8.
FIG. 6C shows the relationship between the wrapper class and the second object. Each component of claim 5 corresponds to each component of claim 3.
FIG. 6D shows the relationship between the wrapper class and the third object. The constituent elements of claims 10 and 11 correspond to the constituent elements of claim 3.
FIG. 6E shows the relationship between the wrapper class and the fourth object. Each component of claims 12 and 14 corresponds to each component of claim 3. Each component of claim 14 corresponds to each component of claim 8.

FIG. 7 shows a block diagram further detailing the system configuration.
The computer system (701) includes a CPU (703) and a main memory (702), which are connected to a bus (714). The CPU (703) is preferably based on a 32-bit or 64-bit architecture, such as Intel's Xeon (TM) series, Core (TM) series, Atom (TM) series, Pentium (TM) series, The Celeron (TM) series, AMD's Phenom (TM) series, Athlon (TM) series, Turion (TM) series, and Empron (TM) can be used. A display (712) such as an LCD monitor is connected to the bus (714) via a display controller (707). The display (712) appropriately displays information about a computer system connected to a network via a communication line and information about software running on the computer system for management of the computer system. Used for display with a graphic interface. A hard disk or silicon disk (705) and a CD-ROM, DVD drive or BD drive (706) are also connected to the bus (714) via an IDE or SATA controller (704).

  The hard disk stores an operating system, a program that provides a Java processing environment such as J2EE, and other programs and data that can be loaded into the main memory.

  The CD-ROM, DVD or BD drive (706) is used for additionally introducing a program from the CD-ROM, DVD-ROM or BD to the hard disk as necessary. Further, a keyboard (710) and a mouse (711) are connected to the bus (714) via a keyboard / mouse controller (709).

  The communication interface (713) follows, for example, the Ethernet (trademark) protocol. The communication interface (713) is connected to the bus (714) via the communication controller (708), and plays a role of physically connecting the computer system and the communication line (715), and is an operating system of the computer system. A network interface layer is provided for the TCP / IP communication protocol of the communication function. The communication line may be a wired LAN environment or a wireless LAN environment based on a wireless LAN connection standard such as IEEE802.11a / b / g / n.

The example of the description of the data part in COBOL is shown. The example of the flow when the instruction of the set to the object of the hierarchy class which is the embodiment of the present invention is executed is shown. An example of a flow when a get instruction to an object of a hierarchical class, which is an embodiment of the present invention, is executed is shown. The example which converted the COBOL sentence which is an example of a structure array which is the embodiment of this invention into the JAVA code | cord | chord is shown. The example which converted the COBOL sentence which is an example of REDEFINES clause which is the embodiment of this invention into the JAVA code is shown. An example of converting a COBOL code into a JAVA code in the embodiment of the present invention will be described. A COBOL sample program to be converted into JAVA code is shown. An example of JAVA code obtained by converting the COBOL program of FIG. 4A by a conventional method is shown. 4B shows an example of JAVA code obtained by converting the COBOL program of FIG. 4A according to the embodiment of the present invention. The verification result of the JAVA program according to the embodiment of the present invention is shown. The example of the system configuration which is an embodiment of the present invention is shown. The relationship between the COBOL code, the wrapper class, and the first to fourth objects is shown. The relationship between the wrapper class and the first object is shown. The relationship between the wrapper class and the second object is shown. The relationship between the wrapper class and the third object is shown. The relationship between the wrapper class and the fourth object is shown. FIG. 6 shows a block diagram further detailing the system configuration of FIG. 5.

Claims (25)

A computer system for executing a program including JAVA (trademark) code converted from COBOL code,
A storage unit for holding a program including JAVA code having at least one declaration of an object whose data type is a wrapper class, wherein each of the declarations is a declaration converted from each of the declarations of data items included in the COBOL code. A storage unit;
The computer system, comprising: a CPU that reads the program from the storage unit into a memory and executes the program.   The computer according to claim 1, wherein the wrapper class has a function of managing data (hereinafter, second data) corresponding to data of a data item (hereinafter, first data) declared in the COBOL code. ·system. The wrapper class is
A first char array for storing the second data;
A variable for storing the number of characters of the second data;
The computer system according to claim 2, further comprising: a variable that stores an offset value that represents a position where the second data is stored. An object generated from the wrapper class (hereinafter referred to as a first object)
Managing third data corresponding to the second data; and a second char array corresponding to the first char array;
A first variable corresponding to the variable storing the number of characters of the third data;
The computer system according to claim 3, further comprising: a second variable corresponding to the variable that stores an offset value that represents a position where the third data is stored. The second char array is
Storing the third data, or
Sharing a memory area for a third char array included in an object (hereinafter referred to as a second object) that is in an upper hierarchy in the hierarchical structure to which the first object belongs and is generated from the wrapper class;
Here, the second object includes the third char array corresponding to the first char array, and the highest layer in which the memory area is allocated to the third char array. Object
The computer system according to claim 4, wherein the third char array includes the memory area in which the third data is stored.   The computer system according to claim 4, wherein the first variable stores the number of characters of the third data.   The computer system according to claim 5, wherein the second variable stores an offset value representing a position where the third data is stored on the memory area. The wrapper class is
A variable that stores numeric data,
An object of 0 or 1 for performing mutual conversion between the numeric data and the data on the first char array;
A flag indicating the validity of a variable for storing the numeric data;
The computer system according to claim 3, further comprising: a flag indicating the validity of the char array representation. An object generated from the wrapper class (hereinafter referred to as a first object)
Managing third data corresponding to the second data; and a second char array corresponding to the first char array;
A first variable corresponding to the variable storing the number of characters of the third data;
A second variable corresponding to the variable storing an offset value representing a position where the third data is stored;
A third variable corresponding to the variable storing the numeric data;
A first flag corresponding to the flag indicating the validity of a variable for storing the numeric data;
A second flag corresponding to the flag indicating the validity of the char array representation,
The computer system according to claim 8, further comprising: a first mutual conversion object corresponding to the object for performing the mutual conversion when the wrapper class includes an object for performing the mutual conversion. The wrapper class further includes an instruction sharing a memory area for the first char array;
An object generated from the wrapper class (hereinafter referred to as a first object) includes a second char array corresponding to the first char array and the shared instruction;
The instruction shared by the first object is:
The fourth char array included in the third object having a fourth char array generated from the wrapper class and corresponding to the first char array, the memory area for the second char array The computer system of claim 3 comprising instructions for sharing with a memory region. The second data is data corresponding to the first data declared in the REDEFINES clause of COBOL;
The computer system according to claim 10, wherein the instruction shared by the first object is included in a constructor executed in generation of the first object. The wrapper class further includes a definition of at least one object (hereinafter referred to as a fourth object) that is in a lower hierarchy in the hierarchical structure to which the first object belongs and is generated from the wrapper class;
The CPU further executes the following instruction, the instruction:
An instruction to execute the third data set or get instruction;
If no memory area is allocated for the second char array,
An instruction for allocating a memory area to the second char array;
An instruction for sharing a memory area for a fifth char array included in the fourth object,
The fourth object is
Managing fourth data corresponding to the second data, and the fifth char array corresponding to the first char array;
A fourth variable corresponding to the variable storing the number of characters of the fourth data;
The shared instruction comprising: a fifth variable corresponding to the variable storing an offset value representing a position where the fourth data is stored;
The computer system according to claim 4, further comprising: an instruction for setting a position in the memory area for the second char array of the fourth data with respect to the fifth variable. The shared instruction is
The memory device further includes an instruction to copy the fourth data stored in the fifth char array to the second char array when a memory area is allocated to the fifth char array. Item 13. The computer system according to Item 12. The wrapper class further includes a definition of at least one object (hereinafter referred to as a fourth object) that is in a lower hierarchy in the hierarchical structure to which the first object belongs and is generated from the wrapper class;
The CPU further executes the following instruction, the instruction:
An instruction to execute the third data set or get instruction;
If no memory area is allocated for the second char array,
An instruction for allocating a memory area to the second char array;
An instruction for sharing a memory area for a fifth char array included in the fourth object,
The fourth object is
Managing fourth data corresponding to the second data, and the fifth char array corresponding to the first char array;
A fourth variable corresponding to the variable storing the number of characters of the fourth data;
A fifth variable corresponding to the variable storing an offset value representing a position where the fourth data is stored;
A sixth variable corresponding to the variable storing the numeric data;
A second mutual conversion object corresponding to the object for performing the mutual conversion;
A third flag corresponding to the flag indicating the validity of a variable for storing the numeric data;
The shared instruction comprising: a fourth flag corresponding to the flag indicating the validity of the char array representation;
The computer system according to claim 9, further comprising: an instruction for setting a position in the memory area for the second char array of the fourth data with respect to the fifth variable. The shared instruction is
The memory device further includes an instruction to copy the fourth data stored in the fifth char array to the second char array when a memory area is allocated to the fifth char array. Item 15. The computer system according to Item 14. The instruction to copy is
The computer system according to claim 15, further comprising an instruction to set the third flag of the fourth object to invalid. When numerical data is given as the data to be set, the CPU further executes the following instruction,
An instruction to set the numeric data in the third variable;
The computer system according to claim 9, further comprising: an instruction to set the second flag to invalid. An instruction to set the numeric data in the third variable is
The computer system according to claim 17, further comprising an instruction to set the first flag to be valid. The execution of the instruction is a get instruction,
The CPU further executes the following instruction, the instruction:
The computer system according to claim 14, further comprising: an instruction for retrieving the fourth data from the fifth char array in which the memory area is shared. The execution of the instruction is a get instruction,
The CPU further executes the following instruction, the instruction:
The computer system according to claim 19, further comprising: an instruction for acquiring the fourth flag and confirming that the acquired fourth flag is set to be valid. The CPU further executes the following instruction, the instruction:
An instruction for obtaining numerical data from the third variable;
An instruction for converting the acquired data into character type data using the first mutual conversion object;
An instruction to set the converted character type data in the second char array;
The computer system according to claim 9, further comprising: an instruction for effectively setting the second flag. The CPU further executes the following instruction, the instruction:
An instruction to obtain character type data from the second char array;
Using the first mutual conversion object, an instruction for converting the acquired character type data into numeric type data;
An instruction to set the converted numeric data to the third variable;
The computer system according to claim 9, further comprising: an instruction to set the first flag to be valid. A method for executing a program including JAVA (trademark) code converted from COBOL code, wherein the computer system performs the following steps:
Reading the program having at least one declaration of an object whose data type is a wrapper class from a storage unit into a memory, wherein each of the declarations is a declaration converted from a declaration of a data item included in a COBOL code Said reading step;
Executing the read program. A method for executing a program including JAVA (trademark) code converted from COBOL code, wherein the computer system performs the following steps:
Reading a program including a JAVA code having at least one declaration of an object whose data type is a wrapper class from a storage unit into a memory;
Each of the declarations is a declaration converted from each of the declarations of the data items included in the COBOL code, and the wrapper class corresponds to data of the data items declared in the COBOL code (hereinafter referred to as first data). Has a function of managing data (hereinafter referred to as second data),
The wrapper class is
A first char array for storing the second data;
A variable for storing the number of characters of the second data;
A variable for storing an offset value representing a position where the second data is stored;
A variable of 0 or 1 that stores numeric data,
An object of 0 or 1 for performing mutual conversion between the numeric data and the data on the first char array;
A 0 or 1 flag indicating the validity of a variable storing the numeric data;
a 0 or 1 flag indicating the validity of the char array representation;
Including zero or more object definitions generated from the wrapper class,
An object generated from the wrapper class (hereinafter referred to as a first object) is
Managing third data corresponding to the second data; and a second char array corresponding to the first char array;
A first variable corresponding to the variable storing the number of characters of the third data;
A second variable corresponding to the variable storing an offset value representing a position where the third data is stored;
And at least one object (hereinafter referred to as an object in a lower hierarchy) that is in a lower hierarchy in the hierarchical structure to which the first object belongs and is generated from the wrapper class,
The lower layer object is:
Managing fourth data corresponding to the second data, and the third char array corresponding to the first char array;
A third variable corresponding to the variable storing the number of characters of the fourth data;
A fourth variable corresponding to the variable storing an offset value representing a position where the fourth data is stored;
A fifth variable corresponding to the variable storing the numeric data;
A second mutual conversion object corresponding to the object for performing the mutual conversion;
A first flag corresponding to the flag indicating the validity of a variable for storing the numeric data;
A second flag corresponding to the flag indicating the validity of the char array representation,
Said reading step;
Executing the third data set or get instructions;
If no memory area is allocated for the second char array,
Allocating a memory area for the second char array;
Sharing a memory area for a third char array included in the lower layer object;
Setting the position in the memory area for the second char array of the fourth data for the fourth variable.   A computer program that causes a computer to execute the steps of the method according to any one of claims 23 to 24.

Images