JP6982920B1 - Source code converter and program - Google Patents

Abstract

PROBLEM TO BE SOLVED: To improve the versatility and maintainability of a Java source code corresponding to a COBOL source code including a description of a group item. SOLUTION: In a source code conversion device 1 for converting a COBOL source code in which a group item 50 is described into a Java source code, a parent-child corresponding to a hierarchical structure of a basic item 51 included in the group item 50 and a dependency relationship. A group item converter 34 that converts the group item 50 into a primitive type class 70 including a parent class 71 and a child class 72 having a relationship is provided, and the group item converter 34 is the basic item of the group item 50. Annotation indicating information about the fixed-length byte array 80 in which the values of 51 are arranged is given to the class 70. [Selection diagram] Fig. 2

Description

The present invention relates to a source code converter and a program.

In recent years, so-called modernization, in which a relatively large-scale legacy system including a mainframe is modified, has been widely performed (see, for example, Patent Document 1).
Many legacy systems generally run programs written in COBOL in the legacy language on the mainframe, and when promoting modernization, the source code written in COBOL is written in Java®. So-called conversion development is being carried out in which the source code is converted (see, for example, Patent Document 2, Patent Document 3, and Patent Document 4).
Documents related to conversion development include, for example, Patent Document 5 and Patent Document 6, and these Patent Documents 5 and 6 include group items described in the data part (DATA DIVISION) of the COBOL source code. Is shown in the Java source code using a uniquely defined wrapper class.

Japanese Unexamined Patent Publication No. 2018-1517113 Japanese Unexamined Patent Publication No. 2019-040399 International Publication No. 2015/015622 Japanese Unexamined Patent Publication No. 2004-118374 Japanese Unexamined Patent Publication No. 2010-86218 Japanese Unexamined Patent Publication No. 2020-60842

However, in the techniques of Patent Document 5 and Patent Document 6, the Java execution environment needs to have a function of interpreting the wrapper class of the above-mentioned original definition in advance, and the programmer who develops the conversion is the above-mentioned original. You need to understand the specifications of the definition wrapper class. Therefore, the converted Java source code has low versatility in the execution environment, and has a problem in terms of maintainability for the developer.

An object of the present invention is to provide a source code conversion device and a program capable of enhancing the versatility and maintainability of Java source code corresponding to COBOL source code including description of group items.

One aspect of the present invention is a source code conversion device that converts a COBOL source code in which a group item is described into a Java source code, in which a hierarchical structure of basic items included in the group item and a parent-child relationship corresponding to a dependent relationship are provided. A primitive type class including a parent class having a and a child class includes a group item converter that defines the group item in the Java source code, and the group item converter is a value of the basic item of the group item. It is characterized in that an annotation indicating information about a fixed-length byte array in which is arranged is given to the class.

One aspect of the present invention is a program that causes a computer to generate Java source code corresponding to COBOL source code, and has a hierarchical structure of basic items including group items described in the COBOL source code, and dependent relationships. Annotation indicating information about a fixed-length byte array in which the values of the basic items of the group item are arranged is defined by defining a primitive type class including a parent class having a parent-child relationship corresponding to and a child class. It is a program that allows a computer to execute what is given to a class.

According to one aspect of the present invention, the versatility and maintainability of the Java source code corresponding to the COBOL source code including the description of the group item is enhanced.

It is a figure which shows the structure of the source code conversion apparatus which concerns on embodiment of this invention together with the functional structure of a processor. It is a figure which shows the functional structure of the conversion processing part. It is a figure which shows schematically the composition of a COBOL source together with an example of a group item. It is a figure which shows an example of the Java class after conversion schematically. It is a figure which shows the correspondence between the data type of the basic item of COBOL and the primitive type of Java. It is a flowchart of a group item conversion process. It is a figure which shows an example of the conversion from a group item to a class. It is a figure which shows the description example of COBOL and Java. It is a figure which shows the correspondence between the group item including the sequence in COBOL and the class in Java. It is a figure which shows the correspondence between the group item including "redefinition" in COBOL and the class in Java. It is a figure which shows an example of the Setter method.

