JPH05289862A - Program maintenance supporting device - Google Patents

Abstract

PURPOSE:To mechanize such work as analysis, correction, improvement, etc., of a source code of an existing program. CONSTITUTION:A source code of an existing program is read in by a program reading-in part 21. The read-in source code is analyzed, based on fundamental specifications of used language by a program analyzing part 22. A result of this analysis is classified into attribute items, etc., stored as an intermediate data base in an intermediate store part 23, and also, the intermediate data base is reconstituted by a model generating part 24, and a program model PM is generated. By using this program model PM, a batch retrieval is executed by a batch retrieving part 31, and a retrieval is executed interactively by an interactive retrieving part 32, and the existing program is analyzed. In the case of correcting the program, the compatibility is decided by inputting temporarily the correction contents to a correction temporary input part 33, and in the case they are matched, a source code is corrected by a program correcting part 34.

Description

Detailed Description of the Invention

[0001]

BACKGROUND OF THE INVENTION 1. Field of the Invention The present invention relates to a program maintenance support device, and more particularly to software maintenance work such as analysis, modification and improvement of the source code of a general computer program written in an ordinary programming language. The present invention relates to a program maintenance support device that can be efficiently performed.

[0002]

2. Description of the Related Art There are the following techniques and technologies related to the maintenance of computer programs that have been conventionally used. Adopt standard programming techniques. Thoroughly maintain documents and comments. A human analyzes the program using the printed list of source code. Prints out the location of an error and related information when compiling or executing a program. The execution of the program is traced sequentially and the related information is printed out if necessary. Create and print out a list of functions and variables defined or used in the program. Using the above list as a database, a function for searching by the name of a function or variable is provided to print out or display the relevant part of the source code on demand.

[0003]

With respect to a computer program, various procedures may exist in order to obtain the same result. Therefore, especially when a person who maintains or improves the program is different from a designer. Processing in the program, functions,
One of the problems in maintenance is that it is difficult to understand the meaning of variables. Regarding this point, it is recommended to adopt standard programming techniques and thorough documentation (above), but in addition to concentrating effort on the program creation stage, existing programs and sequential programming called rapid prototyping are recommended. However, there is a problem that it cannot be applied when adopting various development techniques, and the problem has not been solved yet.

The most basic and widely used method for maintaining an existing program is to analyze a list (described above), but if the program is large, the types of functions and variables are It is difficult to understand how they change in the process because they are related in many and complicated ways, and this is also a maintenance problem. Although error information at the time of compiling a program and execution, output of trace information (above, etc.) is a means of dynamically analyzing the relationship between functions and variables, it is mainly used for debugging work and operates normally. It is not suitable for supporting work associated with program improvements and design changes.

On the other hand, a method of creating a list of functions and variables used in a program and utilizing the information as a database for maintenance (above) is based on a static analysis of the program structure. Basically, it is considered to be an effective means for program improvement and design change. However, in the conventional technology, the information mainly related to the grammatical analysis of the relationships between functions and variables is used, and the information related to the overall structure of the program is insufficient. Can be applied, but there was a problem that it could not exert sufficient effect on upstream work such as improved design and design change.

The present invention has been made in consideration of the above points, and is a program capable of mechanizing software maintenance work such as analysis, correction, and improvement of the source code of an existing program to improve work efficiency. An object is to provide a maintenance support device.

[0007]

The present invention, as means for achieving the above object, includes source code storage means for storing the source code of an existing program; the source code is divided into predetermined division units, and A program analysis unit that divides each division unit into processing units; an intermediate database that divides the content of the processing instructed by each processing unit by attribute item and creates an intermediate database by associating each attribute item with the value of the attribute item Creating means; intermediate database storing means for storing an intermediate database; model creating means for creating a program model by reconstructing the intermediate database by adding reference relationships between processing units; model storing means for storing a program model And; searching for the program model based on the conditions input from the input means, Search means for analyzing the RAM; output means for outputting the analysis result by the search means; correction program storage means for storing the correction program input from the input means; and the correction program against the contents of the program model. A modification program analysis / evaluation means for analyzing / evaluating the modification program; and a source code modification means for modifying the source code when the modification programs match, respectively.

[0008]

In the program maintenance support device according to the present invention, the program model is created by grammatically and structurally analyzing the contents of the existing program only from the source code. This program model is searched based on a predetermined condition and is output as the analysis result of the existing program.

