JPH10312312A - C-language computer program inspection processing method whose operation changes according to specifications and program storage medium - Google Patents

Abstract

(57) [Summary] [PROBLEMS] To automatically detect or correct a part whose operation changes according to the specification of a language to which a compiler conforms from a source program described in C language, thereby facilitating program development. A C source program written in C language 2
Enter the pattern whose operation differs depending on the specification that the compiler complies with, for example, K & R specification or standard C specification.
It is detected by analyzing the input source program. A file name in which the source program corresponding to the detected pattern is described, a line number, a name representing the object, and information on the operation are output as a detection message 4. Also, the source program is automatically corrected so that the operation does not change.

Description

DETAILED DESCRIPTION OF THE INVENTION

[0001]

TECHNICAL FIELD The programming language C (JIS X 30
10-1993, ISO / IEC 9899: 1990) This is a check processing method for computer programs created using the C language program. The present invention relates to a computer program check processing method for a language and a program storage medium for realizing the method.

[0002]

2. Description of the Related Art Computer programming language C has several dialects as well as other languages. In one of the traditional dialects,
There is a specification called K & R which is described in "Haruhisa Ishida: Programming language C UNIX style program writing and manners, Kyoritsu Publishing, 1981". Computer programs in the C language according to the K & R specifications have been used for many years, and many programs have been created.

[0003] On the other hand, the standard C specification is determined by supplementing unclear parts of the K & R specification and improving the conventional specifications. Among the differences between the two, the specifications relating to the syntax rules are simple, and therefore, a compiler conforming to the standard C specification has been created which accepts a program created according to the K & R specification. However, no compiler accurately warned of semantic (behavioral) differences.

[0004]

With the standardization of the C language specification, not only a compiler conforming to the K & R specification but also a compiler conforming to the standard C specification has become available.
In developing a program under such circumstances,
It is common practice to create a program that is interpreted as intended only by a compiler that conforms to one of the specifications, but the program is designed so that conforming specifications are interpreted as intended by multiple compilers with different specifications. You may want to create In this case, since there is a semantic difference between the two specifications, there is a problem that a source program must be created with sufficient care under appropriate restrictions.

Further, when a previously created source program is operated as intended by using a compiler conforming to the specification that was not the target at the time of creation, especially when the scale of the program is large, where to modify It was very difficult to determine what was good.

SUMMARY OF THE INVENTION The present invention solves the above-mentioned problems, and automatically detects, from a source program written in C language, a portion where the operation changes according to the specification of the C language to which the compiler conforms, and further prevents the operation from changing. It is an object of the present invention to provide a means for automatic correction if it can be corrected.

[0007]

[Means for Solving the Problems] Differences in syntax and semantics from K & R specifications and standard C specifications, especially integer types (char type, short type, int type, long type and their unsigned types) ), A pattern (operation for the object and operation between the objects) that causes a difference with respect to the object is extracted. The corresponding pattern is identified and detected from the source program described in the C language by a file name, a line number, a name representing an object, and an operation.

[0008] In advance of detection from a source program, a situation may arise in which one source program must be interpreted differently depending on the specifications of the compiler. For example, if the size of a long type object is 4
When it is a byte, the K & R compiler interprets the next operation of program 1 as the same as program 2, but the standard C compiler interprets the same as program 3.

[Program 1] #if 0xffffffff> 0 f (int a) ｛return a;｝ #else g (int b) ｛return b;｝ #endif [Program 2] g (int b) ｛return b;｝ [Program 3] f (int a) {return a;} In this way, in preparation for a case where a different interpretation is required depending on the specification with which the compiler conforms, it is determined according to which specification the detection should proceed before the check.

For example, patterns extracted from a source program as patterns having a difference in the operation of a program as a result of translation between a compiler conforming to the K & R specification and a compiler conforming to the standard C specification are the following patterns.

(1) Three-letter notation Example ?? = (2) Identifier named entry (3) Identifier named const, volatile, signed, void (4) External declaration in block (5) Integer constant Suffix u, U, ul, UL, U to specify the type of
l, uL, lu, Lu, lU, LU (6) Suffixes f, F, l, L, l for specifying floating-point constants
f, fl, lF, Fl, Lf, fL (7) Wide-angle character constant, wide-angle character string literal (8) Character constant consisting of two or more characters (9) Character constant \ a, \ v, \ ", \? (Here, the notation \ is a substitute for the half-width reverse slant "＼".) (10) Concatenation of character strings Example) "abc""def" is interpreted as "abcdef" in the standard C specification, but K & R Strings cannot be concatenated in the specification.

