WO2013179486A1 - Program conversion method, program conversion system, and program - Google Patents

Abstract

Provided is a technology for accurately and uniformly identifying, in a manual correction process of a non-conversion portion, a non-conversion portion for which correction is necessary. The present invention relates to program conversion which converts a first program which operates upon a first platform to a second program which operates upon a second platform which has a different form. Using a conversion tool, a value of a variable of a non-conversion portion when converting the first program, a non-conversion portion range, and a non-conversion portion conversion source, are acquired. A variable initial value when the processing of the non-conversion portion commences, and a variable terminal value when the processing is terminated, are acquired from the acquired variable values and information of the non-conversion portion range. From the acquired initial value and terminal value of the variable, input information and comparison information to the second program are created. Furthermore, the input information is inputted into a conversion source upon the second platform, an output result which is obtained by carrying out a test using this input information is compared with the created comparison information, and the comparison result is outputted.

Description

Program conversion method, program conversion system, and program

The present invention relates to a program conversion method, a program conversion system, and a program, for example, a program conversion process for converting a program operating on a predetermined platform into a program operating on another platform having a different format.

COBOL (Common Business Oriented Language) is a programming language developed for business processing, but has been used in core systems since the mainframe era. Therefore, existing assets are often included in program sources using COBOL. For this reason, migration processing is often accompanied by system modification (change of flat form), and there is a case where a program source is migrated from a mainframe to an open system.

∙ When migrating program sources, use the source conversion tool to convert existing program sources into program sources for new platforms. Then, the conversion source is manually corrected again to be equivalent to the logic of the existing source. For such program source conversion processing, for example, methods described in Patent Documents 1 to 3 have been proposed.

Patent Document 1 discloses that when converting a program source, it is determined whether to convert the syntax according to the number of times the syntax appears. According to this, syntax conversion is performed when the number of appearances is large, and conversion is not performed when the number of appearances is small.

In Patent Document 2, when a program is converted to be transferred to another environment, the program source to be converted is analyzed, and the conversion is performed by selecting an appropriate tool and law for conversion using the result. It is disclosed.

Patent Document 3 creates a DB (Data Base) and an intermediate file for each token from a C language source, deletes / changes the target character string on the DB, and stores information on the database and the intermediate file as a C language file. Are generated, and then the target program is generated.

Japanese Patent Application Laid-Open No. 2005-157827 JP 2008-305386 A JP 2002-041286 A

The program source converted by the conversion tool is composed of a converted part generated by converting the existing source and a non-converted part that follows the existing source as it is. The non-converted portion is classified into two types: those that operate without any problem even if they are not corrected, and those that must be corrected manually.

Therefore, when the methods of Patent Documents 1 to 3 are used, it is possible to convert the program source. However, the user needs to perform manual work step by step to determine whether the converted program source has the same processing content as the existing source. If it is not the same, it must be corrected. That is, the identity of the process before and after conversion is ensured for the conversion part. For this reason, the non-converted part is specified from the converted program source (the entire source including both the converted part and the non-converted part). Furthermore, the user must actually run the program and manually check the identity of the non-converted part before and after the processing by the conversion tool and the necessity of correction. If the user needs correction, the user must correct the corresponding part and perform a test to confirm the operation. As described above, the process of confirming the identity of the processing contents in the non-converted portion is very complicated and requires skill based on experience. For this reason, there has been a need to perform work efficiently even if the user (person in charge of migration) has little experience.

The present invention has been made in view of such a situation, and provides a technique for accurately and uniformly identifying a non-converted portion that needs to be corrected in a manual correction processing of a non-converted portion. It is.

In order to solve the above problems, one aspect of the present invention relates to program conversion for converting a first program that operates on a first platform into a second program that operates on a second platform having a different format. Using the conversion tool, the value of the variable of the non-conversion part, the range of the non-conversion part and the conversion source of the non-conversion part are obtained at the time of the conversion of the first program. From the information, the initial value of the variable at the start of processing of the non-conversion part and the end value of the variable at the end of processing are acquired, and input information and comparison information to the second program are obtained from the initial value and end value of the acquired variable. In addition, the input information is input to the conversion source on the second platform, the output result obtained by performing the test using this input information, and the created comparison information are It is compare, the comparison result is output.

According to the present invention, it is possible to accurately and uniformly identify the non-conversion portion that needs to be corrected in the manual correction processing of the non-conversion portion.

Further features related to the present invention will become apparent from the description of the present specification and the accompanying drawings. The embodiments of the present invention can be achieved and realized by elements and combinations of various elements and the following detailed description and appended claims.

It should be understood that the descriptions in this specification are merely exemplary, and are not intended to limit the scope of the claims or the application of the present invention in any way.

It is a figure for demonstrating the outline | summary of the necessity determination process of a non-conversion part by embodiment of this invention. 1 is a diagram showing a schematic configuration of an information (program source) migration system 1 according to an embodiment of the present invention. 2 is a diagram showing a schematic configuration of an existing (migration source) computer system 100. FIG. 2 is a diagram showing a schematic configuration of a migration support computer system 200. FIG. 2 is a diagram showing a schematic configuration of a new (migration destination) computer system 300. FIG. 3 is a diagram illustrating a functional configuration of a program conversion unit 2211. FIG. FIG. 11 is a diagram illustrating a functional configuration of a non-conversion partial test / result determination unit 3213. It is a flowchart for demonstrating the whole non-conversion part necessity determination process (corresponding to FIG. 1) in a conversion source. It is a figure which shows the example of the existing source produced by COBOL. It is a flowchart for demonstrating the detail of the program conversion process of S802 (FIG. 8). It is the figure which expressed the program conversion process as the flow of the process on a functional block. It is a figure which shows the structure of the conversion source produced | generated by a program conversion process. It is a figure which shows the example of a conversion source. It is a figure which shows the structure of the non-conversion partial information acquired after a program conversion process. It is a figure which shows the example of non-conversion partial information. It is a flowchart for demonstrating the detail of the debugger script production | generation process of S805 (FIG. 8). It is a figure which shows the structure of the debugger script produced | generated by a debugger script production | generation process. It is a figure which shows the example of a debugger script. It is a figure which shows the outline | summary of a trace log output process. It is a figure which shows the structure of the trace log produced | generated by performing a debugger process according to a debugger script. It is a figure which shows the specific example of a trace log. It is a flowchart for demonstrating the detail of the process which produces | generates the test data and result data for non-conversion parts in S809 (refer FIG. 8). It is a figure which shows the structure of the test and result data for non-conversion parts. FIG. 24 is a diagram illustrating a specific example of non-conversion portion test / result data. It is a functional block diagram for demonstrating the outline | summary of a non-conversion partial test and a result determination process. It is a flowchart for demonstrating the detail of a non-conversion partial test and a result determination process. It is a figure for demonstrating the concept of the process which produces | generates the partial source 332 from the conversion source 202. FIG. It is a figure for demonstrating the concept of the unit test of a partial source, and a correction necessity determination process. It is a figure which shows the example of the output result at the time of executing two partial sources independently. It is a figure which shows the structure of the conversion source (new source) after the necessity determination of correction. It is a figure which shows the specific example of a new source. It is a figure which shows GUI (displayed on the display screen of the output device 350 of a new computer system 300) used when a user corrects a conversion source (non-conversion part).

