JP4827418B2 - Conditional compiling identifier management method, computer program creation support apparatus, and program - Google Patents

Description

  The present invention relates to a method for managing a conditional compilation identifier included in a program source code (hereinafter referred to as source code), a computer program creation support apparatus, and a program, and more particularly to detecting a spelling error in an identifier and performing conditional compilation (Conditional compilation). The present invention relates to an identifier management method capable of reliably performing (Compilation), a computer program creation support apparatus, and a program.

  In recent years, applications have become multifunctional and diverse, and in proportion to this, preprocessor instructions (pre-processing instructions that are executed on the source program before compiling, replacing character strings and valid / invalid parts of the program) The pre-processing using the) is frequently used, and the source code is also large and complicated. As a result, debugging is complicated and takes time. Patent Document 1 introduces a program editor that has a function of analyzing a preprocessor instruction in a source code and visually displaying the result on an editor screen so that an error in the preprocessor instruction can be detected. .

  Patent Documents 2 and 3 introduce an editor capable of highlighting a place where there is a possibility of an input error during source code input work, and Patent Document 4 is used in a program. A variable data processing device for checking the consistency of existing variables is introduced.

  FIG. 15 is a flowchart showing a conventional program creation procedure. Referring to FIG. 15, first, a program is created / edited using an editor or the like (step 1-1), and conditional compilation is manually set at a required location (step 1-2). This conditional compilation setting is often used when machine dependency is involved or during debugging, and the programmer decides from the source code or design document and sets the conditional compilation preprocessor and its identifier at the required location. Is called.

  Subsequently, compilation is performed (steps 1-3 and 1-4). FIG. 16 shows an example of a conditional compilation command. In this case, identifiers “DEBUG” and “TEST” used after the conditional compilation preprocessor instruction in the source code are validated. The part from the #ifdef DEBUG line to #endif in the code is the target of compilation. During this compilation process, errors are checked. If there is a grammatical error, the compiler displays an error (including a grammatical error such as an input error in the preprocessor instruction itself). If an error is displayed, the program is again corrected (step 1-1). On the other hand, if there is no error, the debugging process is started.

  In the next debugging operation, various evaluations are performed to evaluate whether the program is operating according to the specifications (steps 1-5 and 1-6). Here, if a malfunction is noticed, a logical error of the program is found by using various tools or by actually reading the source, and the source code is corrected (step 1-1). If no error is found, the creation of the program ends.

JP 2000-148508 A JP-A-5-341976 JP-A-11-73305 JP-A-7-78072

  Arbitrary characters can be defined as an “identifier” following the preprocessor instruction used in conditional compilation, which is very convenient, but on the other hand, the line containing the preprocessor instruction is treated as being grammatically independent. It can be said that the following burden has arisen. The first problem is that in the error check at the time of compilation, even if there is an input error, it is determined that such an identifier is set and cannot be detected. For example, as shown in FIG. 16, even though the identifier “DEBAG” (input error) is defined in the source code while “DEBUG” is specified in the compile command, the compiler does not make an error and the identifier “DEBUG” Perform conditional compilation. Thus, an identifier input error can only be detected by debugging work, and if a spelling error of a conditional compilation identifier occurs, debugging work will be forced, and large and complex source code It is a considerable burden.

  The second problem is that when specifying an identifier for conditional compilation, it is necessary to manually set many identifiers, so the same identifier should be specified, but another identifier is set. There was always a risk of oversight and mis-designation. Large-scale source code is programmed by multiple people, and in addition, since a single source code supports many product types and versions, preprocessor instructions for conditional compilation may be specified in complex ways. . In addition, if the source code is large and complex, it is difficult to verify whether conditional compilation is correctly set, which hinders the efficiency of program development work.

  In this respect, since Patent Document 1 visually displays the interpretation result of the preprocessor instruction on the editing screen, even if the debugging work is reduced, each of the above problems is not solved in a large-scale and complicated source code. It does not solve the point fundamentally. Further, even with the techniques of Patent Documents 2 and 3, in the case of an identifier for conditional compilation, it is not unambiguous and it is difficult to apply what is determined as an input error. The technique described in Patent Document 4 is also for checking the consistency of variables peculiar to an interpreter language, and this kind of problem can be detected at the time of compilation in a compiler language. It is what.

