JP2022177585A - Error check program, information processing apparatus, and error check method - Google Patents

Abstract

To reduce the time for handling errors using a check result when a source code is checked with an error check tool for source code.SOLUTION: An information processing apparatus 1 checks a source code 21 of a program for errors with a predetermined error check tool. The information processing apparatus 1 determines whether two blocks included in the source code 21 for comparison have sets in which error identifiers uniquely identifying errors and conditions of the errors match, in the same order or not, from a check result. When a determination is made that the orders of the sets are identical, the information processing apparatus 1 outputs the corresponding compared blocks and error identifiers.SELECTED DRAWING: Figure 3A

Description

The present invention relates to an error check program and the like.

Conventionally, when source code is checked using a source code error checking tool, a developer confirms the check result and corrects the source code. For example, the developer visually confirms the check result and corrects the code that needs to be corrected.

In addition, regarding source code correction support, a program for detecting abnormal patterns of function calls in source code has been provided (see, for example, Patent Document 1). In such a program, for each function, the global identifier or keyword is extracted from before and after the function call for that function in the preprocessing result file, the global identifier or keyword with high appearance frequency is set as a common occurrence pattern, and common appearance Print a warning message for function calls that do not include the pattern in the surrounding statements.

JP 2007-249765 A

However, the conventional technology has a problem that when the source code is checked using the source code error check tool, it takes time to deal with the error using the check result. That is, the developer visually confirms the check result and corrects the code that needs to be corrected, so it takes time to deal with the error.

It should be noted that the program for detecting an abnormal pattern of function calls in the source code only supports correction of abnormalities in function calls, and does not support correction of abnormalities in the entire source code.

An object of the present invention is, in one aspect, to reduce the error handling time using the check result when the source code is checked using the source code error check tool.

In one aspect, the error checking program checks the source code of the program for errors by a predetermined error checking tool, and for each block included in the source code, an error identifier capable of uniquely identifying the error and the It is determined whether or not the order of pairs matching the conditions for generating an error is matched, and if it is determined that the order of the pairs is matched, the matched block and error identifier are output, and the computer executes processing. .

According to one embodiment, when the source code is checked using a source code error checking tool, the error handling time using the check results can be reduced.

FIG. 1 is a block diagram illustrating an example of a functional configuration of an information processing apparatus according to an embodiment; FIG. 2A is a diagram (1) illustrating an example of a check result according to the embodiment; FIG. 2B is a diagram (2) illustrating an example of a check result according to the embodiment; FIG. 2C is a diagram (3) illustrating an example of a check result according to the embodiment; FIG. 3A is a diagram (1) illustrating an example of detection processing according to the embodiment; FIG. 3B is a diagram (2) illustrating an example of detection processing according to the embodiment; FIG. 4 is a diagram illustrating an example of a detection result according to the embodiment; FIG. 5 is a diagram illustrating an example of a flowchart of detection processing according to the embodiment. FIG. 6 is a diagram showing an example of a computer that executes an error check program.

Hereinafter, embodiments of an error check program, an information processing apparatus, and an error check method disclosed in the present application will be described in detail based on the drawings. In addition, this invention is not limited by an Example.

[Functional Configuration of Information Processing Device]
FIG. 1 is a block diagram illustrating an example of a functional configuration of an information processing apparatus according to an embodiment; The information processing apparatus 1 according to the embodiment automatically detects a location with a similar problem in block units from the check result 22 of the problem location in the source code 21 of the program, and eliminates the need for error handling in the other block. . Here, the block unit may be, for example, a function or a group of approximately the same number of lines delimited by curly braces. In addition, in the embodiment, the block will be described as a function.

The information processing device 1 has a control unit 10 and a storage unit 20 . The control unit 10 is a processing unit that controls the entire information processing apparatus 1 and has a check execution unit 11 , a detection unit 12 and an output unit 13 . Storage unit 20 has source code 21 , check result 22 and detection result 23 . Note that the check execution unit 11 is an example of a check unit. The detection unit 12 is an example of a determination unit. The output unit 13 is an example of an output unit.

