JPH0384627A - Computer program transfer device - Google Patents

Abstract

PURPOSE:To reduce the labor, the time, and the cost required for transfer of a program by reading the untransferred program information, the transfer program information, the extracting area, and the detection result out of each memory means and printing these read factors after editing them into a form showing the transfer process. CONSTITUTION:A conversion verification means 44 reads the transfer program information out of a transfer program memory means 43 and reads the replacement rule information out of a replacement rule memory means 39. Then the means 44 verifies the propriety of conversion of a change area conversion means 42 and writes this inspecting result into a verification result memory means 45. Then a conversion confirmation information production means 46 reads the untransferred program information, the transfer program information, the extracting area, and the verification result out of the memory means 11, 41, 42 and 45 respectively and gives these reads factors to a print means 122 after editing them into a form showing the transfer process. The means 122 prints the received factors. As a result, an operator can know the presence or absence of a conversion error via the printing operation of the means 122. Then the labor and the time can be reduced for conversion of transfer together with reduction of the cost.

Description

DETAILED DESCRIPTION OF THE INVENTION [Field of Industrial Application] The present invention relates to the modification of computer programs, and particularly to the conversion of computer programming languages for porting programs between different types of computers.

[Conventional technology]

When porting a computer program, the programmer extracts the parts of the program information to be ported that differ in language (change parts), changes the program code (change coding), and creates a list of changed programs. .

[Problem to be solved by the invention]

It takes a lot of effort and time to sequentially perform change coding for each change location.

It is also prone to change errors.

The present invention relates to efforts in porting computer programs.

The aim is to save time and money and reduce language translation errors.

[Means to solve the problem]

The computer program porting device of the present invention includes: a two-dimensional display means (115); a keyboard (101) provided with a plurality of information holes; a display input position for specifying a display input position on the display surface of the two-dimensional display means (115); Position indicating means (
ioi) ; Replacement convention memory means (
39) : Pre-porting program memory means (11) storing program information to be ported; Reading the pre-porting program information from the pre-porting program memory means (11) and extracting the changed parts for porting according to the replacement rule information. Changed part extracting means (40) writes the changed part into the result memory means (41); Reads the changed part from the extracted result memory means (41), reads replacement rule information from the replace rule memory means (39), and changes the pre-porting program information. a modified part conversion means (42) that converts the part according to the replacement convention and then writes it into the transplantation program memory means (11); reads the transplantation program information from the transplantation program memory means (11), reads the replacement convention information from the replacement convention memory means; Conversion verification means (44) that verifies the validity of the conversion of the changed part conversion means (42) and writes it into the verification result memory means (45);
The pre-transplant program information, the transplant program information, the extraction location, and the verification results are stored in each of the memory means (11, 41).
. Note that symbols in parentheses indicate corresponding elements in the embodiments shown in the drawings and described later.

[Effect]

The operator uses an input key to input in advance the correspondence between the code to be changed and the code after change in the pre-transplant program information, that is, the replacement rule information, and stores it in the replacement rule memory means (39). When the operator specifies the pre-porting program stored in the memory means (11) using the input key and inputs the conversion for porting, the changed part extracting means (40)
reads out the pre-porting program information from the memory means (11), extracts the changes for porting according to the replacement rule information, and writes the extracted results into the memory means (41). When this is completed, the changed part conversion means (42) reads the changed part from the extraction result memory means (41), reads the replacement rule information from the replacement rule memory means (39), and converts the changed part of the pre-porting program information according to the replacement rules. This is converted and written into the memory means (43) as post-implantation program information.

Further, the conversion verification means (44) reads the porting program information from the porting program memory means (43) and reads the replacement rule information from the replacement rule memory means to verify the validity of the conversion by the changed part converting means (42). The conversion confirmation information creation means (46) writes the pre-transplant program information, the transplant program information, the extraction location, and the verification result into each memory means (45).
11, 41, , 43, 45), are edited into a format showing the porting process, and are sent to the printing means (122) for printing. From this printout, the operator can know whether there is a conversion error or not. If a change error is printed, the operator can either correct a part of the conversion error in the program information that was converted for porting, or use the input key to correct the conversion error. The replace rule information in the replace rule memory means (39) is corrected and the conversion instruction is input again.

The operator can determine whether or not the ported program information is appropriate based on the pre-ported program information, ported program information, and extraction location on the print, without relying solely on the notation of the presence or absence of change errors on the print.

Therefore, the operator only needs to input the replacement rule information and porting target source program specification information, and by these inputs, the porting source program is automatically obtained, and its change errors are searched, so some of the change errors can be removed. Just correct it.

When creating a porting source program by converting the language of the pre-porting source program, it takes about 5 key-in operations to change information (coding input) in one place.
This has to be done for each changed part of the entire source program, but this can be done by inputting the change information once for each change information (input for creating replacement rule information). Searching for changes and making changes there virtually no longer requires human labor, which greatly reduces the time and cost of conversion for porting, and the porting process is automatically generated and printed out. Based on this, a conversion error check can be easily performed, and it is useful for later conversion error checks, program changes, corrections, or reverse conversions.