On the other hand, when modifying the contents of the program, the modification program is first collated with the content of the program model, and the modification program is analyzed and evaluated. Then, when it is determined that they match, the source code is modified.

[0010]

DESCRIPTION OF THE PREFERRED EMBODIMENTS The present invention will be described below with reference to the drawings.

FIG. 1 is an overall configuration diagram showing an example of a program maintenance support apparatus according to the present invention. This program maintenance support apparatus uses an ordinary programming language (for example, FO).
A source code storage unit 1 for storing the source code of a general computer program (original program) written in RTRAN or LISP, a program analysis unit 2, and an intermediate database creation unit 3 are provided.

The program analysis means 2 divides the source code into predetermined division units and also divides each division unit into processing units, and the intermediate database creating means 3 divides each processing. The contents of the process instructed by the unit are divided for each attribute item, and the value of the attribute item is associated with each attribute item to create an intermediate database. The created intermediate database is stored in the intermediate database storage means 4 and is reconstructed by the model creating means 5 to create a program model.

That is, the model creating means 5 is adapted to add the reference relationships among the processing units to reconfigure the intermediate database and create a program model based only on the source code. The model is stored in the model storage means 6.

On the other hand, a predetermined condition is inputted from the input means 7 shown in FIG. 1 to the search means 8. The search means 8 searches the program model based on this condition, It is designed to analyze programs. The analysis result is output to the output means 9.

A correction program is also input from the input means 7, and the correction program is stored in the correction program storage means 10 as shown in FIG. Evaluation means 1
1, the contents of the program model are collated, and the correction program is analyzed and evaluated. When the correction programs match, the correction means 12 corrects the source code.

FIG. 2 is a functional block diagram in which the program maintenance support device shown in FIG. 1 is represented by functional blocks according to the flow of processing. This program maintenance support device is a model construction unit for constructing a program model PM. 20 and a model application unit 30 that applies the constructed model. The model construction unit 20 includes a program reading unit 2
1, a program analysis unit 22, an intermediate storage unit 23, and a model creation unit 24, and the model application unit 30 includes a collective search unit 31, a dialogue search unit 32, a correction temporary input unit 33, and a program correction unit 34. ..

The program reading unit 21 does not read the entire source code at once, but divides a program in various programming languages (hereinafter simply referred to as "language") (for example, subroutines and functions in FORTRAN, in LISP). It is designed to be read into the work area by a function, macro, etc., and the source code once read into the work area is further processed in the work area in each language (for example, a pair of “(” in LISP). ")", One statement in FORTRAN, etc.). Then, the source code read as text data is divided into basic processing units of the language used and then delivered to the program analysis unit 22.

The program analysis unit 22 is adapted to analyze each processing unit divided by the program reading unit 21 based on the basic specifications of the language used. As an actual procedure, each processing unit is first classified according to the function of the processing (for example, the type of assignment variable or declaration statement in FORTRAN, the function in LISP, etc.), and the arguments and options for each function. , Has been analyzed in detail such as the external functions used. Then, the analysis results obtained in this way are sequentially sent to the intermediate storage unit 23, arranged and stored together with necessary information.

The intermediate storage unit 23 is adapted to store the analysis results by classifying them into attribute items in the frame with names of the respective division units and further detailed items below the attribute items. What is stored here is a program such as a variable whose value has been changed, a variable whose value has not been changed, a function that has been called, a special control process that has been used, various statistical results, etc., in the corresponding division unit. This is essential information for maintenance of.

Further, the model creating section 24 collates the analysis information stored in each attribute item in the frame of the intermediate database generated by the processing up to now with each other, so that the functions and variables can be called. Relationships, loops, etc.
It is designed to extract information related to the structure of the original program. Furthermore, the relational information extracted in this way is
It is designed to add to the intermediate database as a tree or network relationship of existing frames and new frames created as needed.

In the present invention, the database in which the analysis result for each processing unit of the original program is arranged in the frame format and the information about the structure of the original program is newly added is called a "program model" in the present invention. It should be noted that the “model” here means a set of information which is composed of a large number of constituent elements having various internal data, and in which the constituent elements are associated with each other to represent one structure as a whole. In addition, this "program model"
Is a frame-structured database that stores the structure of the original program, the functions and variables used internally, and the relationships between functions and variables, and can be used and saved as an independent file.