Source code 21 indicates the program code of the source program to be checked. That is, the source code 21 is program code coded by the developer.

A check result 22 indicates the result of checking the source code 21 by the error check tool. The check result 22 describes an error identifier that can uniquely identify the problem (error) for the problem location and the conditions under which the error occurs. The error check tool here means a source code static analysis tool, and examples thereof include Agile+Relief (registered trademark), QAC (registered trademark), and Klocwork (registered trademark). The condition under which an error occurs here indicates the condition leading to the error. The conditions under which such errors occur may be generated using, for example, static analysis used when searching for errors in an error checking tool, may be generated in the error checking tool, It may be generated in the later-described check execution unit 11 after the error check tool. Note that the check result 22 is output by the check execution unit 11, which will be described later.

A detection result 23 indicates a result of detecting similar blocks from the check result 22 . Note that the detection result 23 is output by the detection unit 12, which will be described later.

The check execution unit 11 executes a predetermined error check tool on the source code 21 of the program. The check execution unit 11 then outputs the check result 22 . An example of the check result 22 will now be described with reference to FIGS. 2A to 2C.

2A to 2C are diagrams showing examples of check results according to the embodiment. 2A shows a check result 22 of funcA, which is a function included in source code 21. FIG. FIG. 2B is a check result 22 of funcB, which is a function included in the source code 21. FIG. FIG. 2C is a check result 22 of funcC, which is a function included in the source code 21. FIG. The functions funcA, funcB and funcC are examples of blocks.

As shown in FIG. 2A, a code "save==1;" is described at the problem location indicated by symbol a1. This code is associated with an error identifier and an error condition. "pgr0038" is described as an error identifier. The content of the error indicated by "pgr0038" is "== may be wrong". That is, it is pointed out that there is a possibility of a mistake in "==" included in the code. Then, "return return value=NO, sequence of actual arguments=NO" is described as a condition. That is, this condition indicates that the variable (here, "save") included in the code is not the return value of return and is not in the line of actual arguments of funcA.

Also, a code "muinf=save:" is described at the problem location indicated by symbol a2. This code is associated with an error identifier and an error condition. "pgr0000" is described as an error identifier. The content of the error indicated by "pgr0000" is "there may be no value setting before the save reference". That is, it is pointed out that there may be no code that sets a value to "save" before referring to "save" included in the code. As a condition, "value setting route exists=YES" is described. That is, this condition indicates that any line of funcA has a route in which a value is set to a variable (here, "save") included in the code.

In addition, a code "return0:" is written at the problematic portion indicated by reference a3. This code is associated with an error identifier and an error condition. "pgr0524" is described as an error identifier. The content of the error indicated by "pgr0524" is "the acquired resource may not be released". In other words, it points out the possibility that the resource acquired by one of the lines has not been released. Then, "function=malloc, resource release route exists=YES" is described as a condition. That is, such a condition indicates that at some line after the resource is acquired by the malloc function, there is a route to release the resource.

As shown in FIG. 2B, a code "res==chknum( );" is written in the problematic portion indicated by symbol b1. This code is associated with an error identifier and an error condition. "pgr0038" is described as an error identifier. The content of the error indicated by "pgr0038" is "== may be wrong". That is, it is pointed out that there is a possibility of a mistake in "==" included in the code. Then, "return return value=Yes, array of actual arguments=NO" is described as a condition. That is, this condition indicates that the variable (here, "res") included in the code is the return value of return and is not in the line of actual arguments of funcB.

In addition, a code "res=save:" is written at the problematic portion indicated by symbol b2. This code is associated with an error identifier and an error condition. "pgr0000" is described as an error identifier. The content of the error indicated by "pgr0000" is "there may be no value setting before the save reference". That is, it is pointed out that there may be no code that sets a value to "save" before referring to "save" included in the code. As a condition, "value setting route exists=NO" is described. That is, this condition indicates that there is no route in any line of funcB where a value is set to a variable (here, "save") included in the code.