Other objects and features of the present invention will become apparent from the following description of embodiments with reference to the drawings.

〔Example〕

FIG. 1 shows the configuration of an embodiment of the present invention. In FIG. 1, an end computer 100 includes hardware equivalent to a computer terminal, a personal computer, or an image processing device generally called a processor. Endumi Computer 1.00.

It is connected to exchange 200.

The exchange 200 selectively connects the end computers 100 to the central computer 1 according to their requests.

The central computer l has various memories 3゜6.8, 11, allocated to a magnetic drum storage device which is a database memory.
17,19,21,2°3,37°39.41,43,
Writing data to and reading data from 45, and various programs 2, 4, 5, 7, 9,
10,16°18.20,22,24,35,38,4
According to 0°42.44 and 46, data is exchanged with the end computer and various data conversions are performed.

An overview of the program and memory of the central computer is shown below.

*Input/output control program 4: Data exchange with end computer and other programs 2,5゜7.9,1
0,16,18,20,22,24°35,38.40
．． 42, 44, and 46 are accessed.

*Parts data registration program 5: Endi computer 10
Program part data (information on a part of the program) and part name data (part name information) given by 0
Accordingly, a program component (the rightmost column in Table 1) is written to the component data group storage memory 6 for one component name (second column from the right in Table 1).

*Part name registration program 2: When function key assignment is specified, the program part name is assigned to the function key, and the program part name data (first 211I) from the right of the table is written into the component memory 3. When a simple pattern is specified, program data (the rightmost l1l in the second table) addressed to the key-in simple information (241st from the left in the second table) is written into the component memory 3.

Furthermore, when an abbreviation pattern is specified.

Key-in information (corresponding to the 2nd item from the left in Table 3), search for the items specified in the key-in information, and
(i.e., perform the processing in the rightmost column of Table 3)
.

*Interactive coding program 7: In accordance with input from the keyboard of the computer 100, program part names corresponding to function key manual input, abbreviated form information corresponding to abbreviated form input, abbreviated pattern information corresponding to abbreviated pattern input , and the input storage memory 8 stores the coding corresponding to the coding input by one person.
Expand interactively above.

*Source program automatic generation program 9: Converts the specified coding information in the input storage memory 8 into program data according to the coding information in the parts memory 3 (function key information → part name → part data; abbreviated form → original language type) ; omitted pattern → parts pattern).

Table 2 * Source program inspection program 10 Niprogram 9
Formatting the syntax of the source program generated in 9. Performs a syntax error check and standardization convention error check.

Of the above programs, programs 2 and 5 are for storing standardized names (part names) and standardized part data (program parts) in memory 3.6 for automatic source program generation, and program 7 .9
and 10 are for automatically generating a source program based on these standardized data, and the generated source program is registered in the program storage memory 11.

The following programs 16, 18, 20, 22, and 24° are for automatically generating debug data for a source program and debugging the source program.

*Debug data component registration program 182 Define test data for each name and array of tables/files used in the target system, and search whether the table/file is used for each parameter used in the subroutine. If the table/file component is used, it is defined to generate test data using the table/file component and registered in the debug data component storage memory 19.

*Symbol information analysis program 16: Analyzes the program syntax to create test data symbol information and registers it in the analysis data storage memory 19.

*Debug data generation program 20 generates test data by linking red herring information and writes it into the debug data storage memory 21.

*Debug data registration program 22: formats and optimizes the debug data written in the memory 21, and registers it in the debug data storage memory 23.

*Online program debugging program 24: Debugs the source program to which the debug data registered in the debug data storage memory is addressed using the debug data, and sends or generates according to instructions source program storage memory 11 Register or renew your registration.

Next programs 35, 38, 40, 42, 44 and 4
6 is used for modifying or changing a program or converting a language for porting, that is, conversion.

*Relational information extraction program 35: Restores the modified parts (items) and modified contents (items) of the original source program, creates a cross-reference list, and registers it in the related information extraction data storage memory 37.

*Conversion rule registration program 38 registers the conversion rules (replacement rule information in case of porting) created by two people in the rule data storage memory 39.

*Conversion main part extraction program 40: Extracts the changed parts of the pre-portation program information and stores them in the extracted data storage memory 41.
Register as extracted result data.

*Correction/, 1! Collection program 42: Memories 39 and 4
Based on the data in step 1, the H (before transplantation and other changes) source program is modified to obtain a new (S transplantation and other necessary) source program, and is registered in the transplantation source program storage memory 43.

Main conversion inspection program 44: Verifies the result of conversion from the rule data in the ported (new) source program memory 39 and the extracted data in the memory 41.

