JPH03144730A - Device for supporting reuse of program parts - Google Patents

Abstract

PURPOSE:To improve the reusability of program parts by converting source programs available for parameters out of plural source programs into parameters and registering the parameters in a data base. CONSTITUTION:A parameter candidate extracting means 1 decides parameter candidates available for parameters such as arguments, macros, constants, local variables, and I/O input variables existing in a formed source program based upon a previously set decision reference and sends the parameter candidate to a parameter processing means 2. The means 2 displays the applied parameter candidate on a display means 5, inquires of a user whether the candidate can be converted into a parameter or not, and when the user decides the formation of the parameter, substitutes a parameter for the parameter candidate in the source program to execute parameter processing, and requests a comment for explaining the contents of the parameter to form a parameter list. Consequently, the reusable range of the program parts is expanded.

Description

DETAILED DESCRIPTION OF THE INVENTION A. Field of Industrial Application This invention relates to a technique for reusing source program components written, for example, in the C language.

B. Prior Art] In order to improve work efficiency when creating a computer program, a method is adopted in which reusable program parts (modules) are used from previously created programs.

Conventionally, source programs created by individual programmers are registered in a database as is, and when a person creating a new program reuses parts from a previously created program, It reads programs registered in a database and extracts parts that can be reused.

Problems to be Solved by the C0 Invention However, the above-mentioned conventional technology has the following problems.

Each program created by a programmer has a different purpose. For example, if a program is created to produce an answer after repeating a certain arithmetic operation five times, the number of repetitions will be set as a constant and stored in the data file as programmed. be registered. However, when creating a new program with the purpose of repeating the above arithmetic operation 10 times to derive the answer, if the same number of repetitions is parameterized as an input argument that determines the function of the program, then the target value can be set in that parameter. It is possible to reuse simply by assigning the number of times, but in the past, because it was programmed as a constant, it could not be reused in its original form, reducing the reusability of program parts. There is a problem.

If you want to reuse a source program registered in the data cache in such a state, read and analyze the registered program one by one, extract constants that can be treated as parameters, and then parameterize them. It took a lot of effort to reuse it.

This invention has been made in view of the above circumstances, and it is possible to improve the reusability of program parts by parameterizing parts of a source program that can be parameterized and then registering them in a data directory. The purpose of this project is to provide a device that supports the reuse of program components.

01 Means for Solving the Problems The present invention has the following configuration to achieve the above object.

That is, the program component reuse support device according to the present invention uses preset criteria to determine variables, constants, etc. that may be parameterized as input arguments that determine program functions in a created source program. a parameterization candidate extracting means for extracting parameterization candidates based on the parameterization, and displaying the extracted parameterization candidates on a display means to ask the user about the possibility of parameterization, and if there is a possibility, parameterization for the source program. a parameterization processing unit that executes processing and creates a list of parameters; a storage unit that stores a parameterized source program; and a document creation unit that creates a parameter document based on the parameter list. It is characterized by having the following.

E5 Effect According to the present invention, the parameterization candidate extracting means extracts in advance parameterization candidates that may be parameterized, such as arguments, macros, constants, local variables, I10 human variables, etc., existing in the created source program. The determination is made based on the set determination criteria, and the parameterization candidates are sent to the parameterization processing means. The parameterization processing means is
Display the given parameterization candidate on the display means,
If the user determines that it can be parameterized, the parameterization process is performed by replacing the parameterization candidate in the source program with the parameter, and the user is informed of the parameter. Create a parameter list by requesting descriptive comments. The parameterized source program is stored in the storage means, and the parameter list is sent to the document creation means. The document creation means creates a document explaining the contents of the parameters based on the parameter list. When creating a new program, the existence of program parts that can be reused is checked by referring to the parameter document, and the program parts are retrieved from the source program stored in the storage means to be reused. can do.

F9 example Embodiments of the present invention will be described below based on the drawings.

FIG. 1 is a block diagram schematically showing the configuration of an embodiment of the present invention.

A source program created by a programmer is sent to a parameterization candidate extracting unit l serving as a parameterization candidate extracting means. The parameterization candidate extracting unit l performs a grammar analysis of a given source program and extracts parameterization candidates.

The term "parameter" used here refers to the parameters that are passed during the construction of a C language program, that is, the manual arguments that determine the function of the program, which are called arguments. , Parameterization candidates refer to those that can potentially be parameterized as the manual argument.

The parameterization candidate extraction unit 1 extracts source program programs that are likely to be modified according to the following criteria.

■During a macro program, for example, $defin 1ook
The character string ook that follows #defin, which is written as 10, is called a macro, and it instructs to replace 1ook with IO when compiling.
By putting the r:i tank number of the program after ook, it can be reused in other programs, so it is extracted as a candidate for parameterization.

■Input arguments Among the arguments defined in the program,
It determines and extracts the arguments used as input. For example, variables a and b that exist on the right side of the assignment statement x=a+b are determined to be input arguments and are extracted as candidates for parameterization.

■Constants Some of the constants defined in the program include those that can be reused as variations.
Extract as a candidate for parameterization.

■Local variables Refers to variables that are valid only within one function, and among them, those to which a constant is assigned only once are extracted as parameterization candidates. A local variable to which a constant has been assigned only once is used as a constant, so it is extracted as having a possibility of being reused, similar to (■).

■I10 input variables Read variables from outside (for example, user) I10
Among the variables read by the input function, for example,
Similar to ■, those on the right side of the assignment statement are determined to be manual arguments, and are extracted as candidates for parameterization.

When the parameterization candidate extraction unit 1 extracts parameterization candidates based on the criteria described above, it creates a parameterization candidate list and sends it to the parameterization processing unit 2 as a parameterization processing means together with the source code.

