JPH0869380A - Source program check device - Google Patents

Abstract

PURPOSE: To automatically point out a problem on the performance of a source program by making a check item to check the source program into a pattern and comparing by collating an inputted source program with the check item. CONSTITUTION: A syntax text and name table generating part 110 generates a syntax text 120 and a name table 130 based on the inputted source program. A check part 140 performs check by referring to a check item accumulation part 150 from the syntax text 120 and the name table 130. Consequently, when coincident with the check item is obtained i.e., the content in a certain step in the source program is the one to be pointed out, message edit is performed by a message edit part 160. The edit part 160 starts up a correction routine 200 in accordance with a program number acquired from an instruction information accumulation part 170, and inputs the information of the syntax text 120 and the name table 130 requested by the correction routine 200.

Description

Detailed Description of the Invention

[0001]

BACKGROUND OF THE INVENTION 1. Field of the Invention The present invention relates to a source program check device, and more particularly, in a group review of a programming process for an input source program,
The present invention relates to a source program check device that not only checks whether there is a contradiction with the specifications created in the previous process, but also checks whether there is a problem in performance / logic / variable setting / reference relationship (undefined or unused).

[0002] In detail, in the work of performing a group review, performance problems, logical problems, and problems of variable setting / reference relations are pointed out in the source program printed or displayed in the group review. Rather than visually inspect it, if there is a list of points where problems may occur, the source program can be checked before the group review of the programming process, and it will be used as the source review material. The present invention relates to a source program check device capable of outputting a checklist for a program.

[0003]

2. Description of the Related Art Conventionally, as a method of checking a source program, by displaying or printing the source program at the time of reviewing the programming process, performance problems, logical problems, variable setting / reference relations Check the problem visually while checking it against the source. Alternatively, a plurality of source analysis tools are used to output the analysis results for each analysis tool to create a source review material.

As a material for source review, there is an error list for notifying cautions (warnings) and errors for each step during compilation. The user refers to this list and corrects the program at the portion indicated by the step number.

[0005]

However, when performing the above-mentioned conventional visual check, it is necessary to check whether items such as variables are set correctly and whether there is a contradiction in terms of logic. However, there is a problem in that a check omission is likely to occur. Furthermore, even a single source program may miss a check, but it becomes difficult to make a consistent check, especially when the range to be checked extends to multiple related source programs. There is a high possibility that an error will occur in the check itself.

Further, in the conventional method, even when an analysis tool is used, the format of the analysis result output from a plurality of tools is different for each tool, so that it must be re-compiled as a source review material. I won't.

Further, in the conventional method, the output list is an error list, and even if the step number and the type of error are displayed, how to modify the source program depends on the ability and experience of the user. Because there are many things,
It is often difficult for a person other than the user who created the source program to make the determination for correction.

The present invention has been made in view of the above points, and it is possible to improve the inefficiency in the conventional source review and to output the checklist in the same format even if a plurality of source programs are input. An object is to provide a possible source program check device.

A further object of the present invention is to check a source program capable of outputting not only an error and a caution item but also a message indicating how to correct the error and the caution item. The purpose is to provide a device.

[0010]

A source program check device of the present invention is a source program check device for analyzing a source program and outputting a check list of the source program, and input means for inputting the source program and items to be checked. And an analyzing means for analyzing the source program input by the input means based on the patterned check items, and an output means for extracting a result analyzed by the analyzing means and outputting it as an indication list. Have.

The analyzing means divides the source program input by the input means based on the check items and the name storing means for holding the definition information of the source program input by the input means for each check item, and processes it. Stored in the syntax storage means and the syntax storage means for referring to the information in the name storage means to check whether the handling of each definition information is correct by checking it with the check item. And a parsing means for analyzing whether there is any contradiction in the flow of processing by checking the check items.

Further, when an error or a caution item occurs as the analysis result of the name analysis unit and the syntax analysis unit, the output unit outputs a correction method for the occurrence position as a correction instruction message.

Further, the output means applies the correction rule for correcting the error or the caution item and the correction rule to the error or the caution item acquired by the analyzing means,
Generate a correction instruction message based on the applied result,
And means for outputting.

[0014]