Hereinafter, an embodiment of the present invention will be described with reference to the accompanying drawings. In the accompanying drawings, functionally identical elements may be denoted by the same numbers. The attached drawings show specific embodiments and implementation examples based on the principle of the present invention, but these are for understanding the present invention and are not intended to limit the present invention. Not used.

This embodiment has been described in sufficient detail for those skilled in the art to practice the present invention, but other implementations and configurations are possible without departing from the scope and spirit of the technical idea of the present invention. It is necessary to understand that the configuration and structure can be changed and various elements can be replaced. Therefore, the following description should not be interpreted as being limited to this.

Furthermore, as will be described later, the embodiment of the present invention may be implemented by software running on a general-purpose computer, or may be implemented by dedicated hardware or a combination of software and hardware.

Hereinafter, each processing unit (for example, a program conversion unit and a debugger script generation unit) is described as a subject (operation subject), and each processing in the embodiment of the present invention will be described. In each processing unit, a “program” is a processor. Since the processing determined by being executed by the processing is performed using the memory and the communication port (communication control device), the description may be made with the processor as the subject. Further, the processing may be read with “program (program conversion program, debugger script generation program, etc.)” or “function (program conversion function, debugger script generation function, etc.)” as the subject. Some or all of the programs and functions may be realized by dedicated hardware, or may be modularized. Various programs may be installed in each computer by a program distribution server or a storage medium.

<Process overview>
FIG. 1 is a diagram for explaining an outline of a non-conversion portion correction necessity determination process according to an embodiment of the present invention. An information (program source) migration system (program conversion system) 1 according to an embodiment of the present invention includes an existing (migration source) computer system 100, a migration support computer system 200, and a new (migration destination) computer system 300. Composed. However, the migration support computer system 200 and the new computer system 300 may be configured as one computer. That is, the new computer system 300 may be configured to include the function of the migration support computer system 200.

First, an existing source (see FIG. 9), which is a program source that operates in conformity with the existing computer system 100, is provided from the existing computer system 100 to the migration support computer system 200 (F101).

The migration support computer system 200 receives an existing source from the existing computer system 100, executes a program conversion process using a conversion tool program that defines conversion rules (F201), and includes a conversion part and a non-conversion part. (Refer to FIGS. 12 and 13) is generated and provided to the new computer system 300 (F202). Further, non-conversion part information (see FIGS. 14 and 15), which is information about the rows and variables of the non-conversion part, is stored in a memory (storage device) (not shown) (F203).

Then, the migration support computer system 200 reads the non-conversion partial information from the memory, and generates a debugger script (see FIGS. 15 and 16) that defines the operation contents of the debugger based on the information (F204). (F205).

The migration support computer system 200 delivers the generated debugger script to the existing computer system 100. The existing computer system 100 executes debugger processing according to the received debugger script (F206), and transfers the trace log as a result to the migration support computer system 200.

The migration support computer system 200 stores the received trace log (see FIGS. 20 and 21) in the memory (storage device) (F206).

Subsequently, the migration support computer system 200 reads the trace log from the memory, refers to it, generates test data and result data for the non-conversion portion (extracts from the trace log) (F207), and stores the memory (storage device) (F208).

The new computer system 300 receives the conversion source, the non-conversion portion test data, and the result data from the migration support computer system 200, executes the test for the non-conversion portion, and executes the result determination process (F301). In the non-conversion partial test / result determination process, the test data obtained from the trace log is input as the input value for the non-conversion part of the conversion source, and the result data obtained from the non-conversion part of the conversion source At the same time, the result data obtained from the trace log is compared. If the two result data are the same, it is determined that correction is not necessary, and if the result data is not the same, it is determined that correction is necessary. The partial source (non-conversion part) requiring correction is corrected by the user. Then, the conversion unnecessary part and the correction unnecessary part of the converted part and the non-converted part are collected and provided as a new source (F302).

<System configuration>
FIG. 2 is a diagram showing a schematic configuration of the information (program source) migration system 1 according to the embodiment of the present invention. As described above, the system 1 includes the existing (migration source) computer system 100, the migration support computer system 200, and the new (migration destination) computer system 300.

The existing (migration source) computer system 100 includes at least an existing source storage unit 101 for storing an existing source, a debugger processing unit 102 for debugging an existing source based on a debugger script generated by the migration support computer system 200, have.

The migration support computer system 200 converts an existing source using a conversion tool, generates a conversion source having a conversion part and a non-conversion part, and a conversion source storage part 202 stores the generated conversion source. A non-conversion part information storage unit 203 for storing non-conversion part information (including lines and variables of the non-conversion part) obtained by the program conversion unit 201, and defining debugger processing contents based on the non-conversion part information A debugger script generation unit 204 that generates a debugger script to be executed, a debugger script storage unit 205 that stores the generated debugger script, a trace log storage unit 206 that stores a trace log obtained as a result of debugger processing according to the debugger script, and a trace Test data and non-conversion test data from log The the non-converted part for the test result data generating unit 207 for extracting a non-converted part for the test result data storage unit 208 for storing the extracted unconverted portions for test data and result data, and a. Here, the storage unit for each information is shown as a separate configuration, but a single memory (storage device) may store each information.

The new (migration destination) computer system 300 receives from the migration support computer system 200 the new source storage unit 302 that stores the new source generated by combining the conversion part, the non-conversion part and the correction part. A non-conversion part test / result determination unit 301 that determines whether or not the non-conversion part needs to be corrected using the conversion source and the non-conversion part test / result data.

<Hardware configuration of each computer system>
3 to 5 are diagrams showing a schematic hardware configuration of each of the computer systems 100, 200, and 300 constituting the migration system according to the embodiment of the present invention. 3 relates to the schematic configuration of the existing (migration source) computer system 100, FIG. 4 relates to the schematic configuration of the migration support computer system 200, and FIG. 5 relates to the schematic configuration of the new (migration destination) computer system 300.