Conversion result confirmation strike output program 46: Pre-transplant CM
) Source program and porting (new) Read the source program from memory 11.43 on one program card at a time, read the language changes (changed portions) and verification results from memories 41 and 45, and show the porting process. Edit the format and print out each program card.

The terminal computer 100 includes a microprocessor 102 serving as the main image processing means and a calculation microprocessor 106.

The processor 102 has an address bus and a data bus.

A ROM 103 that stores a program for controlling the operation of hardware via a control bus, etc., and via required input/output ports and interfaces. A RAM 104 that stores system operation programs, editing programs (parts), menu screen data, and edited image data (character code & vector information), a bus controller 105, and a bus controller 105 for storing system operation programs, editing programs (parts), menu screen data, and editing image data (character code & vector information), and a bus controller 105 for storing system operation programs, editing programs (parts), menu screen data, and editing image data (character code & vector information). Communication control unit 107a that controls transmission and reception of instructions and data
, a ROM 109 storing pattern information representing characters such as letters, symbols, and numbers, and a printer 122 . Among the image data concentrated in the IW, RAM 1 is used to write image data for one screen of the CRT display 115 (character codes are unchanged, vector information is converted to pixels).
12. CRT display 11 as a two-dimensional display means
5. CRT controller 116. A magnetic hard disk 117 for storing data received from the central computer 1 and key-in data, and a floppy disk device for inputting system operation programs and for writing source programs on the floppy disk! 119. A buzzer 121 and a keyboard 101 are connected.

Note that a mouse for specifying the cursor position on the CRT 115 screen is connected to the keyboard 101.

The cursor on the CRT screen can be moved using the cursor shift key on the keyboard 101 and the mouse.

When a system floppy disk storing a system operation program is set in the floppy disk device 119 and the power of the terminal computer 100 is turned on, the processor 102 performs a reset operation, and then the ROM 1
Based on the hardware control program 03, each element of the computer 100 is initialized, and the system operation program from the system floppy disk is read and stored in the RAM 1 of the RAM 104.

Based on the system operation program, when there is an input from the keyboard 101 specifying "program processing", the end computer 100 is connected to the central computer l,
Thereafter, during "program processing", data input using the keyboard and mouse is transmitted to the central computer 1, and the data sent from the central computer 1 is written into a required memory and displayed on the CRT display 115.

The following describes automatic source program generation processing based on various programs of the central computer 1, automatic debug data generation processing, automatic program change (conversion) including language conversion for porting, and related data registration, input/output. Processing etc. will be explained.

Reference is first made to FIG. 2a. The central computer 1 sets the input/output program 4 as the operating program in the standby state (step 1: hereinafter, the word "step" will be omitted in parentheses).

When the terminal computer 100 notifies "program processing", the menu screen data of "program processing" is sent to the terminal computer 10 according to the input/output program 4.
0, and the terminal computer 100 displays it on its CRT display 115 (2).

Endless computer 100th operator is keyboard 10
1 or the mouse to specify and input "1. Program automatic generation" on the menu screen, this is notified to the central computer 1, and the central computer 1.

Send the menu screen data of "1. Program automatic generation" to the terminal computer 100, and
O displays on its CRT display 115 (3).

"1. Registration" on this menu screen includes simple pattern registration shown in Table 2, abbreviated pattern registration shown in Table 3, program part registration corresponding to the part names shown in Table 1, and function key registration shown in Table 1. Assignment with part name,
Alternatively, it is used to register standardized rules.

When the operator specifies and inputs "1. Registration" on the menu screen using the keyboard 101 or mouse, this is notified to the central computer 1, and the central computer 1 sends the menu screen data of "rl, 1 record" to the terminal computer 100. , terminal computer +00 has its CRT display 1
15 (4).

The operator selects "1. Simple pattern registration J" on the menu screen.
, r;2. Omitted pattern registration J, r4. When you specify "Assign parts data to function key" or "Register 5° standardization rule" using the keyboard 101 or mouse,
The central computer 1 starts the component name registration program 2 via the input/output control program 4, and performs simple pattern registration (51
), omitted pattern registration (5□), component data assignment to function keys (54) or standardization convention registration (55)
), and when "3. Program component registration" is specified and input, the central computer 1 executes program component registration (53) via the input/output control program 4.

These registrations are for forming, modifying, or adding to a database for automatic program generation and automatic program conversion, and are simple pattern registration (51).
In this case, the operator inputs the original format (for example, PROGRAM) as shown in Table 2, and inputs its simplified format (PROGRAM).
) is input to designate and input simplified pattern registration, the simplified form is registered in the memory 3 in such a way that the original form is accessed in the simplified form.

In the abbreviation pattern entry @ (52), the operator enters an abbreviation pattern shown in the usage example column (for example, T
ASKA) and the task name to be included in it,
In response to inputting a file or the like and designating and inputting abbreviation pattern registration, all task names, file lists, etc. are registered in the memory 3 in the form of access in the abbreviation pattern.

