JP6458196B1 - Program conversion system, conversion program execution system, information processing system, program conversion method, conversion program execution method, and information processing method - Google Patents

Abstract

A COBOL language specification for calling a subprogram is reproduced. A program conversion system outputs a data definition reading unit that sequentially reads data definitions in a data unit of a COBOL source program, and a source code for generating an instance of a class for realizing the data definition in a Java source program If the data definition code output part and the data definition include the data item for which the initial value is set, the first source code for calling the method for initializing the data item to the initial value in the class is output. And an initialization attribute output unit that outputs a second source code of a method for outputting information indicating whether or not the COBOL source program has an initialization attribute. [Selection] Figure 6

Description

  The present invention relates to a program conversion system, a conversion program execution system, an information processing system, a program conversion method, a conversion program execution method, and an information processing method.

  With the opening of the core system, attention is focused on conversion of a COBOL source program into a Java (registered trademark) source program. For example, Patent Document 1 discloses a technique for reducing the processing cost of data transfer in units of group items when executing a Java source program converted from a COBOL source program.

JP 2016-1115070 A

  By the way, in the COBOL language specification, when the execution unit is a set of a program (main program) that is first activated at the time of execution and a subprogram called by a CALL statement, each subprogram is called first in the execution unit. At that time, initialization processing of the subprogram is performed. In the initialization process, data items defined in WORKING-STORAGE SECTION (working place section) are initialized. That is, the data item in which the VALUE phrase is specified is initialized with the value of the VALUE phrase.

  When the subprogram is called for the second time or later in the execution unit, the data item defined by the WORKING-STORE SECTION is not initialized, and the previous state is taken over. However, even at the second and subsequent calls in the execution unit, if the INITIAL phrase is specified in the header part of the subprogram, or if the CANCEL statement specifying the subprogram is being executed, WORKING -The data item defined by the STORAGE SECTION is initialized.

  When executing a Java source program converted from a COBOL source program, it is required to reproduce the language specification of COBOL.

  The present invention has been made in view of such circumstances, and an object of the present invention is to reproduce COBOL language specifications related to subprogram calls in a system that executes a Java source program converted from a COBOL source program.

  A program conversion system according to one aspect of the present invention includes a data definition reading unit that sequentially reads data definitions in a data portion of a COBOL source program, and a source for generating an instance of a class for realizing the data definition in a Java source program A data definition code output unit for outputting a code and a first source for calling a method for initializing a data item to an initial value in a class when the data definition includes a data item for which an initial value is set An initialization method output unit that outputs a code, and an initialization attribute output unit that outputs a second source code of a method for outputting information indicating whether or not the COBOL source program has an initialization attribute.

  In addition, a conversion program execution system according to one aspect of the present invention includes an instance cache unit that holds a cache of an instance of a class of a Java source program corresponding to a subprogram called by a CALL statement in a COBOL source program, and a conversion from the CALL statement When the generated first instruction is executed, if an instance of the class of the Java source program corresponding to the subprogram does not exist in the cache, the instance is newly generated. If the instance exists in the cache, the second is generated. If the COBOL source program has an initialization attribute based on the execution result of the source code, the data item is initialized by executing the first source code, and then the instance in the cache is Reuse and initialize genus If no comprises, and an instance manager to reuse the instances in the cache without initializing the data item.

  An information processing system according to an aspect of the present invention generates a data definition reading unit that sequentially reads data definitions in a data portion of a COBOL source program, and an instance of a class for realizing the data definition in a Java source program. A data definition code output section for outputting the source code of the first and a first for calling a method for initializing the data item to the initial value in the class when the data definition includes a data item for which the initial value is set An initialization method output unit for outputting a source code of the COBOL, an initialization attribute output unit for outputting a second source code of a method for outputting information indicating whether or not the COBOL source program has an initialization attribute, and COBOL A subroutine called by a CALL statement in the source program When the instance cache unit that holds the cache of the instance of the class of the Java source program corresponding to Gram and the first instruction converted from the CALL statement are executed, the instance of the class of the Java source program corresponding to the subprogram is obtained. If the COBOL source program has an initialization attribute based on the execution result of the second source code, the instance is newly generated when the COBOL source program does not exist in the cache. After initializing the data item by executing the source code, the instance in the cache is reused, and if there is no initialization attribute, the data item is not initialized and the cached item is not initialized. An instance management unit for reusing the instance.

  According to another aspect of the present invention, there is provided a program conversion method in which a computer sequentially reads data definitions in a data portion of a COBOL source program and generates an instance of a class for realizing the data definition in a Java source program. When the code is output and the data definition includes a data item having an initial value set, the first source code for calling a method for initializing the data item to the initial value in the class is output, and COBOL A second source code of a method for outputting information indicating whether the source program has an initialization attribute is output.

  According to another aspect of the present invention, there is provided a conversion program execution method comprising: a Java source program class corresponding to a subprogram called by a CALL statement in a COBOL source program by a computer executing the Java source program output by the program conversion method; When the first instruction converted from the CALL statement is executed and the instance of the Java source program class corresponding to the subprogram does not exist in the cache, the instance is newly added. If the COBOL source program has an initialization attribute based on the execution result of the second source code if it is generated and exists in the cache, the data item is initialized by executing the first source code if it has the initialization attribute After doing Reusing the instances in the cache, if no initialization attribute reuses the instance in the cache without initializing the data item.

  Also, an information processing method according to one aspect of the present invention sequentially reads data definitions in the data part of a COBOL source program, and outputs source code for generating an instance of a class for realizing the data definition in a Java source program. If the data definition includes a data item for which an initial value is set, the first source code for calling a method for initializing the data item to the initial value in the class is output, and the COBOL source program A second source code of a method for outputting information indicating whether or not it has an initialization attribute is output, and an instance cache of a Java source program class corresponding to a subprogram called by a CALL statement in a COBOL source program is stored. Hold and CALL statement When the converted first instruction is executed, if an instance of the class of the Java source program corresponding to the subprogram does not exist in the cache, the instance is newly generated. If the instance exists in the cache, If the COBOL source program has an initialization attribute based on the execution result of the second source code, the data item is initialized by executing the first source code, and then the data item in the cache is If the instance is reused and does not have the initialization attribute, the instance in the cache is reused without initializing the data item.

  In the present invention, the “part” does not simply mean a physical means, but includes a case where the function of the “part” is realized by software. Also, even if the functions of one “unit” or device are realized by two or more physical means or devices, the functions of two or more “units” or devices are realized by one physical means or device. May be.

  According to the present invention, in a system that executes a Java source program converted from a COBOL source program, it is possible to reproduce the COBOL language specifications related to subprogram calls.