Each of the computer systems 100, 200, and 300 has a general computer configuration, for example, CPUs (also simply referred to as processors) 110, 210, and 310, main storage devices 120, 220, and 320, and auxiliary storage devices. 130, 230 and 330, input devices 140, 240 and 340 such as a keyboard and a mouse, output devices 150, 250 and 350 such as a display device, a printer and an audio output device, and communication ports 160, 260 and 360. Have. Each computer system has a different software configuration including information and programs to be held.

(I) Existing (migration source) computer system 100 (FIG. 3)
The main storage device 120 holds a debugger (program) 1211 as a development / operation environment 121. The debugger 1211 is read by the CPU 110 and provided as the above-described debugger processing F102 or debugger processing unit 102. The debugger may be provided in the migration support computer system 200. In this case, a trace log described later is generated using the existing source acquired from the existing computer system 100 and the generated debugger script.

The auxiliary storage device 130 stores, for example, an existing program source (existing source) created by COBAL operating on the mainframe.

(Ii) Migration support computer system 200 (FIG. 4)
The main storage device 220 holds a program conversion unit (program) 2211, a debugger script generation unit (program) 2212, and a non-conversion part test / result data generation unit (program) 2213 as the migration support environment 221. ing. Each program is read by the CPU 210. The program conversion unit 2211 provides a program conversion process F201 (FIG. 1) and a program conversion unit 201 (FIG. 2). The debugger script generation unit 2212 provides a debugger script generation process F204 (FIG. 1) and a debugger script generation unit 204 (FIG. 2). The non-conversion unit test / result data generation unit 2213 provides a non-conversion unit test / result data generation process F207 (FIG. 1) and a non-conversion unit test / result data generation unit 207 (FIG. 2).

The auxiliary storage device 230 includes a converted program source (conversion source) 213 obtained by converting the existing source by the program conversion unit 2211 and information on a portion not converted by the program conversion processing by the program conversion unit 2211 ( Generated by non-converted portion information 232 (including non-converted portion lines and variables), a debugger script 233 generated by the debugger script generation unit 2212 based on the non-converted portion information, and a debugger process executed according to the debugger script 233 Trace log 234, test / result data 235 for non-conversion part generated by extracting test data and result data from the trace log 233 by the test / result data generation part 2213 for non-conversion part, and program conversion part 2211 is program change A syntax converter side storage unit 236 that is a rule used in processing, a non-conversion partial line information storage unit 237 that stores line information of a non-conversion part that has not been converted by the program conversion process, and a variable of the non-conversion part And a non-conversion partial variable information storage unit 238 for storing information. When the non-conversion partial line information held by the non-conversion partial line information storage unit 237 and the non-conversion partial variable information held by the non-conversion partial variable information storage unit 238 are combined, the same information as the non-conversion partial information 232 is obtained. Can be generated.

(Iii) New (migration destination) computer system 300
The main storage device 320 includes a compiler (program) 3211 which is a tool for compiling a new source 331 as a development / operation environment 321 and an editor (a tool for correcting a non-conversion portion determined to be corrected). Program) 3212 and the execution result of the non-converted portion (corresponding to the partial source described later) of the conversion source and the result data acquired from the test / result data 235 for the non-converted portion, the correction of the non-converted portion is necessary. A non-conversion partial test / result determination unit (program) 3213 for determining NO. Each program is read by the CPU 310 to realize each function. The non-conversion unit test / result determination unit 3213 provides a non-conversion unit test / result data determination process F301 (FIG. 1) and a non-conversion unit test / result determination unit 301 (FIG. 2).

The auxiliary storage device 330 includes a new source composed of a conversion part of an existing source, a non-conversion part determined to be unnecessary for correction, and a non-conversion part corrected because it is determined that correction is necessary, a definition part, and a non-conversion part. A partial source 332 composed of a conversion part (source). The non-conversion partial test / result determination unit inputs the test data corresponding to each partial source as an input value, obtains the corresponding output value, and compares it with the result data to determine whether the source needs to be corrected Determine.

<Configuration of program converter>
FIG. 6 is a diagram illustrating a functional configuration of the program conversion unit 2211. The program conversion unit 2211 includes a control unit 601, a syntax conversion rule storage unit 236 that holds a syntax conversion rule that defines a conversion rule, and non-conversion partial line information that holds line information of a non-conversion part obtained by program conversion processing. The storage unit 237 and a non-conversion partial variable information storage unit 238 that holds variable information of the conversion part are configured.

The control unit 601 converts the existing source received from the existing computer system 100 into a program source suitable for the migrated platform according to the syntax conversion rule, and generates a conversion source. The conversion source includes a converted part and a non-converted part. The part of the existing source to be converted can be grasped by referring to the syntax conversion rule.

In addition, the control unit 601 separates the converted part and the non-converted part, and converts only the non-converted part information (line information and variable information) into the non-converted partial line information storage unit 237 and the non-converted partial variable information storage unit 238, respectively. To store.

<Configuration of non-conversion partial test / result determination unit>
FIG. 7 is a diagram illustrating a functional configuration of the non-conversion partial test / result determination unit 3213. The non-conversion partial test / result determination unit 3213 includes a control unit 701, a new source 331 including a conversion part and a non-conversion part that does not require correction and a correction, a partial source 332 including a source and a definition part of the non-conversion part, It is constituted by.

The control unit 701 determines whether or not each non-converted part given by the partial source 332 needs to be corrected according to the program 7011 for executing the non-converted partial test / result determination process. Details of this processing will be described later.

<Description of overall processing>
FIG. 8 is a flowchart for explaining the entire process (corresponding to FIG. 1) for determining whether or not a non-conversion part in the conversion source needs to be corrected.

The CPU 210 of the migration support computer system 200 acquires the existing source to be converted from the existing computer system 100 via the communication port 260 (S801).

The CPU 210 executes the program conversion process so that the existing source matches the migration destination platform by the program conversion unit 2211 (according to the composition conversion rule), and generates the conversion source (S802). Details of the conversion source will be described later.

The CPU 210 separates the conversion part and the non-conversion part from the conversion source (or specifies the non-conversion part from the conversion source), the range of the non-conversion part (specified by the start line and the end line), the variable, and the conversion Non-converted partial information including the source is generated (S803). Details of the non-converted partial information will be described later.