Collective search section 31 of the model application section 30
Is configured to search for and output the information of the "program model" according to a given condition. However, unlike the interactive search unit 32 described later, the "program model" is searched based on the condition given collectively. Then, the result is output as a document. On the other hand, the dialogue retrieval unit 32 retrieves a "program model" based on a condition given interactively and sequentially outputs the result through a screen. With these functions, the user can freely search and analyze the contents of the existing program.

Further, in the temporary correction input section 33, the user first makes full use of the above-mentioned functions to fix the correction point of the program and the design change policy, and then inputs the concrete correction point and the correction content of the program. It is supposed to do. This input information is not directly used to modify the original program, but is first saved in the work area and then collated with the contents of the "program model" to check for errors in functions and variables or in the configuration of existing parts. The existence of inconsistencies has been confirmed. If any of the above problems are found in the tentatively entered corrections, the related information will be output, and at the same time, the tentatively entered corrections will be "unsuitable", and conversely no problems will be found. The mark "appropriate" is given. Further, as for the correction contents made "inappropriate", the contents can be removed from the work area or re-inputted as necessary. Further, the program modifying section 34 is adapted to modify the original program based on the modification contents temporarily input / confirmed in the previous process. Then, by the functions provided by the both units 33 and 34, the change or modification of the original program intended by the user is
Before being incorporated into the whole, it can be incorporated into the actual original program after confirming that there is no grammatical or structural error.

FIG. 3 shows the hardware configuration of the program maintenance support device shown in FIG. 2. This program maintenance support device includes a central processing unit 41 for processing, a keyboard 42 for data input / output, a mouse 43, It is composed of a CRT 44, a printer 45, an external storage device 46 such as a magnetic disk, and the like, and is realized by a basic computer (workstation) structure.

The program maintenance support apparatus does not necessarily have to be the same as the computer on which the target original program operates, but the source program of the original program must be able to read it as text data.

FIGS. 4 and 5 show the flow of processing in the model construction unit 20 and the model application unit 30 shown in FIG. 2, respectively. Hereinafter, referring to FIGS. 4 and 5,
The operation of both parts 20 and 30 will be described.

First, the model construction unit 20 reads the source code in units of division in step S1, and determines in step S2 whether or not all the source code has been read. If the processing has not been completed, the processing units are separated in step S3, the processing units are analyzed in step S4, stored as an intermediate database in step S5, and the process returns to step S3.

When it is judged in step S6 that the separation of the processing units is completed by repeating this, the process returns to step S1 to read the division units.

On the other hand, if it is determined in step S2 that all the source codes have been read, the intermediate database is read in step S7, information analysis is performed in step S8, information is organized in step S9, and finally in step S10. Reconfigure the intermediate database. As a result, the program model PM is created.

In the model application section 30, first, it is determined in step S11 whether it is a search or a correction, and if it is a search, in step S12 it is determined whether it is a batch or an interactive mode. Then, in the case of batch, step S13
While inputting the conditions in step S14, the search is executed in step S14, and the information of the result is output in step S15. On the other hand, in the interactive case, the condition is input in step S16, the search is executed in step S17, and the result is output to the screen or the like in step S18. Then, in step S19, it is determined whether or not the search is completed, and if the search is to be continued, the process returns to step S16.

When it is determined that the correction is made in step S11, the program correction section is temporarily input in step S20, and the correction section division units are combined in step S21.
In step S22, the correction unit division unit is analyzed. And
In step S23, a frame is created for each correction copy division unit.

In parallel with this, after rebuilding the original intermediate database in step S24, step S25
In step S26, the correction model is analyzed, the correction model is analyzed, and the correction content is evaluated in step S27. If they match, the source code is modified in step S28.

In the program modification shown in FIG. 5, the case where the entire division unit is input is shown, but only the specific processing unit is input, or only the specific variable or function is input to modify. It is also possible.

Next, the program maintenance support method according to the present invention will be described in detail by assuming two typical programs described in FORTRAN called a procedural language and LISP called a functional language. ..

FIG. 6 shows the structure of typical source code written in each of the aforementioned languages. First, the features of the program written in the language will be briefly described.

