JPH09292985A - Program-reusing parts generating method - Google Patents

Abstract

PROBLEM TO BE SOLVED: To make the software developing operation efficient by preparing/ providing a program recycling parts of a simple structure. SOLUTION: An existent program is inputted (201), design information is extracted with data in a center (202), and operator inputs a data item desired to make a part (203), and operation and restriction condition is organized and integrated concerning design information on the data item to prepare data parts which can be recycled (204). Next, a data item related with the data component is extracted (205), data parts are prepared similarly concerning corresponding design information and this is repeated concerning all the related data items (206). Finally, plural data parts related to job processing are collected to produce reusable job parts (207).

Description

Detailed Description of the Invention

[0001]

BACKGROUND OF THE INVENTION 1. Field of the Invention The present invention relates to the field of computer software development, and in particular, reusable component generation based on data from an existing program for supporting the efficiency of software reconstruction and new software development work. Regarding the method.

[0002]

2. Description of the Related Art Conventionally, as a method for extracting design information mainly from data from an existing program, for example, Japanese Patent Laid-Open No.
There is known a method of extracting program logic using a binary object described in Japanese Patent Publication No. 214772. Here, each transaction of the existing program is decomposed into individual data elements, and the decomposed data elements are expressed by a pair of data elements (binary objects), whereby complicated design information in the existing program is obtained. It describes a method of extracting data in a data unit and further organizing the extracted design information so that it can be reused to improve the efficiency of the work of generating a new program structure.

[0003]

In the above-mentioned conventional technique, attention is paid to the data of the existing program, and only the design information of the program regarding each data is extracted and the extracted information is directly reused. However, in the program design information extraction stage, multiple operations and multiple constraints related to each data are extracted. There was a problem that the efficiency of did not go well.

The object of the present invention is to improve the efficiency by organizing the relationship between a plurality of operations and a plurality of constraints extracted from an existing program, and creating / providing a reusable component in a data unit or a plurality of data units related in business processing. It is to be able to carry out general software development work.

[0005]

In order to achieve the object of the present invention, according to the present invention, if design information is extracted mainly from data from an existing program, the operation / constraint condition for each data is re-created in data units. A usage component is created, and further, a business component is created that summarizes the operation / constraint conditions of data related to the business processing, and this information is provided to the worker.

[0006]

BEST MODE FOR CARRYING OUT THE INVENTION An embodiment of the present invention will be described in detail below with reference to the drawings. FIG. 1 is a block diagram showing a system configuration for implementing a program reuse component generation method according to the present invention. In FIG. 1, 101 is a central processing unit (CPU) having a sequential processing function based on a program.
In this case, the execution of the processing procedure shown in FIG. 2 is controlled. 1
Reference numeral 02 denotes an interactive terminal having a keyboard, a mouse and a display screen, which is used by an operator who uses this system to input information necessary for instructions and analysis. Reference numeral 103 denotes a main memory that stores a program for realizing the processing procedure of FIG. Reference numeral 104 is a file that stores an existing program that is a target for program reuse component generation. Reference numeral 105 is a file in which program design information extracted by analyzing an existing program is stored. A file 106 stores the created program reuse parts (data parts, business parts).

FIG. 2 is a flow chart showing the processing procedure of an embodiment of the program reuse component generating method of the present invention. The processing procedure will be described below in detail with reference to the flowchart of FIG. 2 based on a specific example. In the specific example,
An example program for the COBOL language is shown.

First, the CPU 101 inputs an existing program to be analyzed from the existing program file 104 (step 201). Here, the existing programs to be analyzed are shown in FIGS.

In FIG. 3, the program ID is "MAINO1".
Is the main program of. In FIG. 4, the program ID called in the statement 306 of the main program in FIG.
In FIG. 5, the program ID called in the statement 307 is “HANBAI10”.
20 "subprogram. 6 is a subprogram whose program ID is "SHOHIN00" called by the statement 303 of the main program of FIG.
Is a subprogram with a program ID “SHOHIN01” which is also called in the statement 304.

Next, the CPU 1 extracts program design information centered on data (data items, operation target data, etc.) from the input existing program to be analyzed (step 202). This includes, for example, JP-A-6-21477.
It is convenient to apply the method of extracting program logic using the binary object shown in Japanese Patent Publication No. Of course, it is not necessary to limit to this extraction method.