The CPU 210 inputs the generated non-converted partial information to the debugger script generation unit (program) (S804), and generates a debugger script (S805). Details of the debugger script will be described later.

The CPU 210 transmits the generated debugger script to the existing computer system 100 via the communication port 260 in accordance with the instruction to start the debugger process input from the input device 240, and the debugger process is executed there (S806).

When the existing computer system 100 performs the debugger (1211) process according to the debugger script, the CPU 210 acquires the trace log from the existing computer system 100 via the communication port 260 (S807). At this time, the trace log may be output (displayed) to the output device 250.

The CPU 210 inputs the acquired trace log to the non-conversion part test / result data generation unit (program) 2213 (S808), and extracts the test data part and the result data part from the trace log, thereby performing the non-conversion part test. Generate result data (S809).

The CPU 210 passes the conversion source, the non-conversion partial test data, and the non-conversion partial result data to the non-conversion partial test / result determination unit 3213 of the new computer system 300 via the input device 240 and the communication port 260 (S810). ).

The CPU 310 of the new computer system 300 generates a determination result by executing the non-converted part test / result determination unit (program) 3213 for one non-converted part (S811).

Then, the CPU 310 determines whether the determination result regarding the non-converted portion is “requires correction” or “no correction required” (S812).

If it is determined that the determination result is “correction required”, the CPU 310 operates the editor 3212 so that the user can recognize that the corresponding non-converted portion is “correction required” on the editor screen. (S813). For example, it may be possible to change the background color or the source font.

When it is determined that the determination result is “no correction required” or after the completion of S813, the CPU 310 determines whether there is a non-converted portion of “correction required” (S814). Let

On the other hand, if there is a non-converted portion “required for correction”, the CPU 310 waits until there is a manual correction input by the user, accepts the corrected input, and converts the corrected non-converted portion into a new non-converted portion. (S815).

Then, the process proceeds to S811, and the processes from S811 to S814 are executed again to determine whether the correction is correct. If it is corrected correctly (when the determination result is “correction unnecessary”), the process ends.

<Existing source example>
FIG. 9 is a diagram illustrating an example of an existing source created by COBOL. The existing source 900 includes a definition unit 901 that defines functions and variables used for processing, and an execution unit 902 that defines specific processing contents. The definition unit 901 is not converted by the program conversion process. The execution unit 902 converts a part of the source by the program conversion process. In FIG. 9, a portion 903 to be converted is shown.

<Details of program conversion process>
FIG. 10 is a flowchart for explaining details of the program conversion processing in S802 (FIG. 8).

The CPU 210 of the migration support computer system 200 inputs the existing source (conversion object) acquired from the existing computer system 100 to the control unit 601 of the program conversion unit 22211 (S1001).

The CPU 210 uses the control unit 601 to compare the code of the first line (k line: k = 1 to n) of the existing source with the data stored in the syntax rule storage unit 236 as a processing target (S1002). .

The CPU 210 determines whether the processing target line (first line) matches the syntax rule data using the control unit 601 (S1003). If they match, the process moves to S1006, and if they do not match, the process moves to S1004.

If they do not match (No in S1003), the CPU 210 registers the number of the row in the non-converted partial row information storage unit 237 (S1004), and the variables used in the row are stored in the non-converted partial variable information storage unit. It is registered in 238 (S1005).

On the other hand, if they match (Yes in S1003), the CPU 210 converts the source code of the line in accordance with the syntax rule data, and creates a conversion source (one line) (S1006).

Subsequently, the CPU 210 determines whether the processing target line is the end (last line) of the existing source file (S1007).

If it is not the last line (No in S1007), the CPU 210 advances the process target line by one and shifts the process to S1002 (S1009). Then, the processing from S1002 to S1007 is executed for the new processing target row.

When it is the last line (Yes in S1007), the CPU 210 generates non-converted partial information 232 from information stored in the non-converted partial line information storage unit 327 and the non-converted partial variable information storage unit 328 (S1008). ). Specifically, the non-converted part information 232 is generated by integrating a range specified from continuous line information as one non-converted part and variable information.

FIG. 11 is a diagram representing the program conversion process as a process flow on the functional block. Since the processing contents are the same as those in FIG. 10, the description of FIG. 11 is omitted.

<Configuration and example of conversion source>
FIG. 12 is a diagram illustrating a configuration of a conversion source generated by the program conversion process, and FIG. 13 is a diagram illustrating an example of the conversion source.

The conversion source 1200 includes a definition unit 1201 common to the conversion part and the non-conversion part, and an execution unit 1202 configured by at least one non-conversion part and at least one conversion part. As shown in FIG. 12, in the execution unit 1202, the conversion part and the non-conversion part are alternately arranged.

In the conversion source example shown in FIG. 13, the source code from the 1st to 12th lines constitutes the definition part. As described above, this definition section is not subject to program conversion processing, and follows the contents of the existing source.

In the conversion source example, the 13th to 17th lines are the non-converted part 1, the 18th line is the converted part, and the 19th to 28th lines are the non-converted part 2. In this example, the non-conversion part 1 operates without any problem, but in the non-conversion part 2, the operation results differ on the existing computer system 100 and the new computer system 300. This is because the value of the character code value may be different depending on the platform, and the result of the 23rd line will be different due to the influence. That is, in the 23rd line, the character code values of MOJI1 and MOJI2 are compared. In the platform of the existing computer system 100, since the value of the character code of MOJI1 is larger than the character code of MOJI2, “end key input” is set to “0” as defined in the definition section. . On the other hand, on the platform of the new computer system 300, since the character code of MOJI2 is larger than the character code of MOJI1, “end key input” is set to “1”. Thus, there are portions where the result data differs before and after program conversion. The non-converted portion including the portion in which the result data is different is determined as “required for correction” by the non-converted portion test / result determination process.

<Configuration and example of non-converted partial information>
FIG. 14 is a diagram illustrating a configuration of non-converted partial information acquired after program conversion processing, and FIG. 15 is a diagram illustrating an example of non-converted partial information.