According to the present invention, the check items for checking the source program are made into patterns, and the input source program and the check items are compared and collated. Point / variable setting / reference related problems are automatically pointed out instead of looking at the source.

Further, according to the present invention, not only the result of comparison with the check item is output to the list, but the rule for correcting the check result is applied to apply the rule.
Instead of simply outputting an error or a caution item, output how to correct it as a message.

Furthermore, even if a plurality of source programs are input, if the check items for checking the source programs are created in a unified manner, the contents of the check and the viewpoint of the check will not be complicated. Furthermore, since the output format is edited for each check item, the output format does not vary.

[0017]

Embodiments of the present invention will now be described in detail with reference to the drawings.

FIG. 1 is a block diagram of a source program check device according to an embodiment of the present invention. The source program check device 100 shown in the figure has a syntax text / name table creation unit 110, a syntax text 120, a name table 130, a check unit 140, and a check item storage unit 15.
0, message editing unit 160, instruction information storage unit 170,
It comprises a message storage unit 180, an output unit 190, and a correction routine 200.

In this embodiment, a source program as shown in FIG. 2 is input to the syntax text / name table creating section 110 of the source program checking apparatus 100. In the example of the figure, one source program is input for the sake of simplicity, but the number of input source programs is not limited. Furthermore, the type of the source program to be input is a high-level language or an assembler language source program, and an example in which an assembler language source program is input and an example in which a C language and assembler language source program are input are as follows: It will be described later.

FIG. 2 shows an example in which a C language program is input as a source program. The 51st line shown in the figure is "issy (char * C)", and the 52nd line is the text for making the determination. In the example of the figure, only "true" is designated. "Char * C" on the 51st line is a dummy argument,
"C" indicates a variable name.

Syntax text / name table creation unit 120
Stores the name table 130 and the syntax text 140 separately for each check item based on the input source program 110. FIG. 3 shows an example of syntax text of one embodiment of the present invention, and FIG. 4 shows an example of a name table of one embodiment of the present invention. The syntax text 120 represents a processing flow by creating one text for each input processing unit of the source program 10 and connecting the texts. The name table 130 is created in a table format by dividing information of variables, functions, and labels into effective ranges.

As shown in FIG. 3, when the 51st line of the source program 10 is defined from the source program shown in FIG. 2, the syntax text 120 is defined as [function definition | text | formal parameter] Sentences are judged using the same format.

The name table defines the names used in the source program shown in FIG. For example,
“Sum” is a declaration and is a source program main.
Define that it is used in the 50th line of c.

The check item storage unit 150 creates and stores check items for checking the source program 10 in advance.

The check unit 140 checks each check item with reference to the check items in the check item storage unit 150. Check items are as follows. Logical error check: A check that specifies a location where there is a strong suspicion of a logical error, although it is not a compilation error. Performance improvement check: A check that points out points that may cause problems in execution performance. Portability check: A check that specifies points where problems may occur when the compiler used is changed. Complexity check: A check that displays the frequency by measuring the complexity of the program structure according to a fixed evaluation standard. Undefined variable / function check: A check that points out undefined variables and functions and labels. Unused variable / function check: A check that points out variables, functions and labels that have been defined but are not used.

When editing a message, the instruction information storage unit 170 stores a message and an editing method for pointing out an error or a part that needs attention as a result of the checking by the checking unit 140. deep. The types of messages include a performance improvement message, a portability message, a logic error message, etc., depending on the check result from the check unit 140.

The message editing unit 160 is a check unit 1.
Based on the result checked in 40, the instruction information storage unit 170 is referred to, and the message information to be displayed to the user is edited by a predetermined editing method.

The message storage section 180 stores a pair of correction instruction messages corresponding to the check results of all the steps of one source program 10.

The output unit 190 is a message storage unit 180.
5, the correction instruction list 20 is output to the printer or the display device in the order of the line numbers. The correction instruction list 20 shown in FIG. 5 outputs items such as a confirmation date field, a file name, a line number, and a message. The confirmation date is a column for the user to enter the date on which the source program 10 was modified according to the modification message output by the user, and is left blank when it is output. The message is the result of the check, the error item or how the user
Displays whether to handle the items requiring attention. In the example of FIG. 5, the line number “51” is “pass by pointer” as a result of the check, but this process indicates that “pass by value” is better. Therefore, rather than simply displaying a warning, it shows how the user may modify the source program.