In addition, a code "}" indicating the end of the curly bracket is described at the problematic portion indicated by symbol b3. This code is associated with an error identifier and an error condition. "pgr0524" is described as an error identifier. The content of the error indicated by "pgr0524" is "the acquired resource may not be released". In other words, it points out the possibility that the resource acquired by one of the lines has not been released. As a condition, "function=malloc, resource release route present=NO" is described. That is, such a condition indicates that there is no route to release the resource on any line after the resource is acquired by the malloc function.

As shown in FIG. 2C, a code "save==1;" is written in the problematic portion indicated by reference symbol c1. This code is associated with an error identifier and an error condition. "pgr0038" is described as an error identifier. The content of the error indicated by "pgr0038" is "== may be wrong". That is, it is pointed out that there is a possibility of a mistake in "==" included in the code. Then, "return return value=NO, sequence of actual arguments=NO" is described as a condition. That is, this condition indicates that the variable (here, "save") included in the code is not the return value of return and is not in the line of actual arguments of funcC.

In addition, a code "muinf=save:" is written at the problematic portion indicated by symbol c2. This code is associated with an error identifier and an error condition. "pgr0000" is described as an error identifier. The content of the error indicated by "pgr0000" is "there may be no value setting before the save reference". That is, it is pointed out that there may be no code that sets a value to "save" before referring to "save" included in the code. As a condition, "value setting route exists=YES" is described. That is, this condition indicates that there is a route where a value is set to a variable (here, "save") included in the code in any line of funcC.

In addition, a code "}" indicating the end of the curly bracket is described at the problematic portion indicated by reference symbol c3. This code is associated with an error identifier and an error condition. "pgr0524" is described as an error identifier. The content of the error indicated by "pgr0524" is "the acquired resource may not be released". In other words, it points out the possibility that the resource acquired by one of the lines has not been released. Then, "function=malloc, resource release route exists=YES" is described as a condition. That is, such a condition indicates that at some line after the resource is acquired by the malloc function, there is a route to release the resource.

Returning to FIG. 1, the detection unit 12 determines whether or not the order of pairs of matching error identifiers and matching conditions matches from the check result 22 for two blocks (for example, functions) to be compared included in the source code 21. judge. For example, the detection unit 12 acquires a function list from analysis data analyzed by an error check tool for the source code 21 . The detector 12 sequentially compares the check results 22 for two different functions in the function list. The detection unit 12 determines whether or not the error identifiers of the error locations in the two functions to be compared match. When the error identifiers match, the detection unit 12 determines whether the conditions of the error locations in the two functions to be compared match. Then, when the conditions at the error locations match, the detection unit 12 determines whether or not the order of pairs of matching error identifiers and conditions at the error locations in the two functions to be compared match. The detection unit 12 determines that the two functions to be compared have the same problem when the order of pairs of matching error identifiers and conditions in the error locations in the two functions to be compared is the same. do. If the error identifiers or conditions at the error locations in the two functions to be compared are different, or if the error identifiers and conditions match but the order of these sets does not match, the detection unit 12 performs comparison. It is determined that the two functions of interest are not functions with similar problems. In addition, the detection unit 12 may add the case where the number of error locations in the two functions to be compared match as a condition for determining that the functions have similar problems.

Also, the detection unit 12 stores the detection result in the detection result 23 .

The output unit 13 outputs the detection result 23. FIG. For example, the output unit 13 displays the detection result 23 on the screen. As a result, the output unit 13 can notify the developer of functions having similar problems. As a result, the developer analyzes the cause of the problem and implements countermeasures for one function with the same problem, but for the other function, if the analysis of the cause of the problem is omitted and only the countermeasures are executed. good. In other words, the developer can reduce the problem handling time by eliminating the need to analyze the cause of the problem in the other function during coding.

[Example of detection process]
Here, an example of detection processing performed by the detection unit 12 will be described with reference to FIGS. 3A and 3B. 3A and 3B are diagrams illustrating an example of detection processing according to the embodiment. In FIG. 3A, the check result 22 of the function (funcA) shown in FIG. 2A is compared with the check result 22 of the function (funcC) shown in FIG. A case of determining whether In FIG. 3B, the check result 22 of the function (funcA) shown in FIG. 2A and the check result 22 of the function (funcB) shown in FIG. 2B are compared to determine whether the functions to be compared have similar problems. A case of judgment will be explained.