The non-converted part information 1400 includes a total number of non-converted part information 1401 indicating the total number of non-converted part information (a value corresponding to the number of non-converted parts), and specific information (start and end rows, Non-conversion partial information 1402 describing (variable information). “Start line” in each non-converted part information indicates the start line of the corresponding non-converted part in the existing source, “End line” indicates the end line of the corresponding non-converted part in the existing source, and the variable information indicates the corresponding non-converted part. The variable information used in the conversion part is shown.

FIG. 15 shows an example where non-converted partial information is extracted from the conversion source given by FIG. In FIG. 13, since the number of non-converted portions is “2”, the total number of non-converted portion information is set to “2” in FIG. In addition, since the start line of the non-conversion part 1 is 13, the end line is 15, and the variables used are NUM, MOJI1, and MOJI2, each is set as information relating to the non-conversion part 1. The same applies to the non-converted portion 2.

<Details of debugger script generation processing>
FIG. 16 is a flowchart for explaining details of the debugger script generation processing in S805 (FIG. 8).

The CPU 210 of the migration support computer system 200 inputs the non-conversion partial information to the debugger script generation unit (program) 2212 and instructs the debugger script generation (S1601).

The CPU 210 uses the debugger script generation unit 2212 to place information on the start line and end line of each non-converted part as a break point (SET BREAK) in the debugger script (S1602). In S1602, each non-converted portion is repeatedly checked to extract information on all start lines and end lines, and these are set as SET BRAKE.

The CPU 210 adds the output to the trace log to the debugger script (S1603). This sets a process for instructing to output the result output (result data) to the File as a trace log.

The CPU 210 describes the output operation of the variable information of the non-conversion part regarding the start line in the debugger script (S1605). This sets the test data output process in each starting line.

In addition, the CPU 210 adds “source execution instruction” to the debugger script (S1606).

Further, the CPU 210 describes the output operation of the variable information of the non-conversion part regarding each end line in the debugger script (S1607). This sets the output process of the result data in each end line.

Finally, the CPU 210 checks the non-conversion part information and determines whether or not there is a non-conversion part that is not described in the debugger script (S1608). If there is unwritten non-converted partial information, the process proceeds to S1604. If all the non-converted partial information is described in the debugger script, the debugger script generation is completed.

<Configuration and example of debugger script>
FIG. 17 is a diagram illustrating a configuration of a debugger script generated by the debugger script generation processing, and FIG. 18 is a diagram illustrating an example of the debugger script.

The debugger script 1700 is a script that describes how to operate the debugger 1211 in the existing computer system 100. A breakpoint setting in which breakpoints (interruption points) are arranged at the start line and the end line of each non-conversion part. Unit 1701, result output setting unit 1702 in which an execution instruction for processing for outputting the result output as a trace log is arranged, and variable values (execution is interrupted) at the start line and end line (interruption point) of each non-conversion part A program execution instruction setting unit 1703 for setting a process for outputting a variable value) and a debugger end instruction unit 1704 for instructing a debugger end process.

FIG. 18 shows a specific example of the debugger script 1800 generated from the example of the non-converted partial information given by FIG. In FIG. 18, lines (13th, 17th, 19th and 28th lines) corresponding to the start line and the end line are set as break points 1801 (SET BREAK) before the program execution unit. At this interruption point, the actual program execution is temporarily stopped. The setting 1802 instructs to output the variable data (test data and result data) of the start line and end line of the non-conversion parts 1 and 2 as a trace log. Further, the execution units 1803 to 1805 are units for instructing to output variable values in the start and end lines of the non-conversion parts 1 and 2.

<Output of trace log>
FIG. 19 is a diagram showing an outline of the trace log output process. The debugger script generated as shown in FIGS. 17 and 18 is sent to the existing computer system 100. In the existing computer system 100, the debugger 1211 executes the debugger by using the debugger script and the existing source (the debugger script is related to the non-converted portion and can use the existing source). The execution result is sent to the migration support computer system 200 and stored as a trace log. That is, the existing source is executed by the debugger in the order of the description contents of the debugger script, and the result is saved as a trace log.

<Configuration and example of trace log>
FIG. 20 is a diagram illustrating a configuration of a trace log generated by executing a debugger process according to a debugger script, and FIG. 21 is a diagram illustrating a specific example of the trace log.

The trace log 2000 includes a plurality of non-converted part trace logs 2001 to 2003. The trace log of each non-conversion part has variable data 20011, 20021... At the start line and variable data 20012, 20022.

FIG. 21 shows an example of the trace log 2100 corresponding to the debugger script 1800. The trace log 2100 is variable information in the 13th line that is the start line of the non-conversion part 1, information 2101 indicating test data described later, and variable information in the 17th line that is the end line of the non-conversion part 1. , Information 2102 indicating result data to be described later, variable information on the 19th line that is the start line of the non-conversion part 2, information 2103 indicating test data to be described later, and 28 lines that are the end line of the non-conversion part 2 This is variable information for the eyes, and is composed of information 2104 indicating result data described later.

<Non-conversion test / result data generation process>
FIG. 22 is a flowchart for explaining the details of the process of generating test data and result data for the non-conversion portion in S809 (see FIG. 8).

The CPU 210 of the migration support computer system 200 reads the trace log from the auxiliary storage device 230 and inputs it to the non-conversion portion test / result data generation unit (program) 2213 (S2201).

Then, the CPU 210 uses the non-conversion portion test / result data generation unit (program) 2213 to generate test data corresponding to the variable value of the start line of each non-conversion portion in the trace log (S2202).

Further, the CPU 210 uses the non-conversion part test / result data generation unit (program) 2213 to generate result data corresponding to the variable value of the end line of each non-conversion part in the trace log (S2202).

<Configuration and example of non-conversion test / result data>
FIG. 23 is a diagram illustrating a configuration of the non-conversion portion test / result data, and FIG. 24 is a diagram illustrating a specific example of the non-conversion portion test / result data.

The non-conversion part test / result data 2300 includes a plurality of non-conversion part test / result data 2301, 2302,. The test / result data 2301, 2302,... Of each non-conversion part includes test data 23011, 23021... In each non-conversion part and result data 23012, 23022. ing. Here, the test data is used as an initial value of each non-conversion part. The result data is an output value at the end of processing of each non-conversion part, and is used for comparison with an execution value obtained by inputting test data to the non-conversion part of the conversion source, as will be described later.

FIG. 24 shows an example of the test / result data 2400 for the non-conversion portion generated from the trace log 2100. Non-conversion part test / result data 2400 includes non-conversion part 1 test data and non-conversion part 1 test data and result data 2401 including non-conversion part 1 input test data and non-conversion part 1 output data. Input test data and non-converted portion 2 test data and result data 2402 including result data which is an output value of the non-converted portion 2.

The test / result data for non-conversion part provides appropriate data (result data) for the non-conversion part.

<Outline of non-conversion partial test / result judgment processing>
FIG. 25 is a functional block diagram for explaining the outline of the non-conversion partial test / result determination process.

The non-conversion partial test / result determination unit (program) 3213 of the new (migration destination) computer system 300 receives the conversion source 202 and the non-conversion test / result data 208 from the migration support computer system 200.