Hereinafter, embodiments of the present invention will be described with reference to the drawings.
FIG. 1 is a diagram showing the configuration of the source code conversion device 1 according to the present embodiment together with the functional configuration of the processor 16.
The source code conversion device 1 is a device that translates the source code described in COBOL (hereinafter referred to as COBOL source NC) into the source code described in Java (hereinafter referred to as Java source NJ), and is an input I /. It is composed of a computer having an F circuit 10, an output I / F circuit 12, a storage device 14, and a processor 16.

The input I / F circuit 10 is an interface circuit to which the input device 2 is connected.
The input device 2 is a device for inputting COBOL source NC data to the source code conversion device 1, and corresponds to various devices having a data input function such as a user operation device, a reading device, and a receiving device. The user operation device is a user operation type device such as a keyboard, a mouse, and a touch panel. The reading device is a device that reads the COBOL source NC recorded on a recording medium such as a semiconductor memory, an optical recording disk, or a paper medium. The receiving device is a device that receives COBOL source NC from an external device through wired communication or wireless communication. The source code conversion device 1 may include the input device 2.

The output I / F circuit 12 is an interface circuit to which the output device 4 is connected.
The output device 4 is a device that outputs a Java source NJ from the source code conversion device 1, and corresponds to various devices having a data output function such as a display device, a writing device, and a transmitting device. The display device is a device that displays the Java source NJ. The writing device is a device that writes the Java source NJ to a recording medium such as a semiconductor memory, an optical recording disk, or a paper medium. The transmitting device is a device that transmits a Java source NJ to an external device through wired communication or wireless communication. The source code conversion device 1 may include the output device 4.

The storage device 14 is a device that stores various data such as COBOL source NC and Java source NJ, and is, for example, a memory device (also referred to as a main storage device) such as RAM and ROM, and a disk drive such as HDD and SSD. This applies to devices (also called auxiliary storage devices). Further, the storage device 14 stores the program 18 that realizes the source code conversion.

The processor 16 is an arithmetic processing unit that centrally controls each part of the source code conversion device 1 by executing an OS (Operating System) stored in the storage device 14. Further, the processor 16 realizes various functional configurations required for source code conversion by executing the above program 18.
As shown in FIG. 1, such a functional configuration includes an acquisition unit 20, a conversion processing unit 22, and an output unit 24.

The acquisition unit 20 acquires the COBOL source NC from the storage device 14 and outputs it to the conversion processing unit 22. The conversion processing unit 22 converts the COBOL source NC into a Java source NJ and outputs it to the output unit 24, and the detailed configuration will be described later. The output unit 24 outputs the Java source NJ to the storage device 14.

FIG. 2 is a diagram showing a functional configuration of the conversion processing unit 22. Further, FIG. 3 is a diagram schematically showing the configuration of the COBOL source NC together with an example of the group item 50.
As shown in FIG. 2, the conversion processing unit 22 includes a COBOL source NC for converting a COBOL source NC into a Java source NJ, and a COBOL compiler 32 for analyzing the COBOL source NC. Further, the COBOL processing unit 30 includes a COBOL source NC. A group item converter 34 is provided, and the group item converter 34 converts the group item 50 (see FIGS. 3 and 5) described in the COBOL source NC into a Java class 70 (see FIG. 5).

As shown in FIG. 3, the COBOL source NC that is the conversion source generally has a heading unit (also referred to as “IDENTIFICATION DIVISION”) 40, an environment unit (also referred to as “ENVIRONMENT DIVISION”) 41, and a data unit (“DATA DIVISION”). (Also also referred to as) 42 and a procedure unit (also referred to as “PROCEDURE DIVISION”) 43, which are described in this order.
The heading unit 40 is a place where information (program name, etc.) for identifying the COBOL source NC is described. The environment unit 41 is mainly a place where the name of the computer that executes the COBOL source NC and the definition of information such as environment variables are described. The data unit 42 is mainly a place where the group item 50 and the declaration of the record of the file are described. The procedure unit 43 is mainly a place where the main processing content is described.

The language conversion unit 30 of the present embodiment converts the group item 50 described in the data unit 42 into the Java class 70 by the group item converter 34, and the other parts are, for example, machine-translated by Java. Convert to source code. "Machine translation conversion" means converting a COBOL source NC character string into a Java character string in a command word unit, a syntactic unit, or various units according to the COBOL grammar. In addition to the "machine translation conversion", any known or well-known method can be used for the conversion of the portion other than the group item 50.