(11) unsigned short type or unsigned c
<, <=,>,> =, *, / for har type and signed integer type
Operation (12) <, <=,>,> =, *, / operation between unsigned short type or unsigned char type and negative integer constant (13) Integer constant and sign with values greater than or equal to 2 ^{31 and} less than 2 ³² <, <=,>,> = Operations with assigned types (14) Declaration of pointer variables to functions (15) Unary + operator (16) Right side of shift operation is not long type or unsigned long type Is a long type or unsigned long type (17) &&, ‖, unary &,! , Cast operation (18) Undefined ptrdiff_t, size_t, wchar_t type object declaration (19) Long double type object declaration (20) Function type, array type object declaration (21) Prototype declaration (22) Return type is structure (23) Definition of external variables with initialization (24) Initialization of union (25) Initialization of arrays, structures and unions declared as automatic variables (26 (27) Function definition with variable number of arguments (28) Function call with variable number of arguments (29) Function definition with parentheses in parentheses (30) ) Declaration of external variable without definition (31) Preprocessing directive line with a blank character before # (32) Preprocessing directive including defined (33) Preprocessing directive of #elif (34) File specification of #include Macro exists (35) Macro argument in character or character string in substitution list of function-form macro definition (36) Calling a macro whose definition has a macro argument in a character or character string in the permutation list (37) Macro definition of a recursive definition (38) Calling a macro of a recursive definition (39) #, ## Macro definition using operators (40) Macro call using # and ## operators (41) Preprocessing directive in the form of "#line preprocessing lexical string line feed" (42) In the form of "#error" Preprocessing directive (43) Preprocessing directive in the form of “#pragma” (44) Preprocessing directive in the form of spaces other than “#” The above patterns (1) to (44) are detected from the source program. Output the detection result. If the above pattern can be detected, it is possible to cope in advance with a situation in which an unexpected operation occurs due to a difference in operation due to a specification conforming to the compiler. In addition, whether or not to detect each pattern can be designated before the inspection so that only a specific pattern can be detected. According to the detection result,
It is also possible to automatically correct the inspected source program.

[0013]

FIG. 1 is a schematic explanatory diagram of the present invention. In the figure, 1 is a processing device including a CPU and a memory, 2 is a C source program to be inspected, 3 is designation information such as inspection conditions and suppression conditions, 4 is a detection message of an inspection result, and 5 is a corrected source automatically corrected. Program, 10 is C
It represents a C program inspection unit that detects a part having an operation difference from a source program according to the specification of a language to which the compiler conforms.

The C program checking unit 10 receives the C source program 2, performs syntax analysis and semantic analysis of the C source program 2, and detects a pattern whose operation differs depending on the specification of a language to which the compiler conforms. At this time, if there is the specification information 3 of the inspection condition specification or the suppression condition specification, it is detected according to the condition.

The C program checking unit 10 describes a pattern portion detected in the C source program 2 as a description whose operation does not change even if the specification with which the compiler conforms changes.
Alternatively, it has a means for automatically correcting the description so that the intended operation is performed.

FIG. 2 is a module configuration diagram according to an embodiment of the present invention. The C program checker 20 and the preprocessor 24 in FIG. 2 correspond to the C program check unit 10 in FIG. In this example, C program checker 2
0 and the preprocessor 24 operate on the UNIX operating system, and
A source program described in a language is input, syntax analysis and semantic analysis are performed, the above-described pattern is detected, and a detection message 4 of a detection result is output to a file or a terminal.

Means for checking a C program is as follows.
Two logical functional divisions (customizer 23, preprocessor 24, checker body 21, postprocessor 22)
, The customizer 23 and the preprocessor 2
4, and three load modules of the C program checker 20 (FIG. 2).

The customizer 23 is executed only once when the checker of the C program is started, and a default information file 30 that describes an option specified when the C program checker 20 is started and how to interpret when the start option is not specified is specified. Customize file 31
Then, the customization information table file 35 is created.