The modification routine 200 is created in accordance with the directivity of the program, or the content of which the modification pattern is generally determined is expressed by the program, and the design method is arbitrary.

FIG. 6 is a flow chart showing the outline of the operation of the source program check device according to the embodiment of the present invention. In performing the following operation, it is assumed that the check item is previously generated and stored in the check item storage unit 150 to be referred to by the check unit 140.

Step 1) One or a plurality of source programs 10 are input to the program check device 100.

Step 2) The syntax text / name table creation unit 110 creates the syntax text 120 and the name table 130 based on the input source program 10. In addition, as a generation method, the syntax text and the name table may be created by an existing method.

Step 3) All source programs 10
Step 1 and Step 2 above until the input of
Is repeated.

Step 4) The check unit 140 refers to the check item storage unit 150 from the syntax text 120 and the name table 130 created in Step 2, and performs the above check contents. If the check result matches the contents of the check item, that is, if the check result indicates that the contents of a certain step of the source program 10 should be pointed out, the message editing unit 160 edits the message of the check result. I do. On the other hand, if there is no content to be pointed out, the message editing unit 160 does not edit the message.

Step 5) The above check processing is repeated up to check item n.

Next, the check processing with the above check items will be described in detail. FIG. 7 is a flowchart of the operation of the syntax text / name table creating unit and the checking unit according to the embodiment of the present invention. The following flowchart will be described with reference to the syntax text and the name table of FIGS. Step 102 to Step 10 below
The process up to 5 is the check process regarding the check item 1 regarding the declaration and definition. The check in step 106 is a check process related to check item 2 for checking update and consistency of the program.

Step 101) When the C language source program (main.c) shown in FIG. 2 is input, the syntax text / name table creation 110 creates the syntax text and name table as shown in FIGS. 3 and 4. Created by a predetermined program.

Step 102) The check unit 140 checks the check item ““ -sum ”is a reference only and has no declaration or definition” registered in the check item storage unit 150. If the check items match, the process proceeds to step 107. If they do not match, it is determined that there is no need to point out and the process proceeds to step 103.

Step 103) The checking section 140 checks the check item "" -issy "is a reference only and has no declaration or definition". If they match, the process proceeds to step 107. If they do not match, the process proceeds to step 104.

Step 104) The checking unit 140 then checks the check item "" -symc "is a reference only and has no declaration or definition". If they match, the process proceeds to step 107, and if they do not match, the process proceeds to step 105.

Step 105) The checking unit 140 next checks the check item "the variable" c "is a reference only and has no declaration or definition". If they match, the process proceeds to step 107, and if they do not match, step 10
Go to 6.

Step 106) Next, check section 140
Checks whether the argument "c" is indirectly updated. If it has been updated, the process proceeds to step 107. If it has not been updated, there is no need to output a checklist, and the process ends.

Step 107) Items that match the check items in each of the above steps are items that may cause an error or caution, so output how to make corrections as a message.

Next, the case where a message is output in the above step 107 will be described. FIG. 8 is a flowchart of the message editing process of the message editing unit 160 according to the embodiment of this invention.

Step 201) Message editing unit 160
Indicates that an item that has been checked by the check unit 140 and has an error or an item requiring attention appears
Acquire the file name and line number together with the error content.

Step 202) Message editing unit 160
Is passed from the check unit 140 as an error content, and the instruction information storage unit 1 uses the error number.
Search for 70. From the instruction information storage unit 170, a message prompting correction of an error and a program number of a correction routine for correcting the error are acquired. (Step 203) The message editing section 160 activates the modification routine 200 corresponding to the program number acquired from the instruction information accumulating section 170.

(Step 204) When executing the modification routine 200, the message editing section 160 inputs the information of the syntax text 120 and the name table 130 required by the modification routine 200 and acquires the execution result.

Step 205) Message editing section 160
Incorporates the execution result acquired from the modification routine 200 into the message acquired in step 202.

Step 206) Message editing unit 160
Transfers the modification information in which the execution result is incorporated into the message to the message storage unit 180.