The non-conversion partial test / result determination unit (program) 3213 generates partial sources 332-1, 332-2,... From each non-conversion part of the conversion source 202. The total number of partial sources is the number of non-converted parts.

Then, the non-conversion partial test / result determination unit (program) 3213 executes each partial source with each test data corresponding to the non-conversion partial test / result data 208 as an input value, and acquires an output value.

Subsequently, the non-conversion partial test / result determination unit (program) 3213 compares each output value acquired for each partial source with the corresponding result data of the non-conversion partial test / result data 208 to make a match. Judge whether to do.

The non-conversion partial test / result determination unit (program) 3213 presents a partial source having an output value that does not match the result data to the user as “correction required” to prompt correction.

When the partial source of “correction required” is corrected, a new source 331 is generated. The new source 331 may be used as the conversion source 202, and the result data and the output value of the partial source may be compared again to confirm whether the data has been properly corrected.

<Details of non-conversion partial test / result judgment processing>
FIG. 26 is a flowchart for explaining details of the non-conversion partial test / result determination process.

The CPU 310 of the new computer system 300 inputs the conversion source 202 and the non-conversion part test / result data 208 to the non-conversion part test / result determination unit (program) 3213 (control unit (program) 32131) (S2601).

The CPU 310 uses the non-conversion partial test / result determination unit (program) 3213 to create a partial source 332 in which the non-conversion part and the definition part are extracted from the conversion source 202 for the total number of non-conversion parts (S2602).

The CPU 310 extracts the corresponding non-converted part test data from the non-converted part test / result data 208, inputs it to each partial source generated in S2602, and tests each partial source 332 alone. (S2603).

The CPU 310 outputs the result of the unit test of S2603 as an output value, and compares it with the result data of the corresponding non-converted portion obtained from the non-converted portion test / result data 208 (S2604).

Then, the CPU 310 determines, for each partial source, whether the output value of the unit test matches the result data of the corresponding non-converted part (S2605).

If they match (Yes in S2605), the CPU 310 determines that the target non-converted portion is “revision unnecessary” (S2606).

On the other hand, if they do not match (No in S2605), the CPU 310 determines that the target non-converted part is “requires correction” (S2607).

Finally, the CPU 310 determines whether or not there is an unprocessed partial source, and if not, terminates the process, and if there is, shifts the process to S2603 (S2608).

<Concept of partial source generation processing>
FIG. 27 is a diagram for explaining the concept of processing for generating the partial source 332 from the conversion source 202.

The conversion source 208 is configured by the definition unit 2021 and the execution unit 2022 as described above.

The partial sources 332-1, 332-2, 332-3,... Are generated corresponding to each non-converted portion. Each partial source is generated by copying the definition part 2081 of the conversion source 202 and one non-conversion part as an execution part.

<Concept of partial source unit test and correction necessity determination processing>
FIG. 28 is a diagram for explaining the concept of a partial source unit test and a correction necessity determination process.

The test data of the non-converted part to be processed is extracted from the non-converted part test / result data 208 and is input to the partial source 332 having the corresponding non-converted part. The execution data is output as an output result.

Further, the result data of the non-converted part to be processed is extracted from the non-converted part test / result data 208, and the result data is compared with the output result of the corresponding non-converted part.

If they match, the corresponding non-converted part can be used as it is on the new platform, so it is judged as “no correction required”. On the other hand, if they do not match, the corresponding non-converted portion cannot be used as it is in the new plot form, and therefore it is determined that “correction is required”.

FIG. 29 is a diagram showing an example of an output result when two partial sources are executed alone. FIG. 29 includes an example of a non-converted portion determined to be “correction unnecessary” and an example of a non-converted portion determined to be “correction required”.

That is, in FIG. 29, the non-conversion part 1 has an output result obtained by inputting the input test data, which matches the non-conversion part result data (see FIG. 24). It is determined that “no correction is required”.

On the other hand, in FIG. 29, in the non-conversion part 2, the output result obtained by inputting the input test data is inconsistent with the non-conversion part result data (see FIG. 24). Is determined to be “correction required”. Specifically, the output to be “end key input: 0” as shown in FIG. 24 is “end key input: 1” in FIG. 29. This is due to the fact that the output results will be different before and after the transition because of the new platform. This is because, for example, the character code is different due to the platform change, and the execution result of “IF MOJO1 LESS THAN MOJI2” in FIG. 13 is different.

Therefore, the user must correct the conversion source (partial source) so that the same result as the output result before the transfer is output for the non-converted part determined as “required for correction” in this way.

<Configuration and example of new source>
FIG. 30 is a diagram illustrating a configuration of a conversion source (new source) after determination of necessity of correction, and FIG. 31 is a diagram illustrating a specific example of a new source.

The new source 3000 includes a definition unit 3001 and an execution unit 3002. The definition unit 3001 has the same content as the definition unit 1201 included in the conversion source before determining whether correction is necessary. The execution unit 3002 has a configuration in which a non-conversion portion that does not require correction and a conversion portion that requires correction are mixed. As will be described later, it is possible to allow the user to understand which part of the new source should be corrected by clearly presenting the part requiring correction through the GUI.

As shown in FIG. 31, the new source after determining whether or not correction is necessary includes a definition part, a non-converted part determined to be unnecessary for correction (lines 13 to 18), and a non-converted part determined to require correction ( 19th to 28th lines). Since the new source (FIG. 31) is not yet a corrected source, it has the same configuration as the conversion source (FIG. 13), but the new computer system 300 has already known which part needs correction. Is different.

<Guide for non-conversion partial correction>
FIG. 32 is a diagram showing a GUI (displayed on the display screen of the output device 350 of the new computer system 300) used when the user corrects the conversion source (non-conversion part).

When the user instructs the editor (program) 3212 to correct the non-conversion part, as shown in FIG. 32, the editor 3212 includes the entire conversion source so that the part needs to be corrected. The GUI screen 3000 is displayed.

The correction GUI screen 3200 includes a correction required line number display 3001 indicating the total number of non-converted parts to be corrected, a corrected / corrected main part display 3202 indicating how many corrections have been completed among the correction required parts, A conversion source display 3203, a correction necessary part display 3004, and a correction completion button display 3205 are included.

The correction required portion display 3204 is a non-converted portion that is determined as “correction required” on the editor screen by the CPU 310 using the editor 3212 based on the determination result by the non-converted portion test / result determination processing (FIG. 26). By performing the highlight display process and the background color change display process, it is easy for the user to understand the non-converted portion of “correction required”.