According to a first aspect of the present invention, there is provided a method for managing an identifier for conditional compilation included in a program source code by a computer, wherein the computer scans the program source code and at least performs conditional compilation. A step of generating and displaying an identifier list including the identifier used subsequent to the preprocessor instruction, the number of occurrences thereof, and a definition state indicating whether or not the identifier is defined, and at least when a compile command is input, There is provided a method for managing conditional compilation identifiers, including the step of the computer setting an identifier selected by the user from the identifier list as an identifier for conditional compilation .

According to the second aspect of the present invention, the program source code is scanned, and at least the identifier used subsequent to the preprocessor instruction for conditional compilation, the number of occurrences thereof, and whether the identifier is defined. An identifier list output unit for generating and displaying an identifier list including the definition state indicating the state, and at the time of inputting a compile command, by selecting an arbitrary identifier from the identifier list, setting an identifier for conditional compilation There is provided a computer program creation support apparatus including an identifier input receiving unit .

  According to the third aspect of the present invention, the program source code to be checked is scanned, and at least the identifier used after the preprocessor instruction for conditional compilation, the number of occurrences thereof, and the identifier are defined. An identifier for conditional compilation by receiving a selection of an identifier from the identifier list from the user at the time of inputting a compile command, at least when a compile command is input There is provided a computer program creation support program for causing the computer to execute a process of accepting the setting.

  According to the present invention, it is possible to find a spelling error or inconsistency of an identifier by referring to an identifier list in which at least the number of appearances and a definition state are written.

  Next, a preferred embodiment of the present invention in which the present invention is applied to an integrated development environment (Integrated Development Environment) will be described in detail with reference to the drawings. FIG. 1 is a schematic configuration diagram of a computer program creation support apparatus according to the present invention. Referring to FIG. 1, a computer program creation support apparatus includes a storage device 11 that stores and holds source code and object code, an identifier list output unit 12 that performs operations described later, an identifier input reception unit 13, and a compiler 15 (these are A computer program that uses hardware resources of a computer, and the former two will be described in detail later.) In addition to a monitor 14 for displaying a list of identifiers, an editor, a debugger, and other tools required for programming, not shown Has an environment that can be integrated and handled.

  FIG. 2 is a diagram showing a table configuration for creating an identifier list managed by the identifier list output unit 12. Referring to FIG. 2, ID (serial number), identifier name (character string), number of appearances (number of appearances in the source file), setting (use = ON / non-use = OFF), definition, highlighting (ON / OFF) Field is provided, and information of an identifier identified by the ID can be stored. In the definition field, “OFF” indicating that there is no part defining the identifier in the source file, and “ON (” indicating that the identifier is defined by the preprocessor instruction #define in the source file. “Define)”, “ON (Undef)” indicating that the identifier is defined by the preprocessor instruction #undef in the source file, and the identifier is defined by the preprocessor instructions #define and #undef in the source file. “ON (DefineUndef)” indicating “” is described. The identifier list output unit 12 selects and displays appropriate items in this table and provides them to the user.

  FIG. 3 is a matrix for obtaining the four states of the definition column in the table structure of the identifier list described above. Referring to FIG. 3, when the identifier is defined by #define in the source file, define_flag is 1, and when it is defined by #undef, undef_flag is 1. Any state from ~ ON (DefineUndef) can be obtained.

  FIG. 4 is a flowchart showing a rough flow of program creation when the present invention is applied. Referring to FIG. 4, when the creation / modification of the program is completed (step 3-1), the identifier list output unit 12 executes a process of creating a conditional compilation identifier list from the source code (step 3-2).

  Next, from the identifier list (see FIG. 11) output to the monitor 14, the identifier highlighted as appropriate is confirmed to confirm whether there is a spelling error or inconsistency in the identifier (steps 3-3, 3-4). If there is a spelling error, the program returns to program creation / correction again (step 3-1). On the other hand, if there is no spelling error in the identifier, the identifier to be validated is selected from the identifier list (step 3-5). For example, when CUSTOM, DEBUG2, and VERSION are selected as shown in FIG. 12, the identifier input receiving unit 13 is based on the setting column (RELEASE is declared in the source code; see FIG. 11 legend). Then, a command “-D CUSTOM-D DEBUG2-D VERSION” is issued to the compiler 15.

  Subsequently, a detailed operation (generation of an identifier list) in the present embodiment will be described. FIG. 5 is a flowchart showing the detailed operation in step 3-2 of FIG. First, move to the first line of the source file (step 7-1). Next, a process of reading one line from the source file is performed (step 7-2).

  Next, it is determined whether or not an identifier following #define or #undef has been detected from the read line (step 7-3), and if a corresponding identifier is detected, an identifier new registration process described later is performed. Execute (Step 7-6) and go to Step 7-9.

  On the other hand, if the identifier following #define or #undef is not detected in step 7-3, it is used subsequent to the preprocessor instruction #ifdef, #ifdefine or #elif used in conditional compilation next time. It is determined whether or not an identifier has been detected (step 7-4). If no corresponding identifier is detected, the process proceeds to step 7-9.

  On the other hand, if an identifier subsequent to #ifdef, #if define, or #elif is detected in step 7-4, an identifier having the same name as the detected identifier is next entered in the identifier column of the identifier list table. It is determined whether or not it already exists (step 7-5). Here, if the identifier exists in the table, it means that it has already been detected once or more in the past. Therefore, 1 is added to the number of occurrences of the identifier that matches in the table (step 7-7), and the process goes to step 7-9. move on.

  On the other hand, if an identifier having the same name as the identifier detected in step 7-5 does not exist in the table, a line is added to the end of the table, the ID is assigned, the identifier name is described, and the number of occurrences is 1. The setting, definition, and highlight elements are set to OFF (step 7-8), and the process proceeds to step 7-9.

  Then, when moving to the next line in step 7-9, it is confirmed whether or not the end of file (EOF) has been reached. If it is not the end (EOF), the process returns to step 7-2, and the source Continue the single line read flow from the file. If the end of the source file (EOF) has been reached, an emphasis process necessity determination (see FIG. 7, which will be described later) is executed as to whether or not the identifier included in the identifier list table should be emphasized (step 7-). 11) End this flow.

  FIG. 6 is a flowchart showing the detailed operation in step 7-6 in FIG. If an identifier following #define or #undef is detected from the read line in step 7-3 in FIG. 5, it is determined whether an identifier having the same name as the detected identifier exists in the table ( Step 8-1). If the same identifier already exists in the table, the process proceeds to step 8-3.

  On the other hand, if the same identifier does not exist in the table, add a line to the end of the table, number the ID, describe the identifier name, set the number of occurrences to 0, set, define, and highlight each element OFF Set (step 8-2) and proceed to step 8-3.

  In Step 8-3, it is determined whether or not the detected location of the identifier is a definition in #define. If the definition of the identifier is #define, define_flag in FIG. 3 is set to 1 (step S3). 8-4). On the other hand, when the definition of the identifier is #undef, undef_flag in FIG. 3 is set to 1 (step 8-5).

  Thereafter, this flow is terminated, and control is returned to step 7-6 in FIG. When #define and #undef are detected from the source file in this way, define_flag and undef_flag are updated, respectively, and the definition state of the identifier is finally determined using the matrix of FIG.

  FIG. 7 is a flowchart showing the detailed operation (determination of necessity for highlighting) in step 7-11 in FIG. Referring to FIG. 7, after initialization (step 9-1), identifiers in the table for creating an identifier list are sequentially evaluated (step 9-2).

  First, it is determined whether or not the definition state of the identifier is ON (DefineUndef) (step 9-3). Here, when the definition state is ON (DefineUndef), it is possible that it is an error that one identifier is defined in both # define / # undef in the source. The display is turned on (step 9-8).

  On the other hand, if the definition state is not ON (DefineUndef), it is determined whether the definition of the identifier is ON (define) or ON (undef) and the number of appearances is 0 (step 9). -4). If the definition of the identifier is ON (define) or ON (undef) and the number of occurrences is 0, there is a possibility that the identifier is misspelled. 9-8).

  On the other hand, if the definition state is ON (define) or ON (undef) and the number of occurrences is not 0, only the difference between uppercase and lowercase letters, the predetermined number of characters in the character structure is common, etc. A similar identifier search process is performed to determine whether or not a similar identifier having the same character characteristics as the identifier exists in the table (steps 9-5 and 9-6). If there is no similar identifier, the emphasis process ON setting in step 9-8 is skipped and the process proceeds to step 9-9.

  On the other hand, if a similar identifier exists, it is determined whether or not the number of appearances of the identifier being evaluated (under consideration) is equal to or less than the set value (step 9-7). Here, if the number of appearances of the identifier being evaluated (under consideration) is larger than the set value, the emphasis process ON setting in step 9-8 is skipped and the process proceeds to step 9-9.

  On the other hand, if there is a similar identifier and the number of appearances under evaluation (under consideration) is equal to or less than a set value (eg, 3 is used, which can be set separately by the user), the identifier may be a spelling error. Therefore, identifier highlighting is set to ON (step 9-8).

  When the series of evaluation processes is completed, it is determined whether or not the next identifier exists (step 9-9). If there is a next identifier, step 9-10 (increment process) is performed. Then, the process returns to step 9-2 to continue the evaluation of the next identifier. On the other hand, if there is no next identifier, this process is terminated.

  FIG. 9 is a diagram showing a table for creating an identifier list when steps 7-1 to 7-11 in the flowchart of FIG. 5 are executed for the sample source file shown in FIG. Referring to FIG. 8, how the determination is made will be described. [#Define RELEASE] on the first line is detected, and ID number 1 / identifier RELEASE / number of appearances 0 / setting Off / definition On (define) / Data that is highlighted off is added to the table.

  Next, [#undef DEBUG3] on the second line is detected, and this is also not in the table. Therefore, the data with ID number 2 / identifier DEBUG3 / number of appearances 0 / setting Off / definition On (undef) / highlighting Off is obtained. Added to the table.

  Next, [#ifdef CUSTUM] on the fourth line is detected, and this is also not in the table. Therefore, data with ID number 3 / identifier CUSTUM / number of appearances 1 / off setting / off setting / highlighting off is added to the table. Is done.

  Next, [#ifdef DEBUG3] in the eighth line is detected, but since this already exists in the table, the value of the appearance number of ID number 2 (DEBUG3) of the table is added (changed from 0 to 1). ).

  Next, [#ifdef RELEASE] on the 11th line is detected, but since this also exists in the table, the value of the appearance number of ID number 1 (RELEASE) of the table is added (changed from 0 to 1). ).

  Next, [#ifdef DEBUG3] on the 13th line is detected. Since this already exists in the table, the value of the number of appearances of ID number 2 (DEBUG3) of the table is added (change from 1 to 2). ).

  Next, [#ifdef RELEACE] on the 18th line is detected, but since this is not in the table, the data with ID number 4 / identifier RELEACE / appearance number 1 / off setting / off definition / highlighted on is stored in the table. To be added.

  FIG. 9 shows a summary of the above determination processes. Even in this short source file, RELEASE and RELEACE are similar identifiers (details of the determination will be described later), and since the number of appearances is small, highlighting is set to ON. It is understood that

  FIG. 10 is a table for creating an identifier list generated from another source file. Referring to FIG. 10, the identifiers of ID numbers 1 to 4, 7, and 9 are highlighted off, and it can be determined that there is no problem.

  However, the definition field of the ID number 5 and the identifier “NEW” described six times in the source is On (DefineUndef). This is because both definitions of # define / # undef were detected in the source as described above. Such an indeterminate state is considered to have the possibility of an identifier definition error / spell mistake, so the highlighting is set to ON.

  Further, the ID number 6 and the identifier “OLD” are defined by #undef, and #ifdef, #if define or #elif is not found (the number of appearances is 0). In this case, since there is a possibility of a spelling error, the highlighting is set to ON.

  The ID number 8 and the identifier “RELEACE” are described once in the source, but there is no definition (# define / # undef). In this case, since there is RELEASE having a similar (one character difference) spelling and the number of appearances is small (less than three times), it is determined that there is a possibility of a spelling error, and the highlighting is set to ON.

  FIG. 11 is a table in which the identifier list creation table of FIG. The identifier list creation table of FIG. 10 may be displayed as it is to alert the user. However, in the example of FIG. 11, the table is sorted by the number of appearances, and the definition and setting are collected in the setting column. It is displayed as a symbol, and the highlighting is represented by a “*” at the beginning of the line (see NEW / RELEACE / OLD). In addition, since identifiers that have already been explicitly declared in the source are set with priority over the command line, the status (valid / invalid) is displayed in the setting column as shown in the legend. The check boxes are appropriately set to non-changeable so that they cannot be changed from the table.

  The identifier list is configured so that it can be sorted by the number of appearances (ascending / descending order) or identifier name (dictionary order), so that spelling mistakes and inconsistencies of identifiers can be confirmed from each viewpoint. If the user wants to use the identifier, the user can check the box in the setting column to select it. However, since RELEASE is already defined by #define in the source, it cannot be changed in the selected state, and DEBUG3 and OLD are defined by #undef in the source. It cannot be changed. Since NEW is defined by #define and #undef in the source, it cannot be changed in an indefinite state.

  FIG. 12 shows that the RELEACE is wrong from the list of FIG. 11, returns to the source, corrects the identifier RELEACE as RELEASE, deletes the definition part of the identifier NEW, deletes the definition part of the identifier OLD, and then outputs again. It is a list of identifiers. Referring to FIG. 12, the “*” at the beginning of the line that implies an error is gone. In this state, as shown in FIG. 12, when the user checks the check box in the setting column, the setting value in the identifier list table is turned ON. For identifiers whose definition value is other than Off, the setting value is always Off. In the example of FIG. 12, the setting column is checked as the user uses a plurality of identifiers “CUSTOM”, “DEBUG2”, and “VERSION”. Accordingly, by performing a predetermined operation from this state, it is possible to issue a command “-D CUSTOM-D DEBUG2-D VERSION” to the compiler 15.

  As described above, in the conventional method, when specifying identifiers for conditional compilation, it is necessary to manually set many identifiers, and there is a possibility that spelling errors may occur. According to this, the user is easily prompted to highlight the identifier list and can easily detect an error. In addition, by selecting an identifier to be defined (valid state) from the above-described identifier list, it is possible to reduce the probability of error due to an identifier definition error.

  Further, in the above-described embodiment, an example in which highlighting is performed with an asterisk has been described, but other highlighting such as bolding, color change, and blinking can be employed.

  Next, a second embodiment in which the similar identifier search in the first embodiment is performed more finely will be described. Since the present embodiment is different only in that the similar identifier search process in step 9-5 in FIG. 7 is performed in detail, portions that overlap the already described contents are omitted, and the differences will be mainly described. . FIG. 13 is a flowchart showing a detailed operation performed as the similarity identifier search process in step 9-5 of FIG.

  Referring to FIG. 13, first, an identifier A (ID (x)) and an identifier B (ID (x + y)) for comparison and collation are acquired from a table for creating an identifier list (step 14-1). Subsequently, if one character typo comparison process, one particular character in the identifier is deleted or added, does the remaining part match? Judgment is performed from such a viewpoint (steps 14-2 and 14-3). The specific details will be described later with reference to FIG.

  Here, when it is determined that they match (only one character is greater or less), the process proceeds to step 14-10, where it is determined as a similar identifier.

  On the other hand, if it is determined in step 14-3 that they do not match, then determination is made from the viewpoint of whether or not identifier A and identifier B are only the difference between uppercase and lowercase letters (steps 14-4 and 14-). 5). Here, for example, if it is determined that they match (only a difference between uppercase and lowercase letters), such as DEBUG and debug, RELEASE and ReLEaSE, the process proceeds to step 14-10, where it is determined as a similar identifier.

  On the other hand, if it is determined in step 14-5 that they do not match, then the characters of identifier A and identifier B are compared in order and the number of different characters is counted (step 14-6). Then, it is determined whether or not the number of different characters is a predetermined value n or less (step 14-7). For example, the predetermined value n varies based on the number of characters of the identifier of the comparison source, such as n = 2 when the length of the character string of the identifier is 3 or less, and n = 3 when the length of the character string is 4 or more. It is preferable to make it. For example, if it is determined that they match (such as one different character and less than or equal to a predetermined value n), such as DEBUG and DABUG, RELEASE and RELEACE, etc., the process proceeds to step 14-10 to determine a similar identifier.

  On the other hand, if it is determined in step 14-7 that they do not match, then identifier A and identifier B are compared, and only a certain number of characters or less have been replaced (the number of appearances of each character substantially matches). Judgment is made from the viewpoint of whether or not (steps 14-8 and 14-9). Here, for example, DEBUG and DABUG, RELEASE and RELEACE, REREASE and RELEASE are matched (the difference in the number of appearances of each character is a predetermined value or less) If it is determined, the process proceeds to step 14-10 to determine a similar identifier.

  FIG. 14 is a flowchart showing the detailed operation in step 14-2 of FIG. Referring to FIG. 14, first, a flag is set for an identifier having a long character string length (step 15-1), and the case where both identifiers have the same character string length is excluded (step 15-2). The identifier B is compared in order from the beginning (steps 15-3 and 15-4). If there is a difference, if it is the first difference, a process of advancing the comparison character with the longer character string length is performed (step 15-5) and the comparison is continued (steps 15-6 and 15-7). Finally, if one specific character of either one of the identifiers is excluded, it is determined that the identifiers A and B match each other, “match”, and if they do not match, “no match”. For example, DEBUG and DEBG, RELEASE and RELEASE are determined to be similar identifiers.

  If it is determined in each determination process that a similar identifier exists, the enhancement process ON described in the first embodiment is set (step 9-8 in FIG. 7), and the user is prompted to confirm the source code accurately. It becomes possible.

  As described above, various methods for determining that two identifiers are similar have been described. However, these are merely examples, and other processing may be added, as illustrated in FIGS. 13 and 14. A part of the determination process may be omitted, or the order may be changed. Further, the threshold value used in each determination process can be changed as appropriate. In any case, it is desirable that the logic is such that mistakes that are likely to be mistaken during manual input can be accurately detected.

  Although several embodiments of the present invention have been described above, as is clear from the principle thereof, the technical scope of the present invention is not limited to the above-described embodiments, and a list of identifiers from the source code. It is possible to make various modifications and substitutions without departing from the gist of the present invention, in which the identifier is set and displayed to alert the user and the identifier can be set from the identifier list. Not too long.

  In the above-described embodiment, an example using the C language has been described. However, as is apparent from the principle, a language such as Java (registered trademark), C #, or the like that can be roughly conditional-compiled. Of course, there is no particular limitation.

1 is a schematic configuration diagram of a computer program creation support apparatus according to the present invention. It is a figure showing the example of a table structure of an identifier list. It is an example of the matrix for determining the definition state of an identifier list. It is the flowchart which showed the basic flow of the program creation at the time of applying this invention. It is a flowchart showing the detailed operation | movement in step 3-2 of FIG. 6 is a flowchart showing a detailed operation in step 7-6 of FIG. It is a flowchart showing the detailed operation | movement in step 7-11 of FIG. It is a sample source code for demonstrating embodiment of this invention. It is a figure showing the table for identifier list creation produced | generated based on the sample source file shown in FIG. It is an identifier list table generated from another source file. It is an example of the identifier list comprised in the aspect which is easy to understand visually. It is another example of an identifier list. It is a flowchart for demonstrating the principal point of the 2nd Embodiment of this invention. It is a flowchart showing the detailed operation | movement in step 14-2 of FIG. It is the flowchart which showed the conventional program creation procedure. This is an example command for conditional compilation.

Explanation of symbols

11 Storage Device 12 Identifier List Output Unit 13 Identifier Input Accepting Unit 14 Monitor 15 Compiler

Claims (11)

A method for managing an identifier for conditional compilation included in a program source code by a computer,
The computer scans the program source code;
Generating and displaying an identifier list including at least an identifier used subsequent to a preprocessor instruction for conditional compilation, the number of occurrences thereof, and a definition state indicating whether or not the identifier is defined ; ,
Including, at least when a compile command is input, the computer sets an identifier selected by the user from the identifier list as an identifier for conditional compilation .
An identifier management method for conditional compilation characterized by A computer program creation support device,
An identifier that scans the program source code and includes at least the identifier used following the preprocessor instruction for conditional compilation, the number of occurrences, and the definition status indicating whether the identifier is defined An identifier list output unit for generating and displaying a list ;
An identifier input receiving unit that receives setting of an identifier for conditional compilation by selecting an arbitrary identifier from the identifier list at least when a compile command is input ;
A computer program creation support apparatus characterized by the above. In the computer program creation support device according to claim 2 ,
The identifier list output unit generates and displays an identifier list sorted in the order of characters used for the identifier ;
A computer program creation support apparatus characterized by the above. In the computer program creation support device according to claim 2 ,
The identifier list output unit generates and displays an identifier list sorted by the number of occurrences of the identifier ;
A computer program creation support apparatus characterized by the above. In the computer program creation support apparatus according to any one of claims 2 to 4 ,
The identifier list output unit sequentially selects the identifier from the identifier list, against the other identifier, similar identifier exists that features on one of the identifier and the character structure selected from the identifier list matches, and When the number of occurrences of the identifier of interest is less than a predetermined value, highlighting the identifier portion of the identifier list;
A computer program creation support apparatus characterized by the above. The computer program creation support apparatus according to claim 5 ,
The identifier list output unit, when a character string in which at least one character is deleted and arranged from a character string of one identifier selected from the identifier list and an identifier that matches are detected, Determining a matching similar identifier;
A computer program creation support apparatus characterized by the above. Scans the program source code Ji Ekku subject, at least, an identifier which is used by following the preprocessor directives for conditional compilation and its number of occurrences, a defined state shown whether the identifier is defined, and a process for generating display an identifier list was also shown,
A computer program creation support program that causes the computer to execute processing for accepting setting of an identifier for conditional compilation by accepting selection of an arbitrary identifier from the identifier list from a user at least when a compile command is input. In the process of generating and displaying the identifier list, generating an identifier list in which each identifier is sorted in the order of characters used for the identifier;
The computer program creation support program according to claim 7 . In the process of generating and displaying the identifier list, generating an identifier list in which each identifier is sorted by the number of occurrences of the identifier;
The computer program creation support program according to claim 7 . Furthermore,
A process of sequentially selecting an identifier from the identifier list and checking with another identifier;
If there is a similar identifier that matches the character structure of one identifier selected from the identifier list and the number of occurrences of the identifier of interest is less than a predetermined value, the identifier portion of the identifier list is emphasized. The computer program creation support program according to claim 7, which causes the computer to execute a display process. When a matching identifier is detected with a character string obtained by deleting at least one character from a character string of one identifier selected from the identifier list, it is determined as a similar identifier that matches the character configuration characteristics. thing,
The computer program creation support program according to claim 10 .

Images