It is a figure which shows the outline of the whole system in which program conversion is performed. It is a block diagram which shows an example of the function with which the program conversion system 100 is provided. It is a block diagram which shows an example of the function with which the conversion program execution system 120 is provided. It is a figure which shows an example of the conversion rule of the data type in the program conversion system. FIG. 5 is a diagram illustrating an example in which a COBOL data definition is converted based on the conversion rule shown in FIG. 4. 10 is a flowchart illustrating an example of a conversion process of a COBOL data definition. It is a figure which shows an example of the code output in a conversion process. It is a figure which shows an example of the conversion from a COBOL source program to a Java source program. It is a figure which shows an example of the conversion from a COBOL source program to a Java source program. It is a figure which shows an example of the call of the subprogram (module) in COBOL. It is a figure which shows an example of conversion to the Java source program of the COBOL source program containing a CALL sentence. It is a figure which shows an example of the mechanism for performing the Java source program which converted the COBOL source program which calls a subprogram. It is a flowchart which shows an example of the process which reuses the instance corresponding to a subprogram.

  Hereinafter, an embodiment of the present invention will be described with reference to the drawings. FIG. 1 is a diagram showing an outline of the entire system in which program conversion is performed. In this system, the program conversion system 100 converts a program that runs on the host computer 110 into a program that runs on the conversion program execution system 120. Specifically, a COBOL program 130 is running on the host computer 110. The program conversion system 100 converts a COBOL source program 140, which is a source code of the COBOL program 130, into a Java source program 150. The Java source program 150 is compiled into Java byte code 160. The Java byte code 160 is executed by the conversion program execution system 120.

  FIG. 2 is a block diagram illustrating an example of functions provided in the program conversion system 100. The program conversion system 100 includes a conversion rule storage unit 200, a program conversion unit 210, a COBOL source program storage unit 220, and a Java source program storage unit 230. The program conversion unit 210 includes a data definition reading unit 211, an item definition code output unit 212, an initialization method output unit 213, and an initialization attribute output unit 214. The item definition code output unit 212 includes a group item definition code output unit 215, a first basic item definition code output unit 216, and a second basic item definition code output unit 217. The program conversion system 100 is configured using, for example, one or a plurality of computers. Each unit constituting the program conversion system 100 is realized, for example, by using a storage area such as a memory or a hard disk, or by a processor executing a program stored in the storage area.

  The conversion rule storage unit 200 stores a conversion rule for converting a COBOL source program into a Java source program.

  The program conversion unit 210 converts the COBOL source program into a Java source program based on the conversion rule.

  The data definition reading unit 211 sequentially reads the data definitions in the WORKING-STORAGE SECTION for conversion of the WORKING-STORAGE SECTION (working place section) in the DATA DIVISION (data unit) of the COBOL source program.

  The data definition code output unit 212 outputs a source code for realizing the data definition read by the data definition reading unit 212 in the Java source program.

  When the data definition in the COBOL source program is a definition of a group item, the group item definition code output unit 215 outputs a source code that generates an instance of a class (CGrp) for realizing the group item in the Java source program. .

  When the data definition in the COBOL source program is the definition of the basic item and the level is the highest level (for example, “01”), the first basic item definition code output unit 216 displays the basic item in the Java source program. A source code for generating an instance of a class (Java wrapper class) to be realized is output.

  When the data definition in the COBOL source program is the definition of the basic item and the level is not the highest level, the second basic item definition code output unit 217 sets the basic item as a class (CGrp) for realizing the group item. ) Is output as a member variable.

  Note that a method (resetForReuse) that initializes data items to initial values is implemented in a class (CGrp) for realizing group items and a class (Java wrapper class) for realizing basic items.

  Details of the data definition reading unit 211 and the data definition code output unit 212 will be described later using a specific example.

  When there is a data item for which an initial value is set in the data definition of the COBOL source program, the initialization method output unit 213 initializes the data item to the initial value in the class that realizes the data item (resetForReuse). ) For calling the method (resetForReuse).

  The initialization attribute output unit 214 determines whether or not the COBOL source program has an initialization attribute. Specifically, the initialization attribute output unit 214 determines whether or not the INITIAL phrase is specified in the heading part of the COBOL source program. In the COBOL language specification, a program having an initialization attribute (in which an INITIAL clause is specified) initializes variables each time it is called. The initialization attribute output unit 214 outputs information for making it possible to determine whether or not there is an initialization attribute in the Java source program converted from the COBOL source program. Specifically, the initialization attribute output unit 214 outputs a source code of a method (isInitial) for outputting information indicating the presence / absence of the initialization attribute.

  The COBOL source program storage unit 220 stores a COBOL source program before conversion.

  The Java source program storage unit 230 stores the Java source program after conversion.

  FIG. 3 is a block diagram illustrating an example of functions provided in the conversion program execution system 120. The conversion program execution system 120 includes a Java VM execution unit 300, a Java bytecode storage unit 310, and a program execution unit 320. The program execution unit 320 includes an instance cache unit 321 and an instance management unit 322. The conversion program execution system 120 is configured using, for example, one or a plurality of computers. Each unit constituting the conversion program execution system 120 is realized, for example, by using a storage area such as a memory or a hard disk, or by executing a program stored in the storage area.

  The JavaVM execution unit 300 executes JavaVM, which is a platform for executing Java bytecode.

  The Java byte code storage unit 310 stores a Java byte code obtained by compiling the converted Java source program.

  The program execution unit 320 executes Java bytecode. The program execution unit 320 includes various libraries (class library or the like) for executing Java bytecode.

  The instance cache unit 321 holds a Java instance cache corresponding to a subprogram called by a CALL statement in the COBOL source program.

  When an instruction converted from a CALL statement that calls a subprogram is executed, if the instance corresponding to the subprogram does not exist in the cache, the instance management unit 322 newly creates the instance and exists in the cache If so, reuse the instance in the cache.

  Details of the instance cache unit 321 and the instance management unit 322 will be described later using a specific example.

  FIG. 4 is a diagram illustrating an example of a data type conversion rule in the program conversion system 100. In FIG. 4, the left column shows the COBOL data type, and the right column shows the Java wrapper class for realizing the same function as the COBOL data type. For example, an unsigned integer of 1 to 9 digits (PIC 9 (1) to PIC 9 (9)) is converted into a Java wrapper class called CInt.

  FIG. 5 is a diagram showing an example of converting the COBOL data definition based on the conversion rule shown in FIG. For example, in COBOL, “01 NUM01 PIC S9 (003) COMP-3 VALUE 060.” defines a variable “NUM01” as a three-digit integer (initial value “60”) in a signed pack format. This definition is converted to Java as “public CInt NUM01 = new CInt (3, S, COMP3) .VALUE (60);”. Here, the arguments (3, S, COMP3) of CInt represent the number of digits, a signed code, and a pack format in this order. The CINT method VALUE (60) sets the initial value “60” to the variable NUM01.

  FIG. 6 is a flowchart illustrating an example of the conversion processing of the COBOL data definition. FIG. 7 is a diagram illustrating an example of a code output in the conversion process. 8A and 8B are diagrams showing an example of conversion from a COBOL source program to a Java source program. The process of FIG. 6 will be described with reference to FIGS. 7, 8A, and 8B.

  First, the data definition reading unit 211 reads one line of the data definition in the data part of the COBOL source program (S601).

  If the data definition is not complete (S602: N), the group item definition code output unit 215 checks whether the data definition is a group item definition (S603). If the definition is a group item definition (S603: Y), the group item definition code output unit 215 outputs the source code defining the group item as a class inheriting the wrapper class CGrp for the group item (S604). For example, FIG. 7A shows an example of source code for defining the group item GRP1. Specifically, CGRP1 is defined as a class that inherits the class CGRP, and GRP1 is defined as an object of the CGRP1.

  If the definition is not a group item definition (that is, a basic item) (S603: N), the first basic item definition code output unit 216 checks whether the data definition is level 01 (S605). If the level is 01 (S605: Y), the source code defining the basic item is output as an object of the wrapper class for the basic item (S606). For example, FIG. 7B shows an example of source code defining the basic item IDX1. Specifically, IDX1 is defined as an object of class CInt.

  If it is a basic item (S603: N) and is not level 01 (S605: N), the second basic item definition code output unit 217 sets the basic item as a member of the class of the group item to which the basic item belongs. Source code defined as a variable is output (S607). For example, FIG. 7C shows an example of source code that defines the basic item GRP1_IDX1 belonging to the group item GRP1. Here, the source code shown in FIG. 7C is added as a member variable of the class CGRP1 to the source code shown in FIG.

  When the data definition is completed (S602: Y), the initialization method output unit 213 receives data in a class that realizes the data item when an initial value is set in the data definition of the COBOL source program. A source code of a method for calling a method for initializing an item to an initial value is output (S608).

  Further, the initialization attribute output unit 214 outputs a source code of a method for outputting information indicating the presence / absence of the initialization attribute in the COBOL source program (S609).

  8A and 8B show an example of conversion by the process shown in FIG. Here, FIG. 8A shows an example of the conversion source COBOL source program, and FIG. 8B shows an example of the converted Java source program. As shown in FIG. 8B, the group item GRP1 is defined as an object of the class CGRP1 that inherits the class CGRP. The basic items GRP1_IDX1, GRP1_IDX2, and GRP1_IDS1 belonging to the group item GRP1 are defined as member variables of the class CGRP1. The basic item IDX1 that does not belong to the group item is defined as an object of class CInt.

  In the COBOL source program shown in FIG. 8A, an initial value “00” is set in the basic item GPR1_IDS1 belonging to the group item GRP1. The basic item IDS1 that does not belong to the group item is set to an initial value “99”. Correspondingly, as shown in FIG. 8B, a method (GRP1.resetForReuse ()) for initializing data items in the class that realizes the group item GRP1 and data in the class that realizes the basic item IDS1 Source code of a method (resetForReuse ()) for calling a method (IDS1.resetForReuse ()) for initializing items to initial values is output.

  As shown in FIG. 8B, a source code of a method (isInitial) for outputting information indicating the presence / absence of an initialization attribute is output to the Java source program. In the COBOL source program shown in FIG. 8A, the INITIAL phrase is specified in the header section and has an initialization attribute. Therefore, in the example shown in FIG. 8B, the method isInitial has a specification that returns a value “true” as information indicating that it has an initialization attribute. In the case of a COBOL source program having no initialization attribute, a different value (false) may be returned.

  Next, a method for reducing the processing load when the subprogram is executed in the conversion program execution system 120 will be described.

  FIG. 9 is a diagram illustrating an example of calling a subprogram in COBOL. As shown in FIG. 9, in a main program (for example, program MAIN01), a subprogram (for example, subprogram SUB01) can be called by a CALL statement.

  FIG. 10 is a diagram illustrating an example of conversion of a COBOL source program including a CALL sentence into a Java source program. As shown in FIG. 8B, the subprogram is realized as an object of class CblSub.

  FIG. 11 is a diagram showing an example of a mechanism for executing a Java source program obtained by converting a COBOL source program that calls a subprogram. The main program (for example, the program MAIN01) is realized as an instance of the class CblBase. A subprogram (for example, subprogram SUB01) can be called by executing method create of class Factory with a subprogram name (for example, “SUB01”) as an argument.

  The subprogram is realized as an instance of the class CblSub. When the instance of the subprogram is generated, it is cached in the instance cache unit 321. When the subprogram is called by the method create, the instance management unit 322 searches the list of instances held in the cache by the subprogram name. When an instance corresponding to the subprogram to be called exists in the cache, the instance management unit 322 reuses the instance after initializing the value of the member variable as necessary. The initialization of member variables will be described later. Further, when the instance corresponding to the subprogram to be called does not exist in the cache, the instance management unit 322 newly generates the instance and registers it in the cache.

  FIG. 12 is a flowchart illustrating an example of processing for reusing an instance corresponding to a subprogram. When a method (for example, “Factory.create (“ SUB01 ”)”) corresponding to the subprogram call is executed, the instance management unit 322 displays a list of caches of instances corresponding to the subprogram with the specified class name. (For example, “SUB01”) (S1201).

  If not present in the list (S1202: N), the instance management unit 322 generates an instance with the specified class name (for example, “SUB01”) (S1203). At the time of instance generation, an initial value setting process corresponding to the VALUE phrase of the COBOL source program is also performed. Then, the instance management unit 322 adds the generated instance to the cache list (S1204).

  If it exists in the list (S1202: Y), the instance management unit 322 checks whether the called subprogram has an initialization attribute or whether a CANCEL statement has been executed in advance (S1205). . Note that the presence or absence of the initialization attribute can be confirmed by executing the method isInitial. Further, the instance cache unit 321 can store information indicating whether a CANCEL statement has been executed in advance for each cached instance. The instance management unit 322 can check whether the CANCEL statement has been executed in advance by referring to the information.

  If there is no initialization attribute and the CANCEL statement has not been executed in advance (S1205: N), the instance management unit 322 reuses the instance without performing initialization processing. On the other hand, if there is an initialization attribute or the CANCEL statement has been executed in advance (S1205: Y), the instance management unit 322 executes the method resetForReuse () for the instance existing in the cache, and The member variable data is initialized to an initial value corresponding to the VALUE clause of the COBOL source program, and the instance is reused (S1206).

  As described above, in the conversion program execution system 120, the instances corresponding to the subprograms are managed in the cache and reused. As a result, in the system that executes the Java source program converted from the COBOL source program, it is possible to reproduce the COBOL language specifications related to the subprogram call and to reduce the load when the subprogram is called.

  In the above, the program conversion system 100 and the conversion program execution system 120 which are one Embodiment of this invention were demonstrated.

  In the program conversion system 100, when the data definition includes a data item for which an initial value is set, a first source code for calling a method for initializing the data item to the initial value is output. Further, the program conversion system 100 outputs a second source code of a method for outputting information indicating whether the COBOL source program has an initialization attribute. As a result, it is possible to reproduce the language specification related to the initialization of the subprogram in COBOL.

  Further, the conversion program execution system 120 holds a cache of instances of Java source program classes corresponding to subprograms called by CALL statements in the COBOL source program. Then, in the conversion program execution system 120, when the first instruction converted from the CALL statement is executed, if an instance of the class of the Java source program corresponding to the subprogram does not exist in the cache, the instance is newly added. Generated. On the other hand, if it exists in the cache, based on the execution result of the second source code, if the COBOL source program has the initialization attribute, the data item is initialized by executing the first source code. After that, the instance in the cache is reused. If the instance does not have the initialization attribute, the instance is reused without initializing the data item. As a result, it is possible to reproduce the language specification related to the initialization of the subprogram in COBOL and reduce the load at the time of calling the program.

  Further, the conversion program execution system 120 stores information indicating whether a CANCEL statement has been called in advance for each instance. In the conversion program execution system 120, if an instance of the class of the Java source program corresponding to the subprogram exists in the cache, the COBOL source program has the initialization attribute, or the CANCEL statement is called in advance for the instance. If so, the data item is initialized. As a result, it is possible to reproduce the language specification related to the initialization of the subprogram in COBOL and reduce the load at the time of calling the program.

  Note that this embodiment is intended to facilitate understanding of the present invention and is not intended to limit the present invention. The present invention can be changed / improved without departing from the spirit thereof, and the present invention includes equivalents thereof.