In the COBOL grammar, the group item 50 is a collection of one or more basic items 51, and the label number 52 attached to each basic item 51 defines the hierarchical structure and the dependency relationship of the basic items 51. The basic item 51 may be a single data item in which the basic data type 54 is declared. The data item is a definition statement including a pair of the length of the data type 54 to be used (the size of the storage area to be secured) and the name of the data item, and is a variable in other languages such as Java and C language. handle. When the group item 50 is compiled by the compiler, it is converted into a fixed-length byte array 80 (see FIG. 7) in which array elements storing the values of each basic item 51 are arranged. In this way, since the group item 50 is represented by the fixed-length byte array 80, the definition of the group item 50 is generally used for the layout of data when sending and receiving data related to the group item 50 between programs and the like. Has been done.

The COBOL compiler 32 has a general compiler function for compiling COBOL, executes analysis processing such as lexical analysis, syntactic analysis, and semantic analysis on the COBOL source NC, and analyzes the analysis obtained by the analysis processing. The result 36 is output to the language conversion unit 30.
The COBOL compiler 32 of the present embodiment analyzes at least information about the hierarchical structure and subordination of each basic item 51 of the group item 50, and the fixed-length byte array 80 reserved in the storage area based on the definition of the group item 50. Then, the results of these analyzes are included in the analysis result 36 and output to the language conversion unit 30. The information about the fixed-length byte array 80 includes the number of array elements of the fixed-length byte array 80, the data length of each basic item 51 in the fixed-length byte array 80, the position, and the like.
The language conversion unit 30 may use the analysis result 36 of the COBOL compiler 32 for conversion of parts other than the group item 50 of the COBOL source NC. Further, in the following description, the order of each array element of the fixed-length byte array 80 is counted with the head as the zeroth (i = 0).

The group item converter 34 converts the group item 50 of the COBOL source NC into the class 70 of the primitive type in Java.

FIG. 4 is a diagram schematically showing an example of Java class 70 after conversion.
As shown in the figure, class 70 includes one parent class 71 and one or more child classes 72. Each field 73 of the parent class 71 and the child class 72 corresponds to the basic item 51, and the parent-child relationship of the parent class 71 and the child class 72 corresponds to the hierarchical structure and the subordinate relationship of the basic item 51. That is, the field 73 included in a child class 72 is located in a hierarchy below the child class 72 or the parent class 71 from which the child class 72 is derived, and the derivation relationship of the child class 72 is a dependency relationship of the basic item 51. Corresponds to.

Further, in the class 70 of the present embodiment, the parent class 71 and the child class 72 are attached with the class annotation 75A, and the field 73 is attached with the field annotation 75B. The annotation 75A for the class and the annotation 75B for the field show information about the fixed-length byte array 80 of the group item 50, and the details thereof will be described later.

Further, in the class 70, the parent class 71 is a class that inherits the superclass (hereinafter referred to as “original superclass”) 65 defined independently, and the original superclass 65 includes the class annotation 75A and the field. Based on the information about the fixed-length byte array 80 indicated by the annotation 75B, a method for accessing the fixed-length byte array 80 and the like are defined.

The group item converter 34 of the present embodiment specifies the hierarchical structure and dependencies of the basic item 51 and the information regarding the fixed-length byte array 80 based on the analysis result 36 of the COBOL compiler 32, and the group item by the programmer. This information can be identified accurately and easily without depending on the description method of 50.

FIG. 5 is a diagram showing the correspondence between the data type 54 of the basic item 51 of COBOL and the primitive type of Java.
Java's primitive types are "short type", "byte type", "long type", "int type", "double type", "float type", "String type", "Boolean type", and "BigDecimal type". As shown in FIG. 5, each data type 54 that can be taken by the basic item 51 of COBOL is associated with any of the primitive types of Java in advance. The position of the decimal point in the fixed point of COBOL is associated with the value of "scale" in Java's "BigDecimal type".
The type correspondence data 37 (see FIG. 2) showing such correspondence is preliminarily incorporated in the group item converter 34, and the group item converter 34 refers to the type correspondence data 37 and sets each basic item 51 as a primitive type. Convert to field 73 of.