In assigning component data to function keys (54), the operator assigns the input (54) as shown in Table 1.
This assignment is registered in the memory 3 in correspondence with the function key pair (part name).

In the standardization convention registration (55), the input standardization convention is registered in the memory 3.

In program component registration (53), the central computer 1 activates the component data registration program 5 via the input/output control program 4. The operator uses the terminal computer 100
create program parts through keyboard input, or receive the resource program transferred from the central computer and extract the required parts from it, or extract the required parts from the source program read from the floppy disk 120 or the hard disk 118. input an instruction to register a part in association with one part name. In response, the central computer 1 writes this program component into the component data group storage memory 6 in association with the component name.

When modifying component data (program components), the component name is specified, the component data is read out, the component data is manually edited using the keyboard 101, and the data is re-registered.

By the process of "1. Registration J (3, 4)" explained above,
Standardized data for automatic program generation and automatic program conversion is formed in the memories 3 and 6.

Next, the process of "automatic program generation" will be explained.

While the menu screen is displayed in step 3 of FIG. 2a, the operator selects r2. When the user inputs an instruction for "interactive coding," the central computer 1 activates the interactive coding program 7 via the input/output control program 4 and transfers the menu screen data of the interactive coding program to the computer 100. The computer 100 displays this on the CRT 115 (6: Fig. 2b). Note that this menu screen (6) is always displayed at the lower left corner of the display screen while "Coding" is specified. The input mode can be switched by specifying "Function key manual input" (8) while "Dialogue manual input" (7) is being executed, and vice versa.

When the operator specifies "1. Dialogue human power" on this menu screen, the central computer 1 executes "Dialogue human power" (7) via the terminal computer 100. In this case, 1 normal program coding by keyboard input is performed. That is, input characters, numbers, symbols, etc. are displayed at the current cursor position on the CRT display 115, data corresponding to the display is written to the input data storage memory 8, and editing processing corresponding to keyboard input is performed. It is done. This "interactive human power" (7) is a normal coding process that corresponds one-to-one to keyboard input.

When the operator specifies "2. Function key manual" on the menu screen (6: FIG. 2b), the central computer 1 executes "Function key manual" (8) via the terminal computer 100.

This content is shown in Figure 2c. In this case, if there is a function key (13), the program part name corresponding to the code of the key is searched from the memory 3 (14).
), writes the searched program component name at the cursor position on the CRT display 115 (15>).

When the operator specifies "3. Program development" on the menu screen (6: Figure 2b), the terminal computer 100
The central computer l executes "program expansion" (9) via the central computer l. This content is shown in Figure 2d. In this case, a registered component name is searched for in the information (source card) on the display screen of the CRT display 115 (16), the component data (program component) of the searched component name is read out from the memory 6, and the data is stored in the buffer. Expand to memory (17)
. Next, in the same way, search for a registered abbreviation pattern in the information on the display screen (18), and develop the original pattern data of the searched abbreviation pattern in the paraphrase memory (19).
). Next, replace the part name and abbreviation pattern of the source card with the part data and original pattern data developed on the buffer memory (generate a new source card).

The display is updated to this (20). Next, the registered simple pattern of the new source card is searched, and the corresponding pattern data is read from the memory 3 and replaced with the simple pattern (21). These processes are performed by the source program automatic generation program 9.

The operator creates a source card using the above-described "interaction manual" (7) and "function key manual" (8), and obtains a quasi-source program through "program development" (9).