As shown in FIG. 3A, funcA has error locations indicated by symbols a1, a2, and a3 in this order. In funcC, error locations indicated by code c1, code c2, and code c3 exist in this order.

Under such circumstances, the detection unit 12 determines whether or not the error identifiers of the error locations in the two functions to be compared match. Note that if there are multiple error locations in the function, the detection unit 12 compares the error identifiers in the order of the error locations. Error identifiers of error locations in funcA are pgr0038, pgr0000, and pgr0524. On the other hand, the error identifiers of the error locations in funcC are pgr0038, pgr0000, and pgr0524. Both funcA and funcC have error identifiers of pgr0038, pgr0000, pgr0524 in that order. Therefore, the detection unit 12 determines that the error identifiers of the error locations in the functions of funcA and funcC to be compared match.

Then, when the error identifiers match, the detection unit 12 determines whether or not the conditions of the error locations in the two functions to be compared match. Note that if there are multiple error locations in the function, the detection unit 12 compares the conditions in the order of the error locations. The conditions for the error location in funcA are "return return value=NO, actual argument list=NO", "value setting route=YES", "function=malloc, resource release route=YES". The conditions for the error location in funcC are "return return value=NO, actual argument list=NO", "value setting route=YES", "function=malloc, resource release route=YES". Both funcA and funcC have the same conditions in that order. Therefore, the detection unit 12 determines that the conditions of the error locations in the functions of funcA and funcC to be compared match.

Then, when the conditions at the error locations match, the detection unit 12 determines whether or not the order of pairs of matching error identifiers and conditions at the error locations in the two functions to be compared match. Here, in funcA, there are pairs of error identifiers and conditions at error locations indicated by symbols a1, a2, and a3 in this order. In funcC, there are pairs of error identifiers and conditions at error locations indicated by symbols c1, c2, and c3 in this order. The error identifier and condition at the error location indicated by symbol a1 and the error identifier and condition at the error location indicated by symbol c1 match. The error identifier and condition at the error location indicated by symbol a2 and the error identifier and condition at the error location indicated by symbol c2 match. The error identifier and condition at the error location indicated by symbol a3 and the error identifier and condition at the error location indicated by symbol c3 match. Therefore, the detection unit 12 determines that the order of pairs of matching error identifiers and matching conditions at error locations in the functions of funcA and funcC to be compared matches.

Then, if the order of the sets of matching error identifiers and conditions in the error locations in the two functions to be compared match, the detection unit 12 determines that the two functions to be compared are functions having similar problems. I judge. In this case, the order of pairs matching the error identifiers and conditions at the error locations in the functions of funcA and funcC to be compared is the same, so the detection unit 12 detects that the functions of funcA and funcC to be compared have similar problems. Judge it as a function.

Then, the detection unit 12 stores in the detection result 23 a result indicating that the functions of funcA and funcC to be compared have similar problems.

As shown in FIG. 3B, funcA has error locations denoted by a1, a2, and a3 in this order. In funcB, there are error locations indicated by symbols b1, b2, and b3 in this order.

Under such circumstances, the detection unit 12 determines whether or not the error identifiers of the error locations in the two functions to be compared match. Note that if there are multiple error locations in the function, the detection unit 12 compares the error identifiers in the order of the error locations. Error identifiers of error locations in funcA are pgr0038, pgr0000, and pgr0524. On the other hand, the error identifiers of the error locations in funcB are pgr0038, pgr0000, and pgr0524. Both funcA and funcB have error identifiers of pgr0038, pgr0000, pgr0524 in that order. Therefore, the detection unit 12 determines that the error identifiers of the error locations in the functions of funcA and funcB to be compared match.