In this way, since the converted class 70 (parent class 71 and child class 72) is a primitive type (that is, all fields 73 are primitive types), Java's development environment and execution environment are special. The class 70 can be used without importing the library (the library including the uniquely defined wrapper class described in Patent Documents 5 and 6). That is, since the converted class 70 is a so-called POJO (Plan Old Java Object), the versatility and maintainability of the converted Java source NJ are greatly improved.
Further, in the Java source NJ, the primitive type class 70 passes the value of the field 73 to another function or the like by "passing by value", so that the behavior is the same as the "MOVE" instruction in COBOL, and the developer is less likely to misunderstand. can. Further, when a class 70 other than the primitive type is used, "passing by reference" may be performed instead of "passing by value", and there is a risk of including a bug. On the other hand, according to the class 70 of the present embodiment, such a risk can be surely avoided.

Here, when the COBOL data type 54 is associated with the Java primitive type, one primitive type in Java may be associated with a different data type 54 in COBOL. For example, in FIG. 5, the COBOL packed decimal number and the zone decimal number are both associated with Java's "long type".
Therefore, as shown in FIG. 4 above, the field annotation 75B includes the first argument 75B1 indicating the data type 54 of the basic item 51, and the data type of the basic item 51 corresponding to the field 73 is provided by the first argument 75B1. 54 becomes identifiable.
On the other hand, the annotation 75A for the class includes the first argument 75A1 indicating the original superclass of the succession source.

Further, both the class annotation 75A and the field annotation 75B of the present embodiment include an argument indicating information regarding the fixed-length byte array 80 of the group item 50.
Specifically, the class annotation 75A includes a second argument 75A2 indicating the data length of the fixed-length byte array 80 (the number of array elements in this embodiment), and the field annotation 75B has the number of digits of the basic item 51. It includes a second argument 75B2 indicating (corresponding to the number of characters in the case of a character type) and a third argument 75B3 indicating a position (start position in this embodiment) in the fixed-length byte array 80.
The second argument 75A2, 75B2, and the third argument 75B3 describe information about the fixed-length byte array 80 corresponding to the group item 50 in the class 70.

Next, the conversion operation by the group item converter 34 will be described.

FIG. 6 is a flowchart of the group item conversion process. FIG. 7 is a diagram showing an example of conversion from the group item 50 to the class 70.
As shown in FIG. 6, the group item converter 34 first defines a primitive type field 73 for all the basic items 51 of the group item 50 based on the analysis result 36 of the COBOL source NC or the COBOL compiler 32. , The parent class 71 of the parent-child relationship corresponding to the hierarchical structure and the subordination of the basic item 51, and the child class 72 are defined (step S1).

As shown in FIG. 7, when the group item 50 has, for example, a three-layer structure in which the label number 52 is composed of “01”, “02”, and “03”, the group item converter 34 is the top layer (first layer). A parent class 71 named "class STRUCT_TOP" corresponding to "01 STRUCT_TOP" of the layer) is defined, and a parent corresponds to each basic item 51 of the second layer (label number 52 = "02"). Each field 73 of class 71 is defined. In FIG. 7, the name of the original superclass 65 is "Struct", and the group item converter 34 defines a parent class 71 that inherits this "Struct" class by "extends".

Further, in FIG. 7, since the second layer “02 STRUCT_CHILD” is also a group item 50, the group item converter 34 defines a child class 72 named “class STRUCT_CHILD” corresponding to this “02 STRUCT_CHILD”. Then, the group item converter 34 defines each field 73 of the child class 72 corresponding to each basic item 51 of the third layer (label number 52 = “03”).

As shown in FIG. 7, the group item converter 34 defines all or part of the names of the group item 50 and the basic item 51 corresponding to those names in the definitions of the parent class 71, the child class 72, and the field 73. It is easy for the developer to understand the mutual correspondence between the class 70 and the group item 50.

Returning to FIG. 6, the group item converter 34 assigns the annotation 75A for the class and the annotation 75B for the field to the class 70 based on the analysis result 36 (analysis result relating to the fixed-length byte array 80) of the COBOL compiler 32 (step). S2).
As a result, the group item 50 is converted into the primitive type class 70.