When the operator specifies "4. Optimization" on the menu screen (6: Fig. 2b), the central computer 1 executes "Optimization
Execute (to). The contents are shown in Figure 2e. In this, first, the syntax of the "semi-source program" is aligned22), duplicate syntax is merged23), syntax errors are checked24), and standardization convention errors are checked. (25). If an error is detected in these checks, it is displayed on the CRT display 115 and corrected by the operator (correction by the interlocutor's cuff. Function key 8 may be manually operated, but in this case, it is necessary to re-execute program expansion 9). ).

FIG. 2f shows the contents of "syntax arrangement J (22). In this, the central computer 1 arranges each sentence in the semi-source program according to the type of sentence.

FIG. 2f illustrates a portion of the process of aligning declaration statements.

Figure 2g shows the contents of ``Merge duplicated syntax J (23).'' This merges declaration sentences with the same character string in the declaration sentences into one.

``The syntax error check J (24) is the same as the processing of a so-called compiler, so its explanation will be omitted here.

Figure 2h shows the contents of the "Standardization Convention Error Check" (25). In this case, the names of unusable subroutines are checked, the names of subroutines to be used bare are checked, and the arguments of the subroutines are checked. If there is an error, part of the error is displayed on the CRT display 115. The operator corrects some errors using "dialogue manual effort" (7) and/or "function key manual effort" (8).

Through the above steps, a source program has been generated.

Now, when "4. Optimization" in the menu display (6) shown in FIG. 2b is specified, the central computer 1 executes "optimization". This is to format the sentence expansion format of the source program obtained so far.1
Process as follows.

a. If the character in the first column is "C", formatting is not performed.

Example: C*100...Do not format as it is a comment text.

b. If the first character is a number, format according to the number of digits of the number.

C0 In cases other than the above, format the sentence so that it starts from the 7th column. If overflow occurs during formatting, use two lines.

Example: K= +1 → K= +1d If the first character string is a declaration sentence, rearrange it according to the grammar rules.

e. If there are identical sentences in the declaration, combine them into one.

The source program obtained as described above can be added to the generated program storage memory 11 in "5. Registration J (11)" as necessary.
Register. You can also print it out using "6. Print" (12), or print it out on the floppy disk 120 or hard disk 118 in the computer 100
You can also register.

Next, the program information obtained by the above-mentioned "automatic program generation" process is shown in FIGS. 3b, 4a, 4b, and 5a, 5b. When the cross section of the spinneret during casting is virtually divided into 5 x 5 regions and the temperature data Tit to T55 of those regions are obtained by calculation, the temperature data of each region is divided into 3 regions. This relates to a source program for displaying temperature distribution by color.

The processing contents (specifications) of this source program are shown in FIG. 3a.

FIG. 3b shows the source card created in the above-mentioned "1. Human interaction" (7) and "2. Function key manual" (8) according to the processing contents shown in FIG. 3a. The numbers in the leftmost column of Figure 3b are the sequence numbers of the source cards.

FIGS. 4a and 4b are quasi-source programs obtained by processing the source card shown in FIG. 3b in the above-mentioned "3. Program development" (9).

Figures 5a and 5b show the final product, that is, the target source program, obtained by processing this C2 quasi-source program with the above-mentioned ``4. In step (11), the generated source program is registered in the generated source program storage memory 11.

The operator inputs the coding into the source card shown in FIG. 3b, and from this source card, the central computer 1 automatically inputs the code in FIGS. The quasi-source program shown in (continued in the figure) is generated. Then, various error checks are automatically performed using "Optimization", and the operator makes corrections in response to the errors, resulting in the target source program shown in Figures 5a and 5b (continued from Figure 5a). is obtained. In contrast, although a large amount of information (Figures 4a and 4b) is ultimately required, information on the required manpower of the operator (
(FIG. 3b) has a very small amount, so the amount of work for the operator is significantly reduced.

According to the automatic source program generation process described above, the operator only has to develop the program part name on the display surface of the CRT display 115, and this program part name can be input using the input keys corresponding to the part name. Since all you have to do is input, the input operation does not take much time and input errors are reduced.

Next, automatic generation processing of debug data will be explained.

When you specify "Test data automatic generation" with the cursor on the menu screen (2) shown in FIG. Menu screen data for specifying data processing is transmitted to the terminal computer 100, which displays it on the CRT display 11°5 (55 in FIG. 6a).

When the operator specifies and inputs "1. Test data parts registration" on the menu screen (55), the menu screen of "Test data parts registration" is displayed on the CRT 115 (56).
. When the operator specifies and inputs "1゜Table/File Component Registration" on this menu screen, the central computer will
The debug data component registration program 18 is activated via the input/output control program 4 and "table/file component registration" (57) is executed. In this "table/file component registration J (57), test data is defined for each name and description for the table/file used in the source program to be debugged. For example, GiNF (6) is the name GiNF, the array 6 represents,
GiNF defines the CRT number (i), GiN
F (2) defines the screen number (always IO), GiN
F(3) to (6) vary depending on test conditions. In this case, FiNF(1); tt #GLBSET GiN
F(1) =0001;FiNF(2); 11
#GLBSET GiNF<2>=0010;
FiNF (ne); 11 #GLBSET GiN
Register the part F(*)=0001;

"2. Subroutine parts registration" on the menu screen (56)
When specified and input, "subroutine parts registration J (
58). "Subroutine parts registration J (58)
A summary of the contents is shown in Figure 6b. In this "subroutine parts registration J" (58), it is searched whether a table/file is used for each parameter used in the subroutine (67).

If used, define to generate test data using table/file parts (6
8). For example, CALL 5VOPN(CRTION, GNO, PAG
Check whether a table/file is used for each parameter (in parentheses) of CRTON=GiNF(1), KYWD, MODE, RETC). It is checked whether there is a part force Σ defined as GiNF;... in the part, and if so, the part is taken out. This allows, for example, tt #GLB CIIECK GiNF<1>
・1MiQ, 0OOI; CHECK GiNF (2)
・[EQ, 0010 ; CIIECK GiNF<3)
・1;0. ＊＊＊＊;# Register #CRT TRACE;

With the test data components created as described above and the menu screen (55) shown in FIG. , start the symbol information analysis program 16 via the input/output control program 4, execute "source program read" (59), and read the source program to be debugged from the generated source program storage memory 11 (59), Analyze the syntax of the source program (60), create test data symbol information 61), link the symbol information 62), and then start the debug data generation program 20 to generate test data (63). .