The correction routine 200 in steps 203 and 204 above operates as follows. The check unit 140 displays the check result in the message editing unit 1
Enter in 60. When the message editing unit 160 receives, as a check result from the check unit 140, for example, a result “multiplication / division is possible / power calculation is possible”, the instruction information storage unit 170 is based on the check result. , The correction routine 200 is started by the program number corresponding to the above check result, and "shift operation (a >> n) should be performed" is output. A file name and a line number are added to this message and the message is transferred to the message storage unit 180.

As a second example, the check unit 140
As a result of the check, when "there is a loop in the process / there is an invariant operation in the loop" is input to the message editing unit 160, the correction routine 200 obtains a message that "invariant operation is performed before the loop". . A file name and a line number are added to this message and the message is transferred to the message storage unit 180.

As a third example, the check unit 140
As a check result, when "AND operation is present" is input to the message editing unit 160, a message "use type conversion" is obtained from the correction routine 200. Similarly, a file name and a line number are added to this message and the message storage unit 180
Transferred to.

In the above, only the check result message is transferred from the check unit 140 to the message editing unit 160. However, not only the message but also the contents of the actual step of the source program are instructed, and the above second message is sent. For example, the following two pieces of information i) “There is a loop in the process / invariant operation in the loop” ii) Change to “Line 50 Line 51 while t <a * b”, and transfer to the message editor 160 To do. Next, when the message editor 160 acquires these two pieces of information,
It is also possible to automatically change the above ii) to “Line 50 n = a * b Line 51 while t <n” by the correction routine 200 from the instruction information storage unit 170 and transfer it to the message storage unit 180. .

The message storage unit 180 outputs the messages accumulated as described above to the output unit 190.
The output unit 190 outputs the correction instruction list. An example in which the above example is output is shown in FIG. In this way, the output unit 190
Can output not only the error item but also a message instructing how to make the correction.

FIG. 10 shows an example of the correction information generated as described above. The types of messages as the correction information shown in the figure include a performance improvement message, a portability message, and a logical error message.

In the above embodiment, a C language source list as shown in FIG. 2 is input as a source program and output to point out or correct performance problems and logical problems. The following is an example of inputting a program written in assembler language as a source program and outputting a list of indications of problems of variable setting / reference relations.

FIG. 11 shows the configuration of a source program check device according to another embodiment of the present invention. The configuration shown in the figure requires the definition file 210 for analyzing the assembler source when the name table 130 is generated,
Only the name table 130 is generated and the syntax text 12
0 is not generated. The assembler definition file 210 is
It is a file based on the syntax of the assembler language, and by replacing the assembler definition file 210, any kind of assembler language can be input.

FIG. 12 shows an example of an input assembler source program and definition file 210 according to another embodiment of the present invention. The assembler source 10 and the definition file 210 shown in the figure are input to the name table creation unit 110,
The name table shown in FIG. 13 is generated.

The checking section 140 points out undefined variables, functions and labels as undefined variable / function check. In addition, the unused variables / functions are defined, but the unused variables, functions and labels are pointed out.

The message editing section 160 for editing a message, the message storage section 180, the output section 190, the instruction information storage section 170, the correction routine 200, etc. are the same as those in the above-mentioned embodiment, and therefore their explanations are omitted.

Further, the source program input to the source program check device may be input in both C language and assembler language. For example, there is a case where a plurality of C languages among related source programs and an external subroutine of the assembler language are called from the C languages. At this time, the syntax text / name table creation unit 1
10 creates a name table 130 as shown in FIG. Further, in this case, the syntax text / name table creation unit 110 generates both the syntax text 120 and the name table 130.

As described above, according to the present invention, regardless of whether the input source program is a high-level language such as C language or an assembly language, the performance of the source program is improved by comparing the patterned check items with the source program. It is possible to output a list of indications of the above problems and logical problems, and a correction instruction list capable of indicating the setting / reference relation of variables by inputting C language and assembler language.

In the above embodiment, the correction instruction message generated by the message editing unit 160 is temporarily stored in the message storage unit 180 for the purpose of quality control of the program and can be referred to later. Is. Further, the correction instruction message may be stored in the message storage unit 180 and transferred to the output unit 190 until the check of the series of source programs that are the main routine of the source program and the subroutine is completed.