When the correction is completed on the GUI screen 3200, the correction process is completed when the user presses the correction completion button 3205, the corrected conversion source is registered as a determination target, and the non-converted partial test / result determination process ( 26 is executed (see FIG. 29).

<Summary>
(1) In the embodiment, a conversion source is generated by converting an existing source using a conversion tool. The conversion source contains both conversion and non-conversion parts. The migration support computer system acquires the variable value of the non-conversion part, the range of the non-conversion part, and the conversion source of the non-conversion part. The initial value (test data) of the variable at the start line (at the start of processing) and the end value (result data) of the variable at the end line (at the end of processing) are acquired. Further, the migration support computer system obtains input information (corresponding to test data) and comparison information (corresponding to result data) from the initial value (test data) and end value (result data) of the acquired variable. ). The new (destination) computer system generates a partial source by extracting the part corresponding to the source of the non-converted part from the conversion source on a platform different from the existing computer system, and inputs the input information to the partial source. Then, the output result of the test is compared with the comparison information (result data), and the comparison result is output. In this way, when the source is transferred between computers with different platforms, the range to be corrected in the conversion source can be specified from the comparison result. The functions of the migration support computer system may be configured to be included in the new computer system.

Also, the new computer system determines whether or not the non-converted portion needs to be corrected based on the output result and the comparison information, and outputs information on the determination result. In this way, since the determination result of whether or not correction is necessary is shown, it is possible to easily specify the range to be manually corrected in the conversion source, and it is possible to reduce the man-hour at the time of source correction. .

Further, when the non-converted portion determined to be corrected is corrected, the new computer system again compares the output result of the non-converted portion with the comparison as the test target for the corrected non-converted portion. . By doing so, it is possible to confirm whether or not the corrected part is corrected correctly, and it is possible to easily verify whether the conversion source operates correctly on the migration destination computer platform.

When the transition support computer system obtains the initial value (test data) of the variable in the start line and the end value (result data) of the variable in the end line in the non-conversion part, Place a breakpoint and create a debugger script. This debugger script is used by a debugger of an existing computer system, and a trace log is acquired. The trace log describes the value of the variable at the interruption point as the initial value and end value of the variable. By doing so, the debugger targets only the non-converted portion according to the debugger script as the target of the debugger processing, so unnecessary processing can be avoided and processing efficiency can be improved. .

The new computer system corrects the non-converted part when the output result as the execution result obtained by inputting the test data to the partial source matches the comparison information (result data) obtained from the trace log. If it is determined that the output result and the comparison information do not match, it is determined that the non-conversion portion needs to be corrected. Further, the new computer system displays at least a non-conversion part and a GUI indicating whether or not the non-conversion part needs to be corrected, and prompts the user to correct the non-conversion part that requires correction. The GUI displays which non-conversion parts need correction. By doing so, the user can identify the correction location at a glance, and the man-hour in the correction work (manual work) of the non-conversion part included in the conversion source can be greatly reduced.

In this embodiment, a case where a program conforming to COBOL is converted to a program conforming to open source is taken as an example, but the present invention is not limited to this form. However, since the source created according to COBOL has a high asset value, it becomes possible to effectively use the asset by enabling the migration of the existing COBOL source to the new computer system.

(2) The present invention can also be realized by software program codes that implement the functions of the embodiments. In this case, a storage medium in which the program code is recorded is provided to the system or apparatus, and the computer (or CPU or MPU) of the system or apparatus reads the program code stored in the storage medium. In this case, the program code itself read from the storage medium realizes the functions of the above-described embodiments, and the program code itself and the storage medium storing the program code constitute the present invention. As a storage medium for supplying such program code, for example, a flexible disk, CD-ROM, DVD-ROM, hard disk, optical disk, magneto-optical disk, CD-R, magnetic tape, nonvolatile memory card, ROM Etc. are used.

Also, based on the instruction of the program code, an OS (operating system) running on the computer performs part or all of the actual processing, and the functions of the above-described embodiments are realized by the processing. May be. Further, after the program code read from the storage medium is written in the memory on the computer, the computer CPU or the like performs part or all of the actual processing based on the instruction of the program code. Thus, the functions of the above-described embodiments may be realized.

Further, by distributing the program code of the software that realizes the functions of the embodiment via a network, the program code is stored in a storage means such as a hard disk or a memory of a system or apparatus, or a storage medium such as a CD-RW or CD-R And the computer (or CPU or MPU) of the system or apparatus may read and execute the program code stored in the storage means or the storage medium when used.

Finally, it should be understood that the processes and techniques described herein are not inherently related to any particular equipment, and can be implemented by any suitable combination of components. In addition, various types of devices for general purpose can be used in accordance with the teachings described herein. It may prove useful to build a dedicated device to perform the method steps described herein. Various inventions can be formed by appropriately combining a plurality of constituent elements disclosed in the embodiments. For example, some components may be deleted from all the components shown in the embodiment. Furthermore, constituent elements over different embodiments may be appropriately combined. Although the present invention has been described with reference to specific examples, these are in all respects illustrative rather than restrictive. Those skilled in the art will appreciate that there are numerous combinations of hardware, software, and firmware that are suitable for implementing the present invention. For example, the described software can be implemented in a wide range of programs or script languages such as assembler, C / C ++, perl, shell, PHP, Java (registered trademark).

Furthermore, in the above-described embodiment, control lines and information lines are those that are considered necessary for the explanation, and not all control lines and information lines on the product are necessarily shown. All the components may be connected to each other.

In addition, other implementations of the invention will become apparent to those skilled in the art from consideration of the specification and embodiments of the invention disclosed herein. Various aspects and / or components of the described embodiments can be used singly or in any combination in a computerized storage system capable of managing data. The specification and specific examples are merely exemplary, and the scope and spirit of the invention are indicated in the following claims.

1 Program migration system (program conversion system)
100 Existing (migration source) computer system 101 Existing source storage unit 102 Debugger processing unit 110 CPU
120 Main storage device 130 Auxiliary storage device 140 Input device 150 Output device 160 Communication port 200 Migration support computer system 201 Program conversion unit 202 Conversion source storage unit 203 Non-conversion partial information storage unit 204 Debugger script generation unit 205 Debugger script storage unit 206 Trace log storage unit 207 Non-conversion part test / result data generation part 208 Non-conversion part test / result data storage part 210 CPU
220 Main storage device 230 Auxiliary storage device 240 Input device 250 Output device 260 Communication port 300 New (destination) computer system 301 Non-conversion partial test / result determination unit 302 New source storage unit 310 CPU
320 Main storage device 330 Auxiliary storage device 340 Input device 350 Output device 360 Communication port