Regarding the generation of the annotation 75A for the class and the annotation 75B for the field, the group item converter 34 generates the annotation 75A for the class based on the fixed-length byte array 80 of the group item 50, and generates the annotation 75A for the class. It is given to the parent class 71 and the child class 72. Further, the group item converter 34 generates the field annotation 75B based on the fixed-length byte array 80, the data type 54 of the basic item 51, and the number of digits, and assigns the field annotation 75B to the field 73.

In the example of FIG. 7, as a result of compiling the group item 50, a fixed-length byte array 80 having a length of 6 bytes is generated in which the value expressed in hexadecimal is stored. In the fixed-length byte array 80, the value of "01 CARA_VALUE" (illustrated example "41" (= ASCII character "A")) is stored in the array element at the head (i = 0), and the first (i =). The value of "03 CARA_VALUE" (illustrated example "42" (= ASCII character "B")) is stored in the array element of 1), and the second (i = 2) to third (i = 3) array. The value of "03 ASCII_VALUE" (illustrated example "00" and "0B") is stored in the element, and the value of "03 PACK_VALUE" is stored in the fourth (i = 4) to fifth (i = 5) array elements. Values (illustrated examples "12" and "3C") are stored.

When generating the annotation 75A for the class, the group item converter 34 specifies the number of array elements in the fixed-length byte array 80 for the parent class 71 and the child class 72, and sets the number of the array elements to the second argument 75A2. Store.
In the example of FIG. 7, since the number of sequence elements of "01 STRUCT_TOP" corresponding to the parent class 70 and "02 STRUCT_CHILD" corresponding to the child class 72 is "6" and "5", the group items. The converter 34 stores "6" in the second argument 75A2 (name: lens) of the class annotation 75A of the parent class 71, and stores "5" in the second argument 75A2 of the class annotation 75A of the child class 72. ..

On the other hand, when generating the field annotation 75B, the group item converter 34 specifies the data type 54, the number of digits, and the start position in the fixed-length byte array 80 of the corresponding basic item 51 for each field 73, respectively. Is stored in the first argument 75B1, the second argument 75B2, and the third argument 75B3.

In the example of FIG. 7, in "02 CARA_VALUE", the data type 54 is X type (half-width character), the number of digits is "1", and the start position in the fixed-length byte array 80 is the head (i = 0). It is an array element. In this case, the group item converter 34 stores "CBLType.X" clearly indicating that it is an X type in the first argument 75B1 (name: type) of the field annotation 75B, and stores the second argument 75B2 (name: digit). ), And "0" indicating the first array element is stored in the third argument 75B3 (name: location).

Further, in the example of FIG. 7, in "03 PACK_VALUE", the data type 54 is a packed decimal type and the number of digits is "3". Since the field 73 corresponding to this "03 PACK_VALUE" belongs to the child class 72, the start position in the byte array 80A occupied by the child class 72 in the fixed-length byte array 80 is used as the start position in the fixed-length byte array 80. .. In the example of FIG. 7, in the byte array 80A occupied by the child class 72, the start position of "03 PACK_VALUE" is the third (j = 3) array element.
In this case, the group item converter 34 stores "CBLType.us9_COMP9" that clearly indicates that it is a packed decimal type in the first argument 75B1 of the field annotation 75B, and stores "3" in the second argument 75B2. , The start position "3" is stored in the third argument 75B3.

In this embodiment, the character string used for the first argument 75B1 of the field annotation 75B is preset corresponding to the data type 54 of the basic item 51 of COBOL, and the character string corresponds to the data type 54. It is referred from the annotation information set in the field 73 to be used. Further, as described above, the original superclass 65 defines a method for accessing the fixed-length byte array 80 based on the first argument 75B1, the second argument 75B2, and the third argument 75B3 of the field annotation 75B. Has been done. Access to the fixed-length byte array 80 includes, for example, reading and writing values to the fixed-length byte array 80 and generating the fixed-length byte array 80.