The created customization information table file 35 contains information on which case should be inspected,
sizeof (char) value, sizeof (short) value, sizeof (int)
Value, sizeof (long) value, size_t, ptrdiff_t, w
It stores the type of char_t, information on the directory in which the header file referenced by the source program is located, options when starting the program, environment variables, and the like. Here, the options at the time of starting the program have contents similar to those of the UNIX C compiler. Header files, environment variables, and the like are known in UNIX systems and the like, and thus detailed descriptions thereof will be omitted.

The preprocessor 24 has a source file 3
2, prototype file 33, macro definition file 3
4 is read, and lines starting with # (line control, file import, macro definition) and macro expansion described in the C source program are expanded, and if a portion corresponding to the above pattern is found, it is output to the error file 37. Then, the contents of the macro expansion are output so that the checker body 21 reads them. This file is shown as an intermediate file 36 in FIG.

The checker body 21 includes a preprocessor 24
Reads the intermediate file 36 output by
A semantic analysis is performed, and if a portion corresponding to the pattern is found, the information is output to the error file 37.

The post-processor 22 uses the pre-processor 24 and the checker body 21 to execute the error file 3
7 are merged, edited according to the contents described in the customization information table file 35,
These are output as a detection message 4. If the source program can be corrected according to the contents described in the customization information table file 35 so that the operation does not change even if the size of the integer type object changes, the correction result is automatically corrected and the correction result is corrected. Output to file 40.

As described above, each module operates in order,
The source file 32 storing the created C source program is read, and the location that matches the pattern is detected, including the file name and line number, the pattern and its constituent identifiers or integer constants.

The files used as auxiliary in the above processing will be briefly described. The customization file 31 is a file describing how to interpret when an option that can be specified when the C program checker is started is not specified.

The default information file 30 is a file for specifying information that is not specified by an option when the C program checker 20 is started, and defines, for example, macros and types in the same manner as defined in the source program. This is used by the C program checker 20 to define an identifier having the name of the processor or operating system (OS) defined internally by the C compiler.

The message file 38 is a file that stores a template of a message output by the C program checker 20 (a message excluding a file name, a line number, and an object name to be filled at the time of output).

The operation result file 39 is as follows. In the C language, an integer-type object smaller than the int type is once treated as an int or unsi
It is operated after being converted to gned type (this conversion is called promotion). This transformation depends on the case. For example, when sizeof (int) = 4 and sizeof (short) = 2,
In the case of K & R, the operation is performed after the unsigned short type is converted to the unsigned type. In the case of the standard C, the operation is performed after being converted to the int type. The calculation result file 39 is used for this processing, and describes and saves to which type each type of object is converted in each case.

Customization information table file 35
Is a file edited by analyzing the customization file 31 and the startup options. The intermediate file 36 is
This is a file that outputs a result of expansion of #include, #define, and macro by the proprocessor 24 and a list of defined symbols.

The error file 37 is stored in the preprocessor 2
4, a file for temporarily storing the content detected by the checker main body 21; The symbol tables 50 to 52 are tables for storing symbol information in the program.
The token table 53 is a table that stores information of units delimited by delimiters such as parentheses and colons in a program.

In general, in developing a C program, one of the following cases is often used as a development condition. [Case 1] K & R only as a compiler specification [Case 2] Standard C (ANS
I) only [Case 3] K & R and standard C as compiler specifications
(ANSI) The range of char type values is also a development condition.

Therefore, in order to enable the inspection corresponding to the various development conditions as described above, the inspection condition can be designated to the C program checker 20. FIG.
FIG. 4 is an explanatory diagram of designation of inspection conditions.

FIG. 3A shows options regarding specifications to be complied with by the compiler.
Any of three options, "NSI only" and "K & R and ANSI" can be designated. Also, FIG.
(B) is a choice regarding the range of the char type value.
The search condition can be specified from "only non-negative", "some negative", and "any". Here, "K & R and A
If the conditions of "NSI" and "any" are included, there is an intention of the program developer to operate the program to be inspected in some environments. Therefore,
The location where the operation changes under the conditions including these is detected from the program.