FIG. 8 shows a data item "HANBAI-KI" extracted from the programs shown in FIGS.
9 shows an example of program design information for N (sales amount). In the figure, 802 is "HAN" of FIG.
"HANBAI-KIN" in the "BAI10" program
Is a formula (data operation unit) 402 for calculating
01, the expression 402 is executed such that the condition (constraint condition part) 301 in the “MAIN01” program in FIG. 3 is true, the condition 305 is true, and the condition 401 in the “HANBAI10” program in FIG. 4 is true. It is a summary of the constraints for Similarly, 804 is an equation 403 for calculating “HANBAI-KIN” in the program of FIG. 4, and 803 is condition 301 in the program of FIG. 3 is true, condition 305 is true, and the program of FIG. The condition 401 is false (displayed as a logical expression opposite to the true condition),
The constraint conditions for executing the expression 403 are summarized. Further, 806 is “HANBAI2 in FIG.
0 is a formula 502 for calculating “HANBAI-KIN” in the program, and 805 is condition 301 in the program of FIG. 3 is true, condition 305 is false, condition 501 in the program of FIG. Of the constraint conditions for executing the expression 502. Similarly, 808
5 is an expression 503 for calculating “HANBAI-KIN” in the program of FIG. 5, and 807 is condition 501 in the program of FIG. 3 is true, condition 305 is false, condition 501 in the program of FIG. Is a collection of constraint conditions for executing the expression 503 such as false.

FIG. 9 shows a data item "SHOHIN-KI" extracted from the programs shown in FIGS.
7 shows an example of program design information for N (commodity price). In the figure, 902 is "SHO" of FIG.
"SHOHIN-KIN" in the "HIN00" program
Is an expression (data operation unit) 602 for calculating
01 is because the condition 602 in the “MAIN01” program in FIG. 3 is true, the condition 302 is true, the condition 302 is true, and the condition 601 in the “SHOHIN00” program in FIG. 6 is true. It is a summary of the constraint conditions of. Similarly, 904 is an expression 6 for calculating "SHOHIN-KIN" in the program of FIG.
03 and 903 are conditions 30 in the program of FIG.
1 is true, condition 302 is true, condition 6 in the program of Figure 6
The constraint conditions for executing the expression 603, such as 01 is false, are summarized. Further, 906 is “S
"SHOHIN-KI" in the "HOHIN01" program
3 is an equation 702 for calculating “N”, and 905 is shown in FIG.
The conditions in the program are true, the condition 302 is false, the condition 701 in the program of FIG. 7 is true, and the constraint conditions for executing the expression 702 are summarized. 908
Is a formula 703 for calculating “SHOHIN−KIN” in the program of FIG. 7, and 907 is a condition 701 in the program of FIG. 7, a condition 301 in the program of FIG. 3 is true, a condition 302 is false. Is a set of constraint conditions for executing the expression 703 such as false.

In this way, each program design information extracted by focusing on the data (data items in this embodiment) from the existing program to be analyzed is accumulated in the program design information file 105.

Next, when the operator inputs a data item to be made into a component from the interactive terminal 102 (step 203), C
The PU 101 reads the program design information for the input data item from the program design information file 105 and creates a data component for the data item (step 204). Further, the CPU 101 extracts a data item related to the data component (step 205), similarly reads out the program design information for the data item from the program design information file 105 and creates a corresponding data component. Repeat this for all relevant data items (step 20).
6). Here, from the interactive terminal 102, “HANBAI-
Assuming that "KIN (sales amount)" has been input, the creation of data parts related thereto will be described.