Then, when the error identifiers match, the detection unit 12 determines whether or not the conditions of the error locations in the two functions to be compared match. Note that if there are multiple error locations in the function, the detection unit 12 compares the conditions in the order of the error locations. The conditions for the error location in funcA are "return return value=NO, actual argument list=NO", "value setting route=YES", "function=malloc, resource release route=YES". The conditions for the error location in funcB are "return return value=YES, actual argument list=NO", "value setting route=NO", "function=malloc, resource release route=NO". funcA and funcB have different conditions. Therefore, the detection unit 12 determines that the conditions of the error locations in the functions of funcA and funcB to be compared do not match.

Then, when the conditions of the error locations do not match, the detection unit 12 determines that the two functions to be compared do not have similar problems. Here, since the conditions for the error locations in the functions funcA and funcB to be compared do not match, the detecting unit 12 determines that the functions funcA and funcB to be compared do not have similar problems.

Then, the detection unit 12 stores in the detection result 23 a result indicating that the functions of funcA and funcB to be compared do not have similar problems.

[Example of detection result]
FIG. 4 is a diagram illustrating an example of a detection result according to the embodiment; The detection result 23 shown in FIG. 4 is the detection result 23 for the function (funcA) shown in FIG. 2A, the function (funcB) shown in FIG. 2B, and the function (funcC) shown in FIG. 2C.

As shown in FIG. 4, the detection result 23 is information in which the detected problem and the similar problem are associated with each other. In the detected problem item, an identifier for identifying one function to be compared and an error identifier of a problem detected in the function are set. In the similar problem item, an identifier for identifying the other function determined to have a similar problem and an error identifier for the problem detected in the function are set.

Here, in the first line, an identifier "a.c" for identifying the function (funcA) and an error identifier "pgr0038" are set as detection problems. As similar problems, an identifier "c.c" for identifying the function (funcC) and an error identifier "pgr0038" are set. In the second line, an identifier "a.c" for identifying the function (funcA) and an error identifier "pgr0000" are set as detection problems. As similar problems, an identifier "c.c" for identifying the function (funcC) and an error identifier "pgr0000" are set. In the third line, an identifier "a.c" for identifying the function (funcA) and an error identifier "pgr0524" are set as detection problems. As similar problems, an identifier "c.c" for identifying the function (funcC) and an error identifier "pgr0524" are set. That is, the first to third lines show, for example, the detection results of the detection process shown in FIG. 3A.

In the fourth line, an identifier "bc" for identifying the function (funcB) and an error identifier "pgr0038" are set as detection problems. As a similar problem, "no similar" is set. In the fifth line, an identifier "bc" for identifying the function (funcB) and an error identifier "pgr0000" are set as detection problems. As a similar problem, "no similar" is set. In the sixth line, an identifier "bc" for identifying the function (funcB) and an error identifier "pgr0524" are set as detection problems. As a similar problem, "no similar" is set. That is, the fourth to sixth lines show, for example, the detection results of the detection process shown in FIG. 3B.

After that, the output unit 13 outputs the detection result 23 . The developer who saw the output detection result 23 a. For c, analyze the cause of the error of pgr0038, pgr0000 and pgr0524, and a. Take action on the function in c. Developer c. For c, only the pgr0038, pgr0000 and pgr0524 errors are handled. Analysis of the cause of such errors includes: a. This is because it has already been implemented in c. This allows the developer to reduce the problem handling time by eliminating the need to analyze the cause of the problem in the other function during coding. In addition, the developer b. As for c, there is no function with similar problems, so the cause of the error in pgr0038, pgr0000 and pgr0524 is analyzed, and b. Take action on the function in c.

[Flowchart of detection processing]
FIG. 5 is a diagram illustrating an example of a flowchart of detection processing according to the embodiment. In the detection process, a condition for judging that functions have similar problems is that the number of error locations in the two functions to be compared is the same.

First, the check execution unit 11 executes an error check tool on the source code 21 of the target program and outputs the check result 22 . Then, the detection unit 12 acquires a function list from the analysis data of the error check tool (step S11). Then, the detection unit 12 sequentially compares the functions in the function list (step S12).

The detection unit 12 determines whether or not the numbers of problem locations in the functions to be compared match (step S13). When it is determined that the numbers of problem locations in the functions to be compared do not match (step S13; No), the detection unit 12 determines that the functions to be compared are not similar problems, and proceeds to step S17.