Figure 6C shows the contents of "Program syntax analysis J (60). In this, the first syntax of the program is P
ROGRAM, 5IJBROUTINE, BLOCK
If it is a DATA statement, extract the header IIOR and write I
An IDRID-code is created (69).

For example, if there is 5UBROUTINIE FIABS, FIABS is extracted and added to the HDR record list.

Next, from all variable names written in the program, S
A YM record or STR record is created (70).

For example, 5UBROUTINE FIABS...DI
Liver N5ION (25)...2000 C0N
TINUE... CALL 5VOPN(CRTNO, GNO,...
).

If so, the underlined part is the variable name, so extract it.

Next, a KEY record and other records are created for each syntax of the program name (71).

For example, =0: The KEY record lists the attributes of K and 0, and the symbol record number.

The REF record has a KEY record number of 0.

The TGT record lists the KIE'/record number.

Subroutine CALI, 5VCLS (CRTNO, GNO, PAG
E, RHTC), KEYI/:I-do has 5
VCLS, CRTNO.

GNO, PAGE, R-rev C attributes and symbol record N
List o. The GRP record includes CRTNO,
GNO, PAGE, RETC KF, Y record N
o.

List.

In the declaration statement DATA FM/100/, the E'/ record lists the attributes and symbol record number of FMloo, the DCL record lists the E'/record number of FMloo, and the C5T record lists the constant. (100
) and the number of characters (the number of characters is 3° characters = 100).

Through the above record creation, a record as shown in FIG. 6d is created.

The contents of test data symbol information creation (61) are explained in section 6e.
As shown in the figure. In this case, the parsed data (various records: Figure 6d) is read (72), and among the variables in the data, variables to be referenced or assigned that belong to the system common area, subroutines and their arguments, and Extract the program name (73), and create symbol information for generating test data according to the attributes of the variables (74).
).

An example is shown below.

Example 1 Niprogram name (IIDRID-code) is FIABS
If so, @5TART FIABS is extracted as symbol information.

n2: Variable DTI-...DTI name (SY
M L/ :]-do) Attribute (KEY record REF record (NTEMP(K) = DT1(i, J
); on the right side of the expression) DCL record (COMMOMtf) > then,
Since it is referenced by DTI (i, J), it is necessary to set data. Therefore, @5TART DTI (set statement) is extracted as symbol information.

Example 3: Variable NcRTB-NCRTB
N L/ml-de) Attribute < KEY record TGTLz:+-de(NCRTB (K) = 1RE
D; on the left side of the equation) DCL L/:! - code (COMMON declaration)
>, check the data since it has been substituted with NCRTB (K). Therefore, @5TART NCRTB is extracted as symbol information.

Example 4: Variable 5VCLS・-・Name 5VCLS (S
YM L/: 1-code) Attribute <KEY record GRP record> CRTNO=GiNF (1): CRT used for display
is defined as GiNF(1), so @5TART
#GGiNF, #GGiNF, #GGiNF, RET
Extract C as symbol information.

The obtained symbol information is written into the analysis data storage memory 17.

Figure 6f shows the contents of "symbol information linkage J (62). In this, the parsed data is read and (
75), Select variable name whose attribute is subroutine (76)
), for example, CALL 5GFCT(-・-...)
Select 5GFCT. Next, select a variable that is not registered in the test data component and for which symbol information has been generated (77), and merge the symbol information corresponding to the selected variable with your own symbol information (78). )
.

FIG. 6h shows symbol information obtained by performing the above processing to generate debug data for the source program (FIGS. 5a and 5b).

FIG. 6g shows the contents of "Test Data Generation J (63). In this step, test data is first generated from symbol information and test data parts.

In other words, first search for a test data component that matches the test data generation category name described in the symbol information (79), and then subdivide and search for the test data to be generated based on the argument name described in the symbol information (SO). , retrieve the searched test data (81). As a result, the test data shown in FIG. 61 is automatically generated for the source programs shown in FIGS. 5a and 5b.

Next, create symbol information in the order of syntax (82), create test data in the order of syntax, rearrange the test data according to the test data writing rules (84), and if there is multiple identical test data. If so, select one (85
). Through the above steps, the final debug data shown in 6j is obtained. This debug data is written in the debug data storage memory 21. When registering this in the debug data storage memory 23, the operator:
rl of the selection menu 64 appearing in the corner of the screen during test data generation (63: Fig. 6a).

"Register" and enter the debug data storage memory 23.
Register.

As described above, when a source program to be verified is given, the syntax of the source program is analyzed and symbol information is generated based on the analysis data.