The parameterization processing unit 2 asks the user whether parameterization is possible for the given parameterization candidate according to the flowchart shown in FIG. 2, and if possible,
Make changes to the source code due to parameterization.

Step Sl: Determine whether or not there are any parameterization candidates remaining in the parameterization candidate list. If there are, proceed to the next step S2.

Step S2: Extract the remaining parameterization candidates one by one.

Step S3: Determine the shape of the retrieved parameterization candidate, and if it is an input argument, macro, local variable, or I10 input argument, proceed to Steps S4, S7, or S11, respectively; if it is a constant, proceed to Step 515. ) ■If it is determined that it is a human argument, perform the following processing.

Step Sl Displays on the CRT monitor 5 and asks the user whether the retrieved manual argument can be parameterized.
If the user inputs via the keyboard 6 that parameterization is not possible, the process returns to step S1; if the user manually inputs that parameterization is possible, step S5 to step S
Proceed to step 6 to collect information for creating parameter documentation.

Step S5: Extract the data type of the input argument from the source code and write it to the parameter list.

Step S6: Request a comment from the user via the CRT monitor 5 as to what role the input argument plays. A comment entered by the user is written in the parameter list.

The process related to the manual argument is now finished, and the process proceeds to step Sl, where the next parameterization candidate is searched ■Step S3
The parameterization candidates determined by are macros. If is a local variable, in steps S7 to S9, the same processing as in steps S4 to S6 above is performed, and the process proceeds to step 310. However, in the case of a macro,
Since the data type is not written in the source code, the data type written after the macro variable, i.e. inL type for integers, float type for real numbers, c for strings.
Write the har type to the parameter list.

Step S10: In the source code, following the function (・
...), add a macro or local variable as an input argument. After making such changes to the source code, the process returns to step S1.

■The parameterization candidate determined in step S3 is 110.
If it is a human variable, step Sll to step S
In step S12, the same processing as in steps S4 and S5 described above is performed, and the process proceeds to step S13.

Step 7 S13: The I10 input section is programmed differently depending on the type, etc., so the way to change the source code may differ depending on the user.
The user is requested to change the source code via the RT monitor 5.

Step S8: 110 Requests the user for an explanatory text such as what role the human variable plays, writes it in the parameter list, and then executes the process of step SIO.

(2) If the parameterization candidate determined in step S3 is a constant, the process advances to step S15.

Step S15: Since the same numerical value may be used elsewhere, it is determined whether the read numerical value has already been parameterized. If the value is different from the previously parameterized value, the process proceeds to step S19, and if the value is the same, the process proceeds to step S16.

Step S16: Among the rose makeup that has already been created,
Constants having the same value are displayed on the CRT monitor 5.

Step S17 The user is asked whether the parameter is the same as the parameter declared in the F parameter list. If it is the same, the process proceeds to step S1B and the constant in source code 7 is replaced with the parameter. If the user determines that the parameter is different from the previously declared parameter, the process advances to step S19.

Step S19: Ask the user whether the extracted constant can be parameterized, and if the user interrupts that it cannot be parameterized, return to step S1, and if it is determined that parameterization is possible, proceed to step 520.

Step S20: Request the user what variable name to declare the constant.

Step S21: Replace constants in source code 5 with their variable names.

Thereafter, the processes from step S7 to step 510 are performed, and the variable name is added to the source code as a manual argument.

In this way, the user is asked whether the extracted parameterization candidates can be parameterized, and among those that can be parameterized, for those other than the I10 input variable, the source code is automatically replaced with the parameter, and the storage device At the same time, information for creating a document explaining the parameters is written in a parameter list, and the parameter list is sent to the document creation section 3 as a document creation means.

The document creation unit 3 documents and stores the given parameter list, and outputs it as a printed matter from a printer (not shown) to the outside as necessary.

When creating a new program, refer to the parameter document created by the document creation section 3 to check whether any parts that can be reused as parameters are registered in the program parts database 4.
If there is a part that can be reused, it is read out from the program parts database 4 and reused.

In addition, by substituting numerical values such as constants before parameterization into the modified source code registered in the program part data file 4, and executing the program, it is possible to check whether it executes normally. , a component that can inspect the reliability of the modified source code registered in the program component database 4 may be added.

Effects of the G9 Invention As is clear from the above explanation, the program component reuse support device according to the present invention has the possibility of parameterizing the generated source n-gram as a human argument that determines the function of the program component. By extracting variables, constants, etc. and performing parameterization processing on the source program, the program is stored in a storage medium, and a document explaining the contents of the parameters is created, making it easier to reuse program parts. You can expand your scope.

Further, by referring to the document, the programmer can easily understand the function of the program component, and therefore can quickly determine whether the program component can be reused.

[Brief explanation of the drawing]

FIG. 1 is a block diagram showing a schematic configuration of a program component reuse support device according to an embodiment of the present invention, and FIG. 2 is a flowchart illustrating the operation of a parameterization processing section. l...Parameterization candidate extraction unit 2...Parameterization processing unit 3...Document creation unit 4...Program component database 5...CRT monitor

Claims (1)

[Claims] (1) Parameterization candidate extraction means for extracting variables, constants, etc. that can potentially be parameterized as input arguments that determine the function of the program from the created source program based on preset criteria; Displaying the extracted parameterization candidates on a display means to ask the user about the possibility of parameterization, and if there is a possibility, execute parameterization processing on the source program and create a list of the parameters. A program component reproducing program component comprising: a parameterization processing unit that stores a parameterized source program, a storage unit that stores a parameterized source program, and a document creation unit that creates a parameter document based on the parameter list. Usage support device.