On the other hand, if it is determined that the numbers of problem locations in the functions to be compared match (Step S13; Yes), the detection unit 12 determines whether the problem IDs (error identifiers) of the problem locations in the functions to be compared match. It is determined whether or not (step S14). Here, when there are a plurality of problem IDs in each function to be compared, the detection unit 12 may determine whether or not the problem IDs match in the order of the problem locations in the function. If it is determined that the problem IDs of the problem locations in the comparison target function do not match (step S14; No), the detection unit 12 determines that the comparison target function is not a similar problem, and proceeds to step S17.

On the other hand, if it is determined that the problem IDs of the problem location in the comparison target function match (step S14; Yes), the detection unit 12 determines whether the detection conditions of the problem location in the comparison target function match. is determined (step S15). Here, if there are a plurality of problem IDs in each function to be compared, the detection unit 12 may determine whether or not the detection conditions match in the order of the problem locations in the function. If it is determined that the detection conditions for the problem location in the comparison target function do not match (step S15; No), the detection unit 12 determines that the comparison target function is not a similar problem, and proceeds to step S17.

On the other hand, if it is determined that the detection conditions for the problem location in the function to be compared match (Step S15; Yes), the detection unit 12 determines that the function to be compared is a function having similar problems, and the detection result 23 (step S16). And the detection part 12 transfers to step S18.

In step S17, the detection unit 12 determines that the function to be compared is a function that does not have a similarity problem, and records it in the detection result 23 (step S17). And the detection part 12 transfers to step S18.

In step S18, the detection unit 12 determines whether or not there is a function to be compared in the function list (step S18). If it is determined that there is a function to be compared in the function list (step S18; Yes), the detection unit 12 proceeds to step S12 to perform the next comparison process. On the other hand, when it is determined that there is no function to be compared in the function list (step S18; No), the detection unit 12 terminates the detection process.

[Effect of Example]
According to the above embodiment, the information processing apparatus 1 checks the source code 21 of the program for errors using a predetermined error check tool. The information processing apparatus 1 determines whether or not the order of pairs matching the error identifier that can uniquely identify the error and the conditions for the occurrence of the error matches from the check result 22 for the two blocks to be compared included in the source code 21. determine whether When the information processing apparatus 1 determines that the order of the sets matches, it outputs the blocks to be compared that match and the error identifier. According to such a configuration, the information processing apparatus 1 can reduce the error coping time when the source code 21 is checked using the error check tool for the source code 21 . In other words, the information processing apparatus 1 does not need to perform error analysis on the second block of the two blocks in coding, so it is possible to reduce the error coping time.

Further, according to the above embodiment, the information processing apparatus 1 further determines whether or not the numbers of errors match. When the information processing apparatus 1 determines that the order of the sets and the number of errors match, the information processing apparatus 1 outputs the matched block and error identifier. According to such a configuration, the information processing apparatus 1 can determine that the two blocks to be compared that have errors are blocks that have similar errors, so the error analysis of the second block of the two blocks becomes unnecessary. Therefore, the error handling time can be reduced.

In addition, according to the above embodiment, the conditions under which an error occurs are generated using static analysis used when searching for errors in an error checking tool. Thereby, the information processing apparatus 1 can easily generate the conditions under which an error occurs using the known logic of the error check tool.

[others]
In the above-described embodiment, the detecting unit 12 detects that the two blocks to be compared have the same problem when the order of pairs of matching error identifiers and conditions in the error locations in the two blocks to be compared is the same. It was explained that it is judged to be a function with However, the detection unit 12 is not limited to this, and when pairs of matching error identifiers and conditions at error locations in two blocks to be compared overlap, the two blocks to be compared have similar problems. You can judge that it is a function. This is because the code description order may vary from developer to developer depending on the content of the coding.