As described above, in the class 70, each of the parent class 71, the child class 72, and the field 73 corresponding to the basic item 51 of the group item 50 contains the annotation 75A for the class and the annotation for the field containing information about the fixed-length byte array 80. 75B is given.
As a result, in the converted Java source NJ, the processing related to the fixed-length byte array 80 (for example, data exchange between the field 73 and the fixed-length byte array 80) is performed by the class annotation 75A and the field annotation 75B. It can be realized by using. In the present embodiment, since the class 70 inherits the original superclass 65 including the method for accessing the fixed-length byte array 80, the labor required for coding the process for handling the fixed-length byte array 80 is reduced.
Further, since the annotation 75A for the class and the annotation 75B for the field are described in the Java source NJ in a form accompanying the class 70, the readability can be improved.

Further, since the class 70 has a parent class 71 and a child class 72 of a parent-child relationship corresponding to the hierarchical structure and the subordination of the basic item 51, the same notation as "OF modification" in the COBOL grammar is used in the language conversion unit 30. Described in the Java source NJ after conversion by. For example, the "MOVE" instruction of "03 CHAR_VALUE" in the third layer of the group item 50 shown in FIG. 7 is described as in the description example 1 as shown in FIG. On the other hand, in the Java source NJ, the same instructions as in the description example 1 are described as in the description example 2, and the readability of the converted Java source NJ is improved.

FIG. 9 is a diagram showing the correspondence between the group item 50 including the sequence in COBOL and the class 70 in Java.
Within the population item 50, the "array" is declared using the "OCCURS clause", and in the example of FIG. 9, an array in the form of a single data item is represented by "02 CHAR_VALUE PIC X (02) OCCURS 2." It is defined, and an array in the form of a group item is defined by "02 STRUCT_CHILD OCCURS 2.".
In the example of the figure, the fixed-length byte array 80-1 corresponding to the array of a single data item format is a one-dimensional array of 2 bytes × 2, and the characters “A”, “1”, and “A”. , And each of "2" are represented by hexadecimal numbers, and the values are stored in each array element.
Further, in the example of the figure, the array in the group item format is an array consisting of a character type data item and a numerical type data item, and is used for each array element of the fixed length byte array 80-2 corresponding to the array. Stores a value in which each of the character "B", the signed numerical value "+10", the character "C", and the signed numerical value "+11" is indicated by a hexadecimal number.

When the group item converter 34 converts such a group item 50 into a Java class 70, first, the parent class 71 and the child class 72 of the parent-child relationship corresponding to the hierarchical structure and the dependency relationship of the basic item 51 are defined. In the example of FIG. 9, the group item converter 34 defines “class OCCURS_STRUCT” corresponding to “01 OCCURS_STRUCT” of group item 50 as the parent class 71, and “class STRUCT_CHILD” corresponding to “02 STRUC_CHILD OCCURS 2.”. It is defined as a child class 72. Further, the group item converter 34 also defines the field 73 corresponding to the COBOL sequence as an array. In FIG. 9, the fields 73 defined as an array are designated by reference numerals 73-1 and 73-2 in order to distinguish them from the other fields 73.

Next, the group item converter 34 assigns the annotation 75A for the class and the annotation 75B for the field to the class 70. In this case, the field annotation 75B given to the fields 73-1 and 73-2 corresponding to the COBOL sequence has a fourth argument 75B4 (illustrated example, "occurs") indicating that the field annotation 75B corresponds to the COBOL sequence. It is included, and information about the array is described in class 70 by this fourth argument 75B4. Then, by the fourth argument 75B4 and the above-mentioned other arguments (second argument 75A2, 75B2, third argument 75B3) indicating information about the fixed-length byte arrays 80-1 and 80-2, the "array" in COBOL is used. The same function as is realized by Java class 70.

In the present embodiment, the original super class 65 (“Struct class” in the illustrated example) has fields 73-1 and 73-2 based on the value of the fourth argument 75B4 (“occurs”) included in the field annotation 75B. By specifying that it corresponds to an array and having a function of setting a value in fields 73-1 and 73-2 based on the fixed-length byte arrays 80-1 and 80-2 corresponding to the array, "COBOL" The same function as the array of "" is realized.
For example, in FIG. 9, for field 73-1 corresponding to an array of single data item format, the original superclass 65 puts "CHAR_VALUE [0] =" in each array element of "String []" in field 73-1. The values are set so that "A1" and "CHAR_VALUE [1] =" A2 "".
Further, for the field 73-2 corresponding to the array of the group item format, the original superclass 65 sets the value in each array element of "STRUCT_CHILD []" of the field 73-2 as follows. That is, in the original super class 65, the values of "String =" B "" and "short = + 10" are set in "STRUCT_CHILD [0]", and "String =" C "" and "String =" C "" are set in "STRUCT_CHILD [1]". Set the value of "short = +11".