Since there are only the inspection conditions corresponding to the product in each of FIGS. 3A and 3B, there are 3 × 3 = 9 inspection conditions. Further, in order to prevent the unnecessary detection message 4 from being output or unnecessary unnecessary automatic correction, it is possible to specify a suppression condition for the C program checker 20.
A file and a pattern can be selected as a target of the suppression condition. In the specification of the target file, a line of a file and a program that is not detected even if the pattern is present can be specified. In the specification of the target pattern, of the patterns (1) to (44) described above, a pattern for which detection is to be suppressed can be specified.

Next, an example of automatic correction after inspection will be described. FIG. 4 shows an example of automatic correction for a C source program. For example, assume that the inspection target is a C source program 2 as shown in FIG. Where K & R
It is assumed that it is not desired to change the operation between the specification and the ANSI specification.

With respect to the C source program 2, when the above-described pattern extraction is performed, "(11) unsigned short type or unsigned char type and signed integer type <, <=,>,
> =, *, / Operation ”.

In this program, the "i <us" portion (i
And the value of us) change between the K & R specification and the ANSI specification. This is because, in the K & R specification, the type after promotion of unsigned short type is unsigned type, whereas A
This is due to the int type in the NSI specification. Therefore, in order to prevent the operation from changing between the K & R specification and the ANSI specification, it is necessary to modify the modified source program 5 as shown in FIG. That is, in order to eliminate the difference in operation, the types of variables to be compared in magnitude, such as “i <(int) us”, are previously matched. Such automatic correction can be realized by preparing a routine corresponding to the pattern.

The output of the inspection result for the C source program 2 shown in FIG. 4 is, for example, "file name: line: i
And us are K & R / ANSI-dependent messages. Even if automatic correction is not performed, the detection message can alert the program developer.

In the detection message, the "file name" part is the file name of the file storing the C source program 2, and the "line" part is "i <u".
The line number of the line in which "s" is described is embedded.

FIG. 5 is a flowchart of the preprocessor 24 shown in FIG. First, in step S1, the preprocessor 24 registers a process to which control is transferred when an error is interrupted. Next, environment variables and startup options are acquired and set in the internal table (S2). Further, the token table and the symbol table are initialized (S3, S4), and then the customization information is obtained and the customization information table file 35 is initialized (S5). Further, the macro definition file 34 and the prototype file 33 are read, and internal initialization is performed (S6).

After the above initialization processing, in step S7, the programs to be inspected are sequentially read from the source file 32. If it is determined in step S8 that the line starts with “#”, the process proceeds to step S9. Determine whether it is the next preprocessing command.

# If, # ifdef, # ifndef, # elif, # endif, # else,
# include, # define, # line, # error, # pragma, # ident If any of these, the processing corresponding to the preprocessing instruction is performed (S10), and it is determined whether or not the pattern matches the detection pattern (S11). ). If it does not match the detection pattern, the process returns to step S7. If it matches the detection pattern, a diagnostic message is output to the error file 37 (S12), and the process returns to step S7.

If it is determined in step S9 that the command is not a preprocessing command, a syntax error message is output (S1).
3) As an error, the process proceeds to the interruption process (S14), and the process ends.

If it is determined in step S8 that the line does not start with "#", the flow advances to step S15 to perform output to the token table and output to the symbol table as performed by a normal compiler or the like (S15). , S1
6), and output them to the intermediate file 36 (S1)
7). The above processing (S7 to S17) is performed using the source file 3
2 is exhausted (S18), and when the source file 32 is exhausted, the checker main body 21 is started (S19).

FIG. 6 is a flowchart of the checker body 21 shown in FIG. As in the preprocessor 24, the checker main body 21 first registers a process to which control is transferred when an error is interrupted in step S21. Next, environment variables and start options are acquired and set in the internal table (S22). Next, a token table is read (S23), a symbol table is read (S24), and then customization information is acquired and initialized internally (S25).

After the above initialization processing, in step S26, the output of the preprocessor 24 is read. The syntax is analyzed and a syntax tree is generated internally (S27). And
It is checked whether the parse tree matches the detection pattern (S2
8) If they match, a diagnostic message is output to the error file 37 (S29).

Next, the sentence is analyzed to convert the sentence into a predetermined internal format (S30). Processing such as syntax analysis and semantic analysis is the same as the processing performed by a normal compiler, and a detailed description thereof will be omitted.

After the sentence is converted into the internal format, it is checked whether or not the internal format matches the detection pattern (S31).
If they match, a diagnostic message is sent to error file 3
7 (S32).