However, the present invention is not limited to this example, the message editing unit 160 transfers the correction instruction message to the output unit 190 when the correction instruction message is generated, and the output unit 1 outputs the correction instruction message.
The method of outputting from 90 to a display device or a printing device may be used.

Furthermore, the check item storage unit 150 is
It may be set as a table inside the check unit 140 or may be set as a file outside. Similarly, the instruction information storage unit 170 may be set as a table inside the message storage unit 180 or may be set outside as a file.

The present invention is not limited to the above embodiment, but various modifications and applications are possible within the scope of the claims.

[0068]

As described above, according to the present invention, in the programming process, the check items of the review are patterned, and the patterned check items are compared with the source program. Since the problem of (1) and the problem of variable setting / reference relation are automatically pointed out, the review time is shortened and a certain level of quality of the source program is guaranteed.

Further, since the correction point and the correction content are output as a message in the correction instruction list, the source program can be corrected by the method instructed at the point indicated by the message.

Further, even if the user who created the source program does not refer to the correction instruction message, the correction can be easily performed.

[Brief description of drawings]

FIG. 1 is a configuration diagram of a source program check device according to an embodiment of the present invention.

FIG. 2 shows an example of an input C language source program according to an embodiment of the present invention.

FIG. 3 is a diagram showing an example of syntax text according to an embodiment of the present invention.

FIG. 4 is a diagram showing an example of a name table according to an embodiment of the present invention.

FIG. 5 is a diagram showing a modification instruction list according to an embodiment of the present invention.

FIG. 6 is a flowchart showing an outline of the operation of the source program check device according to the embodiment of the present invention.

FIG. 7 is a flowchart showing operations of a syntax text / name table creation unit and a check unit according to an embodiment of the present invention.

FIG. 8 is a diagram showing an example of outputting a correction instruction according to an embodiment of the present invention.

FIG. 9 is a flowchart of a message editing process of a message editing unit according to an embodiment of the present invention.

FIG. 10 is a diagram showing an example of correction information according to an embodiment of the present invention.

FIG. 11 is a configuration diagram of a source program check device according to another embodiment of the present invention.

FIG. 12 is a diagram showing an example of an input assembler source program and a definition file according to another embodiment of the present invention.

FIG. 13 is a diagram showing an example of a generated name table according to another embodiment of the present invention.

FIG. 14 is a diagram showing an example of a name table according to another embodiment of the present invention.

[Explanation of symbols]

 10 source program 20 correction instruction list 100 source program check device 110 syntax text / name table creation unit 120 syntax text 130 name table 140 check unit 150 check item storage unit 160 message editing unit 170 instruction information storage unit “180 message storage unit 190 output Part 200 Correction routine

 ─────────────────────────────────────────────────── ─── Continuation of the front page (72) Inventor Satoshi Yokkasho 1015 Kamiodanaka, Nakahara-ku, Kawasaki-shi, Kanagawa Fujitsu Limited

Claims (4)

[Claims] 1. A source program check device for analyzing a source program and outputting a checklist of the source program, wherein at least one input means for inputting the source program and an item to be checked are patterned and patterned. An analysis unit that analyzes the source program input by the input unit based on a check item and extracts a portion that needs to be corrected; and a pointing-out unit that points out a corrected portion based on a result analyzed by the analysis unit. A source program check device, comprising: output means for outputting a correction indication list. 2. The analysis means includes a name storage means for holding definition information of the source program input by the input means for each of the check items, and a processing of the source program input by the input means. A name that is divided based on the check items and refers to the information in the syntax storage unit that holds the flow of processing and the information in the name storage unit to analyze whether the handling of each definition information is correct by collating with the check items. 2. The source program check device according to claim 1, further comprising: an analysis unit; and a syntax analysis unit that analyzes whether or not the flow of processing stored in the syntax storage unit is inconsistent with the check item. 3. The output means outputs, when an error or a caution item occurs as the analysis result of the name analysis means and the syntax analysis means, a correction method for the occurrence location as a correction instruction message. The source program check device according to claim 1. 4. The output unit applies a correction rule for correcting the error or the caution item and a correction rule to the error or the caution item acquired by the analysis unit, and a result of applying the correction rule. 4. The source program check device according to claim 3, further comprising means for generating and outputting the correction instruction message based on the above.