FIG. 10 is a diagram showing the correspondence between the group item 50 including “redefinition” in COBOL and the class 70 in Java.
In the group item 50, "redefinition" is declared using the "REDDEFINES clause", and in the example of FIG. 10, "YYYYMMDD" is redefined as "YYMMDD_R" by the "REDDEFINES clause". Further, in the figure, "YYYYMMDD" is a basic item 51 indicating the date as an 8-digit character string number (3 digits for the year and 2 digits for the month and day), and "YYMMDD_R" indicates the date. It is defined as a basic item 61 indicated by a 6-digit character string number (2 digits each for year, month, and day).
Then, when the "YYYYMMDD" is compiled by the compiler, it is converted into a fixed-length byte array 80 consisting of eight array elements, and each array element contains a character string number of each digit of the date in hexadecimal. The value indicated by is stored.

The example of FIG. 10 shows the case where the date indicated by "YYYYMMDD" is "August 10, 2021", and the 8-digit character string numerical value indicating the date is expressed in hexadecimal notation. , "32", "30", "32", "31", "30", "38", "31", and "30", and each of these values is stored in each array element of the fixed-length byte array 80.
On the other hand, for "YYMMDD_R", the 0th (i = 0) and 1st (i = 1) array elements of the fixed-length byte array 80 are ignored by "03 FILLER PIC X (02)" in FIG. 03 YYMMDD PIC X (06) ”refers to the array elements from the second (i = 2) to the seventh (i = 7) of the fixed-length byte array 80.

When the group item converter 34 converts such a group item 50 into a Java class 70, first, the parent class 71 and the child class 72 of the parent-child relationship corresponding to the hierarchical structure and the dependency relationship of the basic item 51 are defined. In the example of FIG. 10, the group item converter 34 defines "class REDDEFINES_STRUCT" corresponding to "01 REDEFINES_STRUCT" of the group item 50 as the parent class 71, and "class YYMMDD" corresponding to "02 YYMMDD_R REDEFINES YYYYMMDD". Defined as class 72.

Next, the group item converter 34 assigns the annotation 75A for the class and the annotation 75B for the field to the class 70. In this case, the field annotation 75B assigned to the field 73 (“Public YYMMDD_R YYMMDD_R;” in FIG. 10) corresponding to the redefinition clause is the fifth argument 75B5 (illustration example, “Public YYMMDD_R YYMMDD_R;”) indicating the basic item 51 of the redefinition source. "Redefines") is included, and the information regarding the redefinition is described in the class 70 by this fifth argument 75B5. Then, the fifth argument 75B5 and the other arguments described above (second argument 75A2, 75B2, third argument 75B3) indicating information about the fixed-length byte array 80 provide the same function as "redefinition" in COBOL. It will be realized by Java class 70.

In the Java source NJ, the field 73 (“String YYMMDD;” in FIG. 10) of the child class 72 (“class YYMMDD_R” in FIG. 10) corresponding to the redefinition destination is updated by the Setter method 77 shown in FIG. It is possible by adding to the child class 72 and reflecting the change of the child class 72 corresponding to the redefinition destination in the parent class 71 corresponding to the redefinition source. In the figure, the process for such reflection is coded in the logic unit 77A.

According to this embodiment, the following effects are obtained.

The source code conversion device 1 of the present embodiment is a device that converts a COBOL source NC in which a group item 50 is described into a Java source NJ, and includes a group item converter 34.
The group item converter 34 puts the group item 50 into the primitive class 70 including the hierarchical structure of the basic item 51 included in the group item 50, the parent class 71 having the parent-child relationship corresponding to the dependency relationship, and the child class 72. Convert. Further, the group item converter 34 assigns the class annotation 75A and the field annotation 75B indicating information about the fixed-length byte array 80 in which the values of the basic item 51 of the group item 50 are arranged to the class 70.