The above processing (S26 to S32) is performed until the output files of the preprocessor 24 are exhausted (S3).
3) When the output files run out, the post processor is started (S34).

FIG. 7 shows the post processor 22 shown in FIG.
It is a flowchart of FIG. The post processor 22 first reads the customization information table file 35 in step S41. Next, the error file 37 is read (S42), and the read error file 3 is read.
The diagnostic messages having the contents of No. 7 are rearranged in the order of the file to be diagnosed and the line, and an intermediate file is created (S4).
3).

Next, from the created intermediate file, the diagnostic message to be inhibited by the inhibition condition designation is deleted, and the intermediate file is updated (S44). In addition, a diagnostic message relating to the diagnostic target file to be suppressed is deleted from the contents of the intermediate file (S4).
5).

The content of the remaining intermediate file is output as a detection message 4 to an output device such as a printer, a display, or a file (S46). If automatic correction is possible according to the specification from the user and the detection result, FIG.
The program is automatically corrected as described above, and the process ends.

[0052]

[Embodiment] By using the above C program checker, about 15
Investigation of the M (15 million) lines of C source programs revealed that approximately 10K (10,000) lines had a change in operation between K & R and standard C at a rate of one place.

[0053]

As described above, according to the present invention,
Because the specification of the language to which the compiler conforms is different, it is possible to automatically detect the part where the operation of the program as a result of the compilation changes, so that it is easy to develop the program according to various compilers and to prevent the operation error. Can be prevented. Further, by providing the automatic correction function, it is possible to further reduce labor and improve reliability.

[Brief description of the drawings]

FIG. 1 is a schematic explanatory diagram of the present invention.

FIG. 2 is a module configuration diagram according to the embodiment of the present invention.

FIG. 3 is an explanatory diagram of inspection condition designation.

FIG. 4 is a diagram illustrating an example of automatic correction of a C source program.

FIG. 5 is a flowchart of a preprocessor.

FIG. 6 is a flowchart of a checker main body.

FIG. 7 is a flowchart of a post processor.

[Explanation of symbols]

 DESCRIPTION OF SYMBOLS 1 Processing unit 2 C source program 3 Specification information 4 Detection message 5 Corrected source program 10 C program inspection unit

Claims (5)

[Claims] 1. A processing method for detecting, from a computer program created by using a C language, which is a programming language, a portion whose operation changes according to a specification of a C language to which a compiler conforms, comprising: A process of inputting a program, a process of detecting, from the input source program, a pattern whose operation differs depending on the specification of the C language to which the compiler conforms, and a process of outputting source program information corresponding to the detected pattern A computer program inspection processing method in C language, the operation of which changes according to specifications. 2. A compiler conforming to a first specification and a second compiler
2. The method according to claim 1, wherein when a pattern whose operation is changed by a compiler conforming to the specification is detected from the source program, the inspection is performed by specifying one of the first specification and the second specification. C language computer program inspection processing method whose operation changes according to specifications. 3. The method according to claim 1, further comprising: a step of inputting a designation of whether or not to detect each pattern before the inspection, and a step of outputting a detection result of only the specified pattern. The operation changes according to the specifications of C
Language computer program inspection processing method. 4. A processing method for detecting, from a computer program created using a C language, which is a programming language, a portion whose operation changes according to a specification of a C language to which a compiler conforms, wherein a source written in the C language is used. A process of inputting a program, a process of detecting, from the input source program, a pattern whose operation differs depending on the specification of the C language to which the compiler conforms, and a process of detecting a source program corresponding to the detected pattern in a C language conforming to the compiler. Automatically changing the operation so that the operation does not change or become a predetermined operation even if the language specification changes. C language computer program inspection processing method, the operation of which changes according to the specification. 5. A computer-readable storage medium which stores a program for detecting a portion where an operation changes according to a specification of a C language conforming to a compiler from a computer program created using a C language which is a programming language. A procedure for inputting a source program described in C language, a procedure for detecting a pattern whose operation differs depending on the specification of the C language to which the compiler conforms from the input source program, and a procedure corresponding to the detected pattern. Output the information of the source program to be executed, or automatically execute the procedure of automatically modifying the source program so that the operation does not change or the predetermined operation is performed even if the specification of the C language to which the compiler conforms changes. A program storage medium storing a program.