In FORTRAN, a single main program and arbitrary subroutines and functions are defined for one program. These main programs, subroutines, functions, etc. correspond to the program division unit read by the program reading unit 21 of the present invention in one processing. Furthermore, each of these division units basically consists of independent processing units (statements) for each line (line). When executing the FORTRAN program, first, the main program is unconditionally activated, and the processing units constituting the main program are sequentially executed. If another subroutine or function is used during the execution of a processing unit, execution proceeds to the corresponding subroutine or function, and when all the processing units in that subroutine are executed, the process of returning to the caller is repeated. Be done. This work is similarly performed for multiple nested structures, and when the end of the program executes the explicitly declared processing unit, or when the processing unit of the main program is executed to the end, the program Normal termination.

On the other hand, the LISP is defined in the form of independent functions or macro functions for all the processes, and this corresponds to a program division unit read in one process of the program reading unit 21 of the present invention. All processes in LISP are separated from each other by "blank", and as a whole, from an arbitrary number of character strings (function name, variable name, number, etc.) enclosed by a pair of "(" and ")". It is described by using an expression form called "S-expression" as a basic unit. The function definition itself is described in the form of "S-expression", but an arbitrary number of processing units are defined in the "S-expression". In addition, "S
Since the expression itself can return a value as a result of execution, another processing unit may be described as an argument of each processing unit to form a nested structure. When the LISP program is executed, the function name to be executed first is designated by the input from the user or some automatic mechanism. In the execution process of the function, defined processing units are sequentially executed, but when a processing unit having a nested structure or another function is encountered, the flow shifts to that processing unit. Finally, the program terminates normally when the termination of the program executes the explicitly declared processing unit or when the processing units of the invoked function have been executed to the end.