According to this configuration, since the class 70 obtained by converting the group item 50 is a primitive type, the class 70 can be used without importing a special library in the Java development environment and execution environment, and the converted Java source NJ can be used. The versatility and maintainability of the are greatly improved.
In addition, since the class 70 is given the annotation 75A for the class and the annotation 75B for the field containing the information about the fixed-length byte array 80, the processing related to the fixed-length byte array 80 is performed by using the annotation 75A for the class and the annotation 75B for the field. Can be realized.
Further, since the annotation 75A for the class and the annotation 75B for the field are described in the Java source NJ in a form accompanying the class 70, the readability can be improved.

In the source code conversion device 1 of the present embodiment, the field annotation 75B given to the field 73 corresponding to the basic item 51 includes the information of the data type 54 of the corresponding basic item 51.
According to this configuration, even if a plurality of COBOL data types 54 are associated with one primitive type, each data type 54 can be correctly identified by the field annotation 75B.

In the source code conversion device 1 of the present embodiment, the group item converter 34 is an original superclass of an original definition having a method including access to the fixed-length byte array 80 based on the annotation 75A for the class and the annotation 75B for the field. Generate a parent class 71 that inherits 65.

According to this configuration, it is possible to reduce the labor required for coding the process for handling the fixed-length byte array 80.

It should be noted that the above-described embodiment is merely an example of one aspect of the present invention, and can be arbitrarily modified and applied without departing from the gist of the present invention.

In the above-described embodiment, the group item converter 34 generates two types of annotations, a class annotation 75A and a field annotation 75B, as annotations indicating information about the fixed-length byte array 80. However, the form of annotation is arbitrary as long as it shows information about the fixed-length byte array 80.

In the above-described embodiment, the program 18 does not realize the function of converting all of the COBOL source NC into the Java source NJ, but may at least realize the function of the collective item converter 34.
In this case, the program 18 is in Java, which includes the hierarchical structure of the basic item 51 included in the group item 50 described in the COBOL source NC, and the parent class 71 and the child class 72 having a parent-child relationship corresponding to the dependency relationship. It is to make the computer execute the definition of the class 70 of the primitive type and the addition of the annotation indicating the information about the fixed-length byte array 80 in which the values of the basic item 51 of the group item 50 are arranged to the class 70. ..
When the computer executes the program 18, the class 70 corresponding to the group item 50 described in the COBOL source NC is generated.
The program 18 can be distributed by recording the program 18 on a recording medium such as an optical disk or a portable semiconductor memory, or by transmitting the program 18 through a telecommunication line.

The functional blocks shown in FIGS. 1 and 2 are schematic views showing the components classified according to the main processing contents in order to make the invention of the present application easy to understand, and each component corresponds to the processing contents. It can also be classified into more components. It can also be categorized so that one component performs more processing.

1 Source code converter 22 Conversion processing unit 30 Language conversion unit 32 COBOL compiler 34 Group item converter 36 Analysis result 37 type Corresponding data 42 Data unit 50 Group item 51 Basic item 54 Data type 65 Original super class 70 Class 71 Parent class 72 Child Class 73 Field 75A Class Annotation 75B Field Annotation 80 Fixed Length Byte Array NC COBOL Source NJ Java Source

Claims (4)

In a source code conversion device that converts a COBOL source code in which a group item is described into a Java source code.
It is provided with a group item converter that converts the group item into a primitive type class including a hierarchical structure of the basic items included in the group item, a parent class having a parent-child relationship corresponding to a dependency relationship, and a child class.
The collective item converter
A source code conversion device characterized in that an annotation indicating information regarding a fixed-length byte array in which the values of the basic items of the group item are arranged is added to the class. The annotation is
The source code conversion device according to claim 1, wherein the information of the data type of the basic item is included. The collective item converter
The source code conversion device according to claim 1 or 2, wherein the parent class inherits the superclass having a method including access to the fixed-length byte array based on the annotation. To define a primitive type class in Java, including a hierarchical structure of basic items included in the group items described in the COBOL source code, a parent class having a parent-child relationship corresponding to a dependent relationship, and a child class.
Annotating the class with information about a fixed-length byte array in which the values of the basic items of the group item are arranged is added.
A program that causes a computer to run.

Images