DESCRIPTION OF SYMBOLS 100 Program conversion system 110 Host computer 120 Conversion program execution system 130 COBOL program 140 COBOL source program 150 Java source program 160 Java bytecode 200 Conversion rule memory | storage part 210 Program conversion part 211 Data definition reading part 212 Data definition code output part 213 Initialization Method output unit 214 Initialization attribute output unit 215 Group item definition code output unit 216 First basic item definition code output unit 217 Second basic item definition code output unit 220 COBOL source program storage unit 230 Java source program storage unit 300 JavaVM Execution unit 310 Java bytecode storage unit 320 Program execution unit 321 Instance cache unit 322 IN Chest of drawers management unit

Claims (7)

A data definition reading section for sequentially reading data definitions in the data section of the COBOL source program;
A data definition code output unit for outputting a source code for generating an instance of a class for realizing the data definition in a Java source program;
When the data definition includes a data item for which an initial value is set, an initialization method for outputting first source code for calling a method for initializing the data item to the initial value in the class An output section;
An initialization attribute output unit for outputting a second source code of a method for outputting information indicating whether the COBOL source program has an initialization attribute;
A program conversion system comprising: A conversion program execution system for executing a Java source program output from the program conversion system according to claim 1,
An instance cache unit that holds an instance cache of a Java source program class corresponding to a subprogram called by a CALL statement in the COBOL source program;
When the first instruction converted from the CALL statement is executed,
If an instance of the class of the Java source program corresponding to the subprogram does not exist in the cache, a new instance is generated,
If the COBOL source program has an initialization attribute based on the execution result of the second source code if it exists in the cache, the first source code is executed by executing the first source code. An instance management unit that reuses the instance in the cache after initialization and reuses the instance in the cache without initializing the data item if it does not have an initialization attribute When,
A conversion program execution system comprising: A conversion program execution system according to claim 2,
The instance cache unit stores, for each instance, information indicating whether a CANCEL statement has been called in advance;
When the instance of the class of the Java source program corresponding to the subprogram exists in the cache, the instance management unit has a CANCEL statement in advance when the COBOL source program has an initialization attribute, or for the instance. The data item is initialized when called by
Conversion program execution system. A data definition reading section for sequentially reading data definitions in the data section of the COBOL source program;
A data definition code output unit for outputting a source code for generating an instance of a class for realizing the data definition in a Java source program;
When the data definition includes a data item for which an initial value is set, an initialization method for outputting first source code for calling a method for initializing the data item to the initial value in the class An output section;
An initialization attribute output unit for outputting a second source code of a method for outputting information indicating whether the COBOL source program has an initialization attribute;
An instance cache unit that holds an instance cache of a Java source program class corresponding to a subprogram called by a CALL statement in the COBOL source program;
When the first instruction converted from the CALL statement is executed,
If an instance of the class of the Java source program corresponding to the subprogram does not exist in the cache, a new instance is generated,
If the COBOL source program has an initialization attribute based on the execution result of the second source code if it exists in the cache, the first source code is executed by executing the first source code. An instance management unit that reuses the instance in the cache after initialization and reuses the instance in the cache without initializing the data item if it does not have an initialization attribute When,
An information processing system comprising: Computer
Read the data definitions in the data part of the COBOL source program sequentially,
Outputting a source code for generating an instance of a class for realizing the data definition in a Java source program;
When the data definition includes a data item having an initial value set, the first definition code for calling a method for initializing the data item to the initial value in the class is output.
Outputting a second source code of a method for outputting information indicating whether the COBOL source program has an initialization attribute;
Program conversion method. A computer that executes the Java source program output by the program conversion method according to claim 5,
In the COBOL source program, a cache of an instance of a class of a Java source program corresponding to a subprogram called by a CALL statement is held.
When the first instruction converted from the CALL statement is executed,
If an instance of the class of the Java source program corresponding to the subprogram does not exist in the cache, a new instance is generated,
If the COBOL source program has an initialization attribute based on the execution result of the second source code if it exists in the cache, the first source code is executed by executing the first source code. After initializing, the instance in the cache is reused, and when there is no initialization attribute, the instance in the cache is reused without initializing the data item .
Conversion program execution method. Computer
Read the data definitions in the data part of the COBOL source program sequentially,
Outputting a source code for generating an instance of a class for realizing the data definition in a Java source program;
When the data definition includes a data item having an initial value set, the first definition code for calling a method for initializing the data item to the initial value in the class is output.
Outputting a second source code of a method for outputting information indicating whether the COBOL source program has an initialization attribute;
In the COBOL source program, a cache of an instance of a class of a Java source program corresponding to a subprogram called by a CALL statement is held.
When the first instruction converted from the CALL statement is executed,
If an instance of the class of the Java source program corresponding to the subprogram does not exist in the cache, a new instance is generated,
If the COBOL source program has an initialization attribute based on the execution result of the second source code if it exists in the cache, the first source code is executed by executing the first source code. After initializing, the instance in the cache is reused, and when there is no initialization attribute, the instance in the cache is reused without initializing the data item .
Information processing method.