Further, in the above embodiment, each component of the illustrated information processing apparatus 1 does not necessarily have to be physically configured as illustrated. That is, the specific aspects of the distribution and integration of the information processing device 1 are not limited to those shown in the drawings, and all or part of them can be functionally or physically implemented in arbitrary units according to various loads and usage conditions. It can be distributed and integrated. For example, the check execution unit 11 may be divided into an execution unit that executes an error check tool and a generation unit that generates conditions for error occurrence. Alternatively, the detection unit 12 and the output unit 13 may be integrated as one unit. Alternatively, the storage unit 20 may be connected to the information processing apparatus 1 as an external device via a network.

Moreover, various processes described in the above embodiments can be realized by executing a prepared program on a computer such as a personal computer or a work station. Therefore, an example of a computer that executes a rewriting program that implements the same functions as those of the information processing apparatus 1 shown in FIG. 1 will be described below. FIG. 6 is a diagram showing an example of a computer that executes an error check program.

As shown in FIG. 6, the computer 200 has a CPU 203 that executes various arithmetic processes, an input device 215 that receives data input from the user, and a display device 209 . The computer 200 also has a drive device 213 that reads programs and the like from a storage medium, and a communication I/F (Interface) 217 that exchanges data with other computers via a network. The computer 200 also has a memory 201 that temporarily stores various information and a HDD (Hard Disk Drive) 205 . The memory 201 , CPU 203 , HDD 205 , display device 209 , drive device 213 , input device 215 and communication I/F 217 are connected via a bus 219 .

The drive device 213 is a device for the removable disk 211, for example. The HDD 205 stores an error check program 205a and error check processing related information 205b. A communication I/F 217 serves as an interface between the network and the inside of the apparatus, and controls input/output of data from other computers. For the communication I/F 217, for example, a modem, a LAN adapter, or the like can be adopted.

A display device 209 is a display device that displays data such as a cursor, an icon, a toolbox, documents, images, and functional information. The display device 209 can employ, for example, a liquid crystal display or an organic EL (Electroluminescence) display.

The CPU 203 reads the error check program 205a, develops it in the memory 201, and executes it as a process. Such a process corresponds to each functional unit of the information processing apparatus 1 . The error check processing related information 205b corresponds to the source code 21, the check result 22, the detection result 23, and the like. For example, the removable disk 211 stores each information such as the error check program 205a.

Note that the error check program 205a does not necessarily have to be stored in the HDD 205 from the beginning. For example, the program is stored in a “portable physical medium” such as a flexible disk (FD), CD-ROM, DVD disk, magneto-optical disk, IC card, etc. inserted into the computer 200 . Then, the computer 200 may read and execute the error check program 205a from these.

1 information processing device 10 control unit 11 check execution unit 12 detection unit 13 output unit 20 storage unit 21 source code 22 check result 23 detection result

Claims (6)

Check the source code of the program for errors with a predetermined error checking tool,
For two blocks to be compared included in the source code, it is determined from the check result whether the order of pairs matching the error identifier that can uniquely identify the error and the condition that the error occurs is matched,
An error check program for causing a computer to execute a process of outputting a matched block to be compared and an error identifier when it is determined that the sets match in order. The determining process further determines whether or not the numbers of errors match,
2. The error check program according to claim 1, wherein the output processing outputs a matching block and an error identifier when it is determined that the order of the sets and the number of errors match. 2. The error check program according to claim 1, wherein the conditions under which the error occurs are generated using static analysis used when searching for the error in the error check tool. 2. The error check program according to claim 1, wherein said block is a function included in said source code. a checking unit for checking an error with a predetermined error checking tool for the source code of the program;
Judgment for determining whether or not the order of pairs matching the error identifier that can uniquely identify the error and the condition that the error occurs matches from the check result for the two blocks to be compared included in the source code. Department and
an output unit for outputting a matched block to be compared and an error identifier when it is determined that the order of the sets matches;
An information processing device comprising: Check the source code of the program for errors with a predetermined error checking tool,
For two blocks to be compared included in the source code, it is determined from the check result whether the order of pairs matching the error identifier that can uniquely identify the error and the condition that the error occurs is matched,
An error checking method, wherein when it is determined that the sets match in order, the computer executes a process of outputting a matched block to be compared and an error identifier.

Images