Next, taking the above-mentioned two types of typical programs as an example, the operation when applied to the program maintenance support method according to the present invention will be described. <Procedure 1> First, the program reading unit 21 functions to read the target source code as text data. As described above, the division unit read in one process is the main program or subroutine or function in the case of FORTRAN, and the function or macro function in the case of LISP. The range of these division units is "PROGRAM" ... "END" / "SUBRO" in FORTRAN.
"UTINE" ... "RETURN" / "FUNCTION"
N "..." RETURN ", in LISP" (DEFU
A combination of character strings or symbols such as "N" ... ")" / "(DEFMACRO" ... ")" can be determined as the identifier.
Further, in the process of reading the division unit and the range determination process, it is possible to determine the basic processing units constituting the division unit in parallel. The range in this case is FORTR
In the case of AN, if there is no line continuation declaration, line by line, LIS
In the case of P, the unit is “S formula”. Part of the source code read in this way (division unit name: X) is
It is divided into work variables T (X, i) [i: 1 to the number of processing units in X] and stored so that each processing unit can be extracted by the following procedure. A part of the source code once stored in the work variable T is sent to the program analysis unit 22 for each processing unit T (X, i), and procedure 2 / procedure 3 is repeated. <Procedure 2> In the program analysis unit 22, each processing unit T (X, i) is analyzed according to a criterion determined according to the grammar / syntax of the programming language of the original program. Various types of analysis criteria can be considered depending on the target language, the work range to be supported, the applied functions, and the like.
However, in most programs, the most important factor in maintaining them is the use of functions, variables, and instructions set by the programming language and operating system. Therefore, as the most basic analysis criteria, in this example, "function", "variable", "instruction"
The case of analyzing will be described below.

First, regarding the target processing unit T, the contents of the processing instructed by it are divided into "function definition", "variable definition", and "instruction execution", and the functions defined for each are Extract the variable or the name of the instruction used. Furthermore, regarding functions and variables, in addition to organizing the functions and variables used in the contents of their definitions (“used functions”, “used variables”),
Determine if a function, variable or another instruction is used as an argument and sort them out. In order to identify these "functions", "variables", "instructions" and their arguments, it is necessary to extract identification rules in advance based on the grammar of the language in which the target program is written. is there. The analysis result thus obtained is directly sent to the procedure 3. <Procedure 3> In the intermediate storage unit 23, the analysis results for each processing unit obtained in Procedure 2 are organized and sequentially stored in the frame format database. A frame for storing analysis data is created independently for each division unit read in step 1. In this example, the name of the frame is defined as X, which is the same as the name of the division unit. Further, in the frame X, various basic commands such as declarations, definitions, and controls that are grammatically defined in each programming language according to the above analysis items (for example,
For FORTRAN, COMMON, IF, DO, GOT
O ..., LISP DOLIST, CAR, CDR, S
ETQ ..., etc.) and the attribute item S corresponding to the variable whose value is newly defined or assigned in the division unit X.
Define (X, j) [j: sum of variables defined as instructions used in X]. In this example, the same names as the names of the commands and variables are used as the specific names of these attribute items. The attribute item thus defined is a unique number indicating the processing unit in which each instruction / variable is used / defined in the division unit X (i: FORTRAN of T (X, i): line number in the case of i: FORTRAN). , LISP) is stored. In addition, each processing unit T (X, i) normally uses other commands in it or uses functions or variables defined externally. , This is very important information for the maintenance of the program. Therefore, each attribute item S
In (X, j), as its value, information such as a position i where each instruction or variable is defined and a function, variable, or instruction outside X used or referenced in T (X, i) Also store. In this example, specifically, the location i is stored as the value of S (X, j), and the detailed item E (S, k) corresponding to an external function, an external variable, an external instruction, or the like is stored in S (X, j).
[K: External data type of interest] is defined, and the names of corresponding functions, variables, instructions, etc. are stored in them. As a result, with respect to the division unit X, information such as the type and location of the process executed therein and external items referred to in each process are all explicitly stored in each frame. The procedure 2 / procedure 3 is repeated until all the processing units in the division unit X read in the procedure 1 are analyzed. <Procedure 4> When the above Procedures 1 to 3 are all completed for the entire source code of the target program, the model creating unit 24 reconstructs the contents of the created intermediate database to create a “program model”. To create. The intermediate database immediately before this procedure has a flat structure in which the frames X (m) [m: total number of division units] for each division unit covering the entire original program exist independently of each other.
In the model creating section 24, first, the attribute item S of each frame X
And all detailed items E are searched, all data types defined and referenced in the division unit X are extracted, and new attribute items IN (X, k) and EX (X, k) [k: external reference of interest Data type, same as detailed item E ”is created and information is saved. All the attribute items IN of the frame X are searched again, and the frames and the functions and variables defined in the original program have the same names as F (n) [n: the total number of functions] and V (p) [p: the total number of variables, respectively. ], And stores in which division unit each function or variable is defined / redefined. Then, all the attribute items EX of the frame X are searched again, and for the items included in F and V, information on which division unit the function or variable is referred to is newly added to each frame F and V. Create and save. For those not included in F and V, new frames EF (q) [q: total number of functions] and EV (r) [r: number of variables] having the same names as the respective functions and variables are created. Saves information about in which unit a function or variable is referenced. As a result of these processes, new attribute items IN, EX and new frames F, V, EF, EV are added to the intermediate database, which has been configured as a set of mutually independent frames X as described above. Each frame X, F, V, EF, and EV of this new database explicitly contains information indicating a mutual reference relationship as an attribute item, and in this sense, this database represents a "model" that represents the structure of a program. ”(“ Program model ”). A configuration example of the "program model" is shown in FIG. <Procedure 5> The “program model” generated from the source code of the original program by the processing of steps 1 to 4 is
It can be managed as an independent data file together with the source code and used as needed. The present invention is
The purpose is to support the maintenance of the original program, and the specific contents of the support using this "program model" are the analysis of the source code and the actual modification. The work of these contents may be carried out as a series of work, but it is basically more efficient to realize it as a function that can be used independently as needed. The procedure described here provides a function of searching the source code analysis result of the original program stored in the above-mentioned “program model”, and the collective search unit 31 and the interactive search unit 32.
However, unlike steps 1 to 4, each of them basically functions independently. The batch search section 31 is a function that sets a search condition for a group as its name suggests, searches the entire program in a batch, and outputs the information. Basically, the output format is a batch method and printing is performed by a printer or the like. Output is the main subject. On the other hand, the interactive search unit 32 provides a function of interactively inputting a search condition and a search range and sequentially outputting the result. Due to such a sequential interactive method, a device such as a keyboard or a mouse is inevitably used as an input means through a display on a CRT screen, and a CRT screen and a printer or a hard copy is used as an output means.

As described above, the batch search unit 31 and the interactive search unit 32 both functionally search the contents of the "program model", although there is a difference in the above-mentioned method and the device configuration to be used. Are equivalent in that they provide information. Further, these functions are not limited to the contents of the "program model", and in particular, by tracing the reverse of the procedure 1, it is possible to instruct the relevant portion of the source code of the original program. Some specific examples of these functions and information that can be provided by using the "program model" and the source code are shown below. List of function names defined inside the program and function names defined outside The list of variable names defined inside the program and variable names defined outside The location of the specific function and its use List of function names and variable names that use specific functions Function names and variable names that use a specific function, list of used areas Function names and variable names that use a specific instruction or declaration, list of used areas Combination of conditions or list of locations where they occur <Procedure 6> Procedure 5 provides a function to search for "program model" independently, but Procedure 6 / Procedure 7 does not include source code that uses these functions. Based on the analysis, it provides the function to support the concrete program modification work after the improvement and modification policy and the design change content are fixed. The temporary correction input unit 33 supports the work at the stage where a person fixes the original part of the source code and the contents of the correction and specifically inputs a part of the program.

When broadly classified as modifications and additions,
It is possible to input the entire specific division unit, input only the specific processing unit, or input only the specific variable or function. When inputting the entire division unit, first enter the code into the work area via the keyboard as in a normal editor, and process it in the same way as the existing program division unit according to steps 1 to 3. Create an independent "divided unit frame". If this is added to the intermediate database of the original program and step 4 is executed, the same “program model” as when the correction is made is synthesized without actually inputting the corrected portion (temporary input state) into the original program. I can do things. Using this and procedure 5, it is possible to identify structural and grammatical problems when the correction part is input in advance.

Also when inputting only the processing unit, the entire division unit including the processing unit to be inserted, modified or deleted is extracted from the original program and stored in the work area, and a partial correction is made to this. By the same procedure as in the previous case, the entire “program model” including the temporary input part can be synthesized in advance. Although the intermediate database of the original program is used for these processes, the division unit frame X of the "program model" is extracted from the intermediate database of the original program, and the attribute items IN and E
It can be easily reproduced by removing X.

In addition to this, when only a specific function or variable is replaced, it is not necessary to resynthesize the "program model" including the temporary input part, and the original "program model" can be replaced with a new function or variable. The same effect can be obtained by searching the function or variable to be replaced.

By the above processing, the existence of a problem is examined in advance from the viewpoint of grammar and structure, and it is confirmed that there is no problem. Is added and saved, and the procedure is taken over to step 7. Other than that, it is possible to wait for confirmation processing while leaving it in the work area, or delete it from the work area if necessary. <Procedure 7> As described above, with respect to the temporary input part of the program modification, which has been confirmed in step 6 as to whether there is a grammatical or structural problem, the modified part and the modified content are stored in the work area. The program correction section 34 provides a function of actually correcting the source code based on this content. However, the present invention relates to the work of modifying the program,
Since it mainly provides grammatical or structural confirmation means for the correction contents, and does not verify the program's correction policy or the contents of design changes, it is possible to confirm the provisional input part as well. , It does not guarantee that the contents are correct. To prevent this, it is possible to protect the original program by copying the source code once to another file and then modifying the source code of the original program, instead of directly applying the temporarily entered modification. it can. In addition to this, a method of directly modifying the original program by saving the original program content modified by the modification content in the work area is also conceivable.

As described above, according to this embodiment, the following effects can be obtained.

A "program model" can be automatically created by grammatically and structurally analyzing the contents of the existing source code of the program.

By using the "program model", the contents can be collectively searched based on a predesignated condition and the result can be output. This output result can be used as an analysis document of the program.

It is possible to perform a search while interactively designating the contents as conditions using the "program model". By using this, it is possible to easily search the used part of the function or variable to be modified, the referenced internal or external function or variable, the range of influence, the structure of the program before and after it. it can.

With the analysis document created from the "program model" and the interactive source code analysis function, the maintenance and improvement of the program can be easily planned and studied. Conventionally, these tasks are manually performed by humans using the output source code list.

Temporarily input the contents of the planned program correction,
By using this to synthesize only the modified "program model" before changing the source code, the contents of the modification and the original source code are not syntactically and structurally inconsistent without changing the source code itself. Can be evaluated.

When a mismatch is found in the temporary input section, only this temporary input section can be repeatedly corrected and evaluated. As a result, when a large-scale program is modified, it is not necessary to test it by incorporating it into the whole in order to identify grammatical and structural problems of the partial modification, and the work is streamlined.

When a large number of small corrections are made, it is possible to check the existence of grammatical or structural problems in advance by means of the above-mentioned means for each correction point, and finally to incorporate them into the source code all together. Especially for large programs that take a long time to compile and link, you can enter dynamic tests after completing the grammar and structure in advance, and the efficiency of maintenance work can be improved.

In the above embodiment, the case where the source code is analyzed focusing on the reference relation between the functions and variables has been shown as the structure of the program. When focusing on a loop or branch of a flow, a declaration or instruction that defines the loop or branch is searched in the frame X and independent frames (for example, loop 1, loop 2, ..., Branch 1, branch 2, ... )Generate a,
It is also possible to store related information such as the loop range and branch destination as attribute items of the frame X.

Further, in the above-mentioned embodiment, as the "program model", only information relating to division units, functions, variables, etc. of the original program such as X, F, V, EF, EV is stored as a frame for use in analysis. Regarding the processing unit T, which has been described above, the method of not storing it has been described.
This is because the content of each processing unit corresponds to the source code, so that the location indicated by the processing unit T (X, i) (i of the division unit X is
This is because it is possible to extract from the separately stored source code file as needed. However, in addition to this, a method in which the processing unit T is directly stored in the “program model” together with X, F, V, EF, EV, etc. is also conceivable. In this case, the main body of the "program model" will be large, but the source code file will not be needed,
This increases the independence of the "program model", which is advantageous in file management. Further, there is an advantage in application in that the contents of the corresponding processing unit (contents of the code) can be immediately output from the analysis result obtained by searching the "program model". Further, if the "program model" incorporates all processing units, it is possible to synthesize the source code of the original program or the modification program as needed by collecting them. By using this, by managing the processing unit of the original program and the processing unit related to the modification respectively, it is effective in managing the source code of the program that has several different versions as a result of the change.

[0055]

As described above, according to the present invention,
The software maintenance work such as analysis, modification, and improvement of the source code of the existing program can be mechanized to improve the work efficiency.

[Brief description of drawings]

FIG. 1 is an overall configuration diagram showing an example of a program maintenance support device according to the present invention.

FIG. 2 is a functional block diagram in which the apparatus of FIG. 1 is represented by functional blocks according to a processing flow.

FIG. 3 is a hardware configuration diagram of the apparatus of FIG.

FIG. 4 is a flowchart showing the flow of processing in the model building unit in FIG.

5 is a flowchart showing the flow of processing in the model application unit of FIG.

FIG. 6 is an explanatory diagram showing a configuration example of a typical program.

FIG. 7 is an explanatory diagram showing the structure of a program model.

[Explanation of symbols]

 1 Source Code Storage Means 2 Program Analysis Means 3 Intermediate Database Creation Means 4 Intermediate Database Storage Means 5 Model Creation Means 6 Model Storage Means 7 Input Means 8 Search Means 9 Output Means 10 Correction Program Means Means 11 Correction Program Analysis / Evaluation Means 12 Sources Code correction means 20 Model construction unit 21 Program reading unit 22 Program analysis unit 23 Intermediate storage unit 24 Model creation unit 30 Model application unit 31 Batch search unit 32 Dialog search unit 33 Temporary correction input unit 34 Program correction unit

Claims (1)

[Claims] 1. Source code storage means for storing a source code of an existing program; program analysis means for dividing a source code into predetermined division units and each division unit into processing units; The contents of the process designated by the unit are divided according to attribute items, and an intermediate database creating unit that creates an intermediate database by associating each attribute item with a value of the attribute item; an intermediate database storing unit that stores the intermediate database; Reconfigure the intermediate database by adding reference relationships between units,
Model creating means for creating a program model; model storing means for storing the program model; retrieving means for retrieving the program model based on conditions input from the input means and analyzing the existing program; analysis by the retrieving means Output means for outputting the result; correction program storage means for storing the correction program input from the input means; correction program analysis for collating the correction program with the contents of the program model and analyzing / evaluating the correction program A program maintenance support device comprising: an evaluation unit; and a source code correction unit that corrects the source code when the correction programs match.