When "HANBAI-KIN (sales amount)" is input as a data item to be made into a component, the CPU 101 first reads from the program design information file 105 the program design information for "HANBAI-KIN" (here, in FIG. (8 information) is read out, and the data operation unit / restriction condition unit is organized and integrated to create a data component for calculating the sales amount.

FIG. 10 shows an example of data parts for calculating "HANBAI-KIN (sales amount)" created by the program design information of FIG. The program design information is organized in the order of "constraint of the same expression", "constraint common to each expression", and "consecutive constraint (true / false relationship)".
In the example of FIG. 8, since there is no same expression, the constraint condition common to each expression is first extracted. As a result, "SYORI-KBN
(Processing category) = '1''is bundled as an overall constraint condition (1001). Next, the constraint condition “KEIYAKU-NEN> = 10” common to the equations 802 and 804.
And the constraint condition “KEIY” common to the expressions 806 and 808.
Organize AKU-NEN <10 (1002).
Further, since these two constraint conditions are “reciprocal constraints (true / false relationship)”, here, the constraint condition 1002
Branch processing (THEN and ELSE). In the next layer, “SHOHIN-KIN> = 1000
000 ”and“ SHOHIN-KIN <100,000 ”
Since “0” is a “conflicting constraint (true / false relationship)”, the branching process of the constraint conditions 1003 and 1006 is performed here as well. After organizing the constraints in this way,
Each expression 802, 804, 806, 808 is arranged under the extracted conditions (1004, 1005, 1007, 100
8), the sales amount calculation data part of FIG. 10 is completed.

Next, the CPU 101 determines "SHOHIN-KI" as a data item related to the data part of FIG.
“N (commodity price)” is extracted, the program design information (here, the information of FIG. 9) corresponding to “SHOHIN-KIN” is read from the program design information file 105, and in the same manner, a data component for calculating the commodity price. To create.

FIG. 11 shows an example of data parts for calculating "SHOHIN-KIN (sales amount)" created by the program design information of FIG. First, the constraint conditions for the equations 902 and 906 and the equations 904 and 908, which are the same equations, will be summarized. The restriction method is performed in the order shown above. In FIG. 11, 1101 is extracted as a constraint condition common to all expressions, and the remaining constraint conditions are different from Expression 1.
Since 103 and 1104 are “conflicting constraints”, the true / false (T
HEN / ELSE relationship). Expressions 902 and 906 are arranged as Expression 1103, and Expressions 904 and 908 are arranged as Expression 1104.

The above processing is repeated to create all related data parts and store them in the reusable part information file 106 as reusable part information.

Next, the CPU 101 reads out the data parts from the reusable parts information file 106 and collects the related data parts in the business processing to create the business parts (step 207). In creating this business part, related data parts are sequentially added from the data item designated by the worker.

FIG. 12 shows an example of a sales price calculation business component created from the data components of FIGS. In creating the business component, the constraint condition “SYORI-KBN” common in the data components of FIGS. 10 and 11 is used.
(Processing category) "1001, 1101 are grouped (120
1) From the execution order of each data component (in this example, the order in which the product price must be calculated before calculating the sales price), the data component (1
202), the data component for calculating the sales amount of FIG.
Arrange in the order of 3).

The business component thus created is stored in the reusable component information file 106 as the reusable component information at a later date, like the previous data component.

In the flowchart of FIG. 2, step 203 and step 204 may be performed in reverse order. In this case, in extracting the program design information, it is only necessary to extract the design information related to the data item desired by the operator to be made into a component from the existing program.

[0024]

According to the present invention, reusable design information extracted from an existing program is organized, and a reusable component having a simple program structure of a data unit or a plurality of data units related to business processing is provided. Is possible,
You will be able to perform efficient software development work.

[Brief description of drawings]

FIG. 1 is a block diagram showing a system configuration for implementing a program reuse component generation method of the present invention.

FIG. 2 is a flowchart showing a processing procedure of an embodiment of the method of the present invention.

FIG. 3 is a specific example of an existing main program to be analyzed.

FIG. 4 is a specific example of an existing subprogram to be analyzed.

FIG. 5 is a specific example of an existing subprogram to be analyzed.

FIG. 6 is a specific example of an existing subprogram to be analyzed.

FIG. 7 is a specific example of an existing subprogram to be analyzed.

8 is an example of program design information extracted from the analysis target programs of FIGS. 3, 4, and 5. FIG.

9 is an example of program design information extracted from the analysis target program of FIGS. 3, 6, and 7. FIG.

10 is an example of reusable data parts created by the program design information example of FIG. 8;

FIG. 11 is an example of reusable data parts created by the program design information example of FIG. 9;

FIG. 12 is an example of a reusable business component created by the data component examples of FIGS. 10 and 11;

[Explanation of symbols]

 101 CPU 102 Interactive Terminal 103 Main Memory 104 Existing Program Storage File 105 Program Design Information Storage File 106 Reusable Parts Storage File

Claims (2)

[Claims] 1. Reusable parts for each data unit, by extracting program design information mainly from data from an existing program, reorganizing and reconstructing operation / constraint conditions for each data in the extracted program design information. A method for generating a program reuse component, the method comprising: 2. The program reusable component generating method according to claim 1, wherein the reusable components of the generated data unit collectively generate the business components related to the business processing. Reusable parts generation method.