Then, the test data corresponding to the component included in the symbol information is read out from the test data component information memory 19, expanded, and written into the debug data memory 21. As a result, debug data of the source program to be verified is obtained in the debug data memory 21.

Therefore, the operator's input operation for creating debug data does not take much time, and input errors are reduced.

For example, by extracting test data for all program parts such as tables/files and subroutines that are subject to verification in various programs from existing debug data,
If there is no corresponding item, create a new one and store it in the test data component information memory means in advance.
As described above, debug data is automatically generated and registered in the debug data memory means.

As mentioned above, by storing all standardized test data (information required for debugging) in the test data component information memory means, debug data for each source program can be automatically generated with simple operations by the operator. be done. The number of operations required by the operator is reduced to about 172 compared to conventional coding input. In this way, the amount of operator operations is reduced, and there is virtually no need for human labor to search for and extract required test data (debug data parts) from ready-made debug data and to edit the debug data that is being created. The labor time and expense required to create debug data is greatly reduced, and since the test data (debug data parts) in the debug data are already ready-made, the debug data can be used to store input errors caused by input errors during creation. Reduces the possibility of containing errors.

Next, FIG. 7a shows an outline of the contents of "3. Conversion" (2 in FIG. 2a), which performs the process of changing the source program. These processes are performed by the related information extraction program 35. shown in FIG. Conversion rule registration program 38. Conversion main part extraction progera 1140, modification/editing program 42
．． This is executed by the conversion inspection program 44 and the conversion result confirmation list output program 46.

FIG. 7b shows the processing operations of the operator and computer 1 when performing ``transferring program information'' in ``3. Conversion.'' ``When porting program information, the operator inputs the replacement rule data using the keyboard 101 (PI), and after completing this, the operator prints out the replace rule data and checks the rule data for errors. If so, correct it (P2, P3). After completing the error check, register the replacement rule data in the memory 39 (
P5). When the operator inputs a porting conversion instruction, the computer 1 sequentially retrieves one program at a time from the pre-porting program A specified manually with the key (P6), and extracts the replacement rule data group registered in the memory 39 and specified manually with the key. Extract the changed parts and store the changed parts in memory 4
1 (P7), convert the changed part (P8), port and convert program B, verify the error, display the error, and in response, the operator corrects the error,
Write program B to memory 11 (P10). Then, add the verification results to the relevant part of program B,
Program A before porting and program B after porting conversion are edited so that they can be compared on a card-by-card basis.
Print out (pH,). Note that the replacement rule data is registered in the memory 39 in the same manner as the standardization rule registration described above.

FIG. 7b shows the contents of the source program change process when "3. Conversion" is specified. When "3. Conversion" is specified, the central computer 1 displays a menu (not shown) for specifying the contents of "3. Conversion J" on the CRT display 115 via the input/output control program 4.Contents of the menu The items are "1. Related information list", r2. Conversion rule input J, r3. Conversion part extraction J, r4. Program automatic change J, r5. Conversion verification J and r6. Confirmation list output”.

The operator specifies "1. Related information list", enters the name of the source program to be changed (in the case of porting, before porting), and enters the related information (change information: in the case of porting, the replacement rule information group specification code). Then, the central computer 1 starts the relational information extraction program 35 via the input/output control program 4, analyzes the change information (language to be changed) of the source program to be changed (before porting), and analyzes the change information (language to be changed) of the source program to be changed (before porting). 8
6) Restore the change information of the specified source program and the reference information to which the change information is referenced and register them in the related information extraction data storage memory 37 (87). An example of the restored cross-reference list is shown in Section 8a.
As shown in the figure.

When the operator specifies "2. Conversion rule manual",
The central computer 1 starts the conversion rule program 38 via the input/output control program 4 and registers the operator's conversion rule input in the rule data storage memory 39 (8
8). FIG. 8b shows an example of a conversion rule used for conversion for porting.

When the operator specifies "3. Extract conversion part", the central computer 1 starts the conversion main part extraction program 40 via the input/output control program 4, and extracts the change target of the target source program according to the conversion rules. Search for the location, restore it to the extraction list, and store it in the extraction data storage memory 41.
Register (89).

When the operator specifies "4. Program automatic change", the central computer 1 starts the modification/editing program 42 via the input/output control program 4, and changes the information of the changed source program based on the extraction results and conversion rules. Modify (90). This content is shown in more detail in FIGS. 7c and 7d.

Next, when the operator specifies "5. Conversion Verification" and inputs a verification rule (91), the central computer performs conversion from the modified (post-ported) source program and the conversion rules based on the conversion inspection program. Verify the results, restore the verification results, and display them on the CRT display 11.
5 and prints out when there is a print instruction (92).

An example of the verification result is shown in FIG. 8c. The operator specifies "4. Program automatic change" in response to the change error, starts the correction/collection program 2, and corrects the error.