Claims (19)

1. A program conversion method for converting a first program operating on a first platform into a second program operating on a second platform having a different format,
   A processor, using a conversion tool, obtains a value of a variable of a non-conversion part, a range of the non-conversion part, and a conversion source of the non-conversion part during conversion of the first program;
   From the value of the acquired variable and the range information of the non-conversion part, obtain the initial value of the variable at the start of processing of the non-conversion part and the end value of the variable at the end of the process,
   From the acquired initial value and end value of the variable, create input information and comparison information to the second program,
   A program conversion method comprising: inputting input information to the conversion source on the second platform; comparing a test output result with the comparison information; and outputting a comparison result.
2. In claim 1,
   Furthermore, the processor determines whether or not the non-converted portion needs to be corrected based on the output result and the comparison information, and outputs information of the determination result.
3. In claim 1 or 2,
   Further, when the non-converted portion determined to be corrected is corrected, the processor compares the output result of the non-converted portion with the comparison again as the test target for the corrected non-converted portion. A program conversion method characterized by:
4. In any one of Claims 1-3,
   When obtaining the initial value of the variable at the start of processing of the non-converted portion and the end value of the variable at the end of processing, the processor places break points at the first and last lines of the non-converted portion, and A program conversion method characterized in that a value of a variable at a point is acquired as an initial value and an end value of the variable.
5. In claim 4,
   A program conversion method, wherein a processor acquires a value of the variable at the interruption point as a trace log.
6. In claim 2,
   The processor determines that the non-conversion portion need not be corrected when the output result matches the comparison information, and corrects the non-conversion portion when the output result does not match the comparison information. Judge that it is necessary,
   Further, the program conversion method characterized in that the processor displays at least the non-conversion portion and a GUI indicating whether or not the non-conversion portion needs to be corrected, and prompts the correction of the non-conversion portion requiring correction.
7. In any one of Claims 1-6,
   The program conversion method, wherein the first program is a program conforming to COBOL, and the second program is a program conforming to open source.
8. A first computer system that operates a first program on a first platform, a computer system that operates a second program on a second platform having a format different from that of the first platform, and the first program as the second program A third computer system that supports the conversion process, and a program conversion system comprising:
   The first computer system includes a first memory that stores the first program, and a first processor that executes a debugger process on the first program,
   The second computer system has a second memory for storing the second program obtained by converting the first program, and a second processor for executing the second program,
   The third computer system includes a third memory that stores a support program for processing that supports conversion from the first program to the second program, and a third processor that executes the support program. ,
   The third processor reads the support program from the third memory, and uses a conversion tool included in the support program to convert a variable value of a non-conversion part and a range of the non-conversion part when the first program is converted. , And the process of acquiring the conversion source of the non-converted part, and the initial value of the variable at the start of the process of the non-converted part and the information at the end of the process from the information of the acquired variable value and the range of the non-converted part A process of acquiring an end value of the variable, and a process of creating input information and comparison information to the second program from the initial value and the end value of the acquired variable,
   The second processor inputs input information on the second platform to the conversion source, compares the output result of the test with the comparison information, and outputs the comparison result. A program conversion system characterized by being executed.
9. In claim 8,
   The second processor further executes a process of determining whether or not the non-conversion portion needs to be corrected based on the output result and the comparison information, and outputting information of the determination result. Conversion system.
10. In claim 8 or 9,
    Further, when the non-conversion portion determined to be corrected is corrected, the second processor, for the corrected non-conversion portion, as an object of the test, the output result of the non-conversion portion and the comparison A program conversion system that executes a process of comparing the two again.
11. In any one of Claims 8 to 10,
    The third processor interrupts the first and last lines of the non-conversion part when executing the process of obtaining the initial value of the variable at the start of the process of the non-conversion part and the end value of the variable at the end of the process. A program conversion system characterized in that a point is arranged and a value of a variable at the interruption point is acquired as an initial value and an end value of the variable.
12. In claim 11,
    The program conversion system, wherein the third processor acquires the value of the variable at the interruption point as a trace log.
13. In claim 9,
    The second processor determines that the non-conversion part need not be corrected when the output result and the comparison information match, and the non-conversion part when the output result and the comparison information do not match. It is determined that correction is required,
    The second processor further executes a process of displaying at least the non-conversion part and a GUI indicating whether or not the non-conversion part needs to be corrected, and prompts the correction of the non-conversion part that requires correction. A featured program conversion system.
14. A program that converts a first program that operates on a first platform into a second program that operates on a second platform of a different format,
    To the processor,
    A process of converting the first program into the second program by a conversion tool to generate a conversion source;
    A process of acquiring a value of a variable of a non-conversion part, a range of the non-conversion part, and a conversion source of the non-conversion part at the time of conversion of the first program;
    A process of obtaining an initial value of a variable at the start of processing of the non-conversion part and an end value of a variable at the end of processing from the value of the acquired variable and the range of the non-conversion part,
    A process of creating input information and comparison information to the second program from the initial value and end value of the acquired variable;
    A process of inputting input information to the conversion source on the second platform, comparing a test output result with the comparison information, and outputting a comparison result;
    A program for running
15. In claim 14,
    A program for causing a processor to further execute a process of determining whether or not the non-conversion portion needs to be corrected based on the output result and the comparison information, and outputting information of the determination result.
16. In claim 14 or 15,
    When the non-conversion portion determined to be corrected is further corrected by the processor, the output result of the non-conversion portion and the comparison are compared again as the test target for the corrected non-conversion portion. A program characterized by causing processing to be executed.
17. In any one of claims 14 to 16,
    When executing processing for obtaining the initial value of the variable at the start of processing of the non-converted portion and the end value of the variable at the end of processing in the processor, the break points are arranged at the first and last lines of the non-converted portion. And a program for causing the value of the variable at the interruption point to be acquired as an initial value and an end value of the variable.
18. In claim 17,
    A program for causing a processor to acquire a value of the variable at the interruption point as a trace log.
19. In claim 15,
    When the output result and the comparison information match, the processor determines that the non-conversion portion need not be corrected. When the output result and the comparison information do not match, the processor corrects the non-conversion portion. Let me decide that I need it,
    A program for causing a processor to further display at least the non-conversion portion and a GUI indicating whether or not the non-conversion portion needs to be corrected, and to execute a process for prompting correction of the non-conversion portion that requires correction. .

Images