Next, when the operator specifies "6. Output confirmation list" and inputs the format settings for each program card and instructs execution, the computer 1 outputs the pre-transfer (previous) program information from the first program card. , the extraction results, the ported (new) program information, and the verification results are edited into a confirmation list, displayed on the CRT display 11.5, and printed out by the printer 122 when a print instruction is input.

When the next page is designated, similar processing is performed for the second program card (93). In figure 8d.

- shows an example of program cards. The operator is
From this program card, it is possible to check which information (language) at which location in the pre-transplant program A has been changed to which information in the post-transplant program B.

〔Effect of the invention〕

As described above, according to the computer program porting device of the present invention, about five key-in operations are required to change information (coding input) in one place when creating a porting source program by converting the language of the source program before porting. However, this has to be done for each changed part of the entire source program, but this can be done by inputting change information once for each change information (input for creating replacement rule information). In addition, searching for changed locations and making changes there virtually no longer requires human labor, which greatly reduces the labor and cost of conversion for porting, and the porting process is automatically generated and printed out. Therefore, a conversion error check can be easily performed based on this, and it is useful for later conversion error checks, program changes, corrections, or reverse conversions.

[Brief explanation of drawings]

FIG. 1 is a block diagram showing a general configuration of an embodiment of the present invention. Figure 2a, Figure 2b, Figure 2c, Figure 2d, Figure 2e,
2f, 2g, and 2h are flowcharts showing the processing operations of the central computer 1 shown in FIG. 1. FIG. 3a is a plan view showing an example of program creation specifications (contents to be processed by the program: items to be processed). Figure 3b is a plan view showing the contents of a source card created according to the specifications of Figure 3a. FIGS. 4a and 4b are plan views showing quasi-source programs developed by the central computer 1 from a source card. FIGS. 5a and 5b are plan views showing source programs in which the central computer I has optimized the quasi-source programs. Figures 6a, 6b, 6c, 6d, 6e,
Figures 6f and 6g show the central computer 1 shown in Figure 1.
3 is a flowchart showing the processing operation of FIG. FIG. 6h is a plan view showing symbol information extracted from the source program by the central computer l. FIG. 61 is a plan view showing semi-debug data automatically generated by the central computer 1 based on test data parts and symbol information. FIG. 6j is a plan view showing debug data obtained by formatting and optimizing semi-debug data. FIG. 7a-1 is a block diagram showing the source program addition and modification functions of the central computer 1 shown in FIG. 1. FIG. 78-2 is a flowchart showing an overview of the program porting process brought about by the functions of the central computer 1 and input operations by the operator. FIG. 7b is a flowchart showing the contents of the source program change process. FIGS. 7c and 7d are flowcharts showing the contents of the subroutine 90 shown in FIG. 7b. FIGS. 8a, 8c, and 8d are plan views illustrating data automatically generated by the central computer 1 shown in FIG. 1 in the source program change process. FIG. 8b is a plan view showing an example of a change rule input by an operator for changing a source program. 1: Central computer (change part extraction means, change part conversion means, conversion verification means, conversion confirmation information creation means) 11: Source program storage memory (pre-porting program memory means, porting program memory means) 39: Rule data storage memory ( Replacement rules memory means) 41: Extraction data storage memory (extraction result memory means) 45: Inspection data storage memory (verification result memory means) 101: Keyboard (keyboard, position indication means)
115: CRT display (two-dimensional display means) 122
: Printer (printing means) East 2e Figure 2d Figure 6b Figure East 6C Figure 6gb Figure ne Category Language Category 1 creation/update/history etc. Data specifications, type, length ate) Symbol record record 1 < No o . Record No. No. EY Records No. Record No. -To N○. und) East 60 Figure 1

Claims (1)

[Scope of Claims] Two-dimensional display means; a keyboard comprising a plurality of information input keys; a position indication means for specifying a display input position on the display surface of the two-dimensional display means; information input with the input keys Replacement convention memory means storing corresponding replacement convention information: Pre-transportation program memory means storing program information to be ported; Pre-transportation program information is read from the pre-transportation program memory means and changes are made for porting according to the replacement convention information. A changed part extracting means for extracting the part and writing it into the extraction result memory means; reading the changed part from the extraction result memory means, reading replacement rule information from the replacement rule memory means, and converting the changed part of the pre-porting program information according to the replace rule. After that, the changed part conversion means writes the changed part conversion means into the transplanted program memory means; reads the transplanted program information from the transplanted program memory means, reads the replacement rule information from the replacement rule memory means, and verifies and verifies the validity of the conversion by the changed part converting means. Conversion verification means for writing into the result memory means; and reading out the pre-transplant program information, the transplant program information, the extraction locations, and the verification results from each of the memory means, edits them into a format that shows the process of porting, and sends them to the printing means for printing. A computer program porting device comprising: conversion confirmation information creation means;