JPH07281879A - Application program editing device - Google Patents

Abstract

PURPOSE:To provide an application editing device which complements a function name and an argument name by utilizing definition information when descriptions for calling a function and a procedure are provided in a program by extracting and storing name and type information on a variable defined by a user in the program and name and argument information on the function. CONSTITUTION:In the application program editing device 101, a program definition extraction part 103 which extracts variable and function information defined by the user in the program, a definition information output part 104 which outputs the definition information to the storage device 110, and a program input support part 102 which complements the function name and argument name by utilizing the definition information are provided, and, the definition information is utilized to retrieve the names of the function and argument and the type of the variable with key words, thereby selecting complementation candidates for the function and function argument.

Description

Detailed Description of the Invention

[0001]

BACKGROUND OF THE INVENTION 1. Field of the Invention The present invention relates to an editing device for creating an application program.

[0002]

2. Description of the Related Art A close example of a program editing device known before the present invention is GNU Emacs. GNU Emacs
Has a built-in Lisp interpreter that can be used to supplement system-recognized function and variable names known to the interpreter and user-defined function and variable names while editing a Lisp program.

In addition, the Visual Work-bench, an application creation editor of Microsoft Visual C ++, has a database for storing information indicating the mutual relationships among constants, macros, variables, functions and classes in a program generated from a compiler. It is possible to search the above database by using the names of variables, type specifiers, macros, and classes as keys, and display a list of matching functions and variables.

[0004]

When a user calls a function or procedure in a program according to the conventional technique, the function name and the variable name must be entered without typographical error. In particular, it is difficult to accurately describe function names and variable names of a dozen or more characters. Also, when the program becomes huge, it becomes difficult for the user to grasp the definition information of the functions and variables defined in the program, and when using the previously defined functions and variables, what definition should be made in which file. I had to search for what was there.

The above conventional technique has the following problems. The GNU Emacs complement feature is the GNU Emacs Lisp
Although the name of the function and the variable recognized by the interpreter can be complemented, since the type information of the variable is not recognized, the type of the variable is used to limit the completion candidates.
Function argument completion cannot be performed.

The Microsoft Visual C ++ editor can select functions and variables that can be used in a program by using the names and type information of functions, variables, macros, and classes, but has a complementary function. When editing a program, it is necessary to write the function name and variable name in the program by looking at the result browsed by the user when editing the program.

An object of the present invention is to complement the function and the variable by extracting and storing the name and type information of the variable defined in the program by the user and the name and argument information of the function, and the key input of the user. The object is to provide an application editing apparatus that reduces the number of applications.

[0008]

To achieve the above object, the present invention provides a program definition information extraction unit for extracting information on variables and functions defined in a program by a user, and outputting the definition information to a file. The program editing device is provided with a program information support unit for complementing function names and argument names by using the definition information output unit and the above definition information and similar definition information for the program library provided by the system. When the function and the procedure are called in the program, the program editing device (1) extracts information about variables and functions defined in the program by the user,
(2) Process of outputting the extracted information to a file,
(3) A process of searching the above definition information using the names of the function and the variable and the types of the function and the variable as keys, (4) a process of outputting the search result to a buffer, and (5) a function and a function based on the search result. Performs the process of complementing the variable name.

[0009]

Operation: The program editing apparatus is provided with the name and type information of the variable and the name and type information of the function and the argument information defined by the user in the program, and (1) the name of the function and the variable and the type of the function and the variable. The process of searching the above definition information using information as a key makes it possible to provide the user with complementary candidates. (2) A character string entered by the user,
By the process of matching with the provided complementary candidates, it becomes possible to narrow down the complementary candidates. By repeating these processes, the number of candidates for complementation is limited to one, and it becomes possible to complement functions and variables.

[0010]

【Example】

(Embodiment 1) An embodiment of the present invention will be described with reference to FIGS. 1 to 15.

FIG. 1 is an overall view of an editing apparatus embodying the present invention. Reference numeral 100 is an input / output device, 101 is a program editing device, a program input support unit 102 for complementing a function name and an argument name, a variable name and type information defined by a user in a program, and a function name. It has a program definition extraction unit 103 that extracts argument information, a definition information output unit 104 that outputs the program definition information to a file designated by the user, a buffer 105 that stores a user program, and a buffer 106 that stores a complement candidate. Reference numeral 107 denotes a program local definition that stores information about variables and functions defined in the source file being edited, which are defined by the user and are valid in the file (hereinafter referred to as "program local definition information"). The information storage device 108 is information about user-defined variables and functions that can be used in the entire source program across a plurality of files (hereinafter referred to as "program global definition information").
A program global definition information storage device for storing
09 is a program library provided by the system,
Holds information about system-provided functions. Reference numeral 110 denotes a program storage device that stores a program.

The program editing device 101 stores the source program in the program storage buffer 105 when the user makes a description to call a function and a procedure in the program.
, And the program definition information extracting unit 103 extracts the program definition information. The definition information output unit 104 stores the extracted definition information in the storage devices 107 and 108. The program input support unit 102 searches the storage devices 107, 108, and 109 using the names of the functions and variables and the type information of the functions and variables as keywords, stores the search results in the complement candidate storage buffer 106, and searches for the complement candidates. Based on this, the names of functions and variables are complemented.

FIG. 2 is a diagram showing stored contents of a storage device for storing the program definition information. The program local definition information storage device 107 has a local variable information table 20 and a local function information table 21. The local variable information table 20 is a collection of records having data of variable types and variable names. The local function information table 21 is a collection of records having data of a function type, a function name, and an argument type.

Program global definition information storage device 1
08 has a global variable information table 22 and a global function information table 23. The global variable information table 22 is a set of records having data of a variable type, a variable name, and a file name indicating in which file the variable is defined. The global function information table 23 is a collection of records having data of a function type, a function name, an argument type, and a file name indicating in which file the function is defined.

The program library 109 has a system-provided function information table 24, and the system-provided function information table 24 is a collection of records having data of a function type, a function name, and an argument type.

FIG. 3 is a flow chart for explaining a processing procedure for complementing the function name and the argument name according to the present invention.
Reference numeral 300 denotes a step of performing a key input process from the input device 10, and 301 denotes a step of performing a key input determination and branching the process.

When there is a key input for complementing in step 300, the program being edited is stored in the buffer 106, and it is judged whether the program local definition information is updated in the program being edited or not.
02 and 303 are executed, and if there is an update, the local variable information table 20 and the local function information table 2
Steps 303 and 304 for creating 1 are executed. Three
Reference numerals 05 and 306 are steps for branching the processing according to the character string input to the cursor line. At the cursor line,
If only alphanumeric characters have been entered, step 307 for complementing the function name and variable name is executed. If the cursor line contains ″ (″ and ″, ″,
Step 308 of complementing the function argument is executed. If "=" is entered in the cursor line, step 309 for complementing the function name is executed.

When there is a key input for saving the source program in step 300, the global variable table 22 and the global function table 23 are created,
The steps 310 and 311 of storing the source program in the program storage device 110 are executed.

FIG. 4 is a flow chart illustrating step 304 of creating the program local definition information in FIG. The compile type checking mechanism executes step 400 for extracting the program definition information. 401 is a step of determining whether or not there is a user-defined variable in the program as a result of step 400, and 402 is a step of determining whether or not a user-defined function is included in the program as a result of step 400. Is. If the result of determination in step 401 is that the source program has a variable definition defined by the user, step 403 of registering the variable type and variable name in the local variable information table 20 is executed. If the result of determination in step 402 is that there is a function defined by the user in the source program, step 404 of registering the function type, function name, and function argument type in the local function information table 21 is executed.

FIG. 5 is a flow chart illustrating step 310 of creating the program global definition information in FIG. By the type checking mechanism of compilation,
Execute step 500 of extracting program definition information. Reference numeral 501 is a step of determining whether or not there is an external variable defined externally in the program as a result of step 500, and 502 is a step of determining whether or not there is a user-defined function in the program as a result of step 500. Is. If the result of determination in step 501 is that there is an external variable defined by the user in the source program,
The step 503 of registering the variable type and the file name defined as the variable name in the global variable information table 22 is executed. If the result of determination in step 502 is that there is a user-defined function in the source program, the file type defined as the function type, function name, and function argument type is registered in the global function information table 23.
Execute 04.

FIG. 6 is a flow chart for explaining step 307 for complementing the function name and variable name in FIG. A work buffer "key character string" for storing a character string is prepared, and step 600 for storing one word immediately before the cursor on the cursor line is executed. 601 is
In the step of determining whether or not the complement candidate is stored in the complement candidate storage buffer 106, if the complement candidate is not stored in the complement candidate storage buffer 106, the character string stored in the "key character string" is used as a keyword for the variable. The information tables 20 and 22 and the function information tables 21 and 23 are searched, and the function name matching "key string" or
Step 602, which determines whether there is a variable name, and 6
03, and if there is a function name or variable name that matches the "key string", the matching function name, or
Step 6 of storing the character string of the variable name in the buffer 106
04, and the program input support routine 700 is executed. Function name that matches "key string", or
If there is no variable name, step 605 is presented to the user that there is no complement candidate.

FIG. 7 is a flow chart for explaining the program input support processing routine. Processing routine 700
Enter the value of the complement candidate storage buffer 106 and the work buffer "key character string" that stores the character string to be complemented. If there is one complement candidate stored in the complement candidate storage buffer 106, Comparing the character string stored in "key string" and the character string of the completion candidate, input the remaining part which is not enough in the character string stored in "key string" to the program Steps 705 to 707 are executed in which the storage buffer is cleared and the completion of the complement is returned with a return value. When a plurality of complement candidates are stored in the complement candidate storage buffer 106, the complement candidate list is presented to the user, the character string stored in the "key character string" is compared with the given complement candidate, and the complement candidate is complemented. Steps 702-704 are performed to determine if the candidate is limited to one. As a result of step 704,
When the number of complement candidates is not limited to one, the candidate names having the possibility of complement are stored again in the complement candidate storage buffer 106, and steps 708 to 709 for returning the completion of the complement with a return value are executed.

FIG. 8 is a flow chart for explaining the step 308 for performing the function argument complementing process in FIG. Reference numeral 800 denotes a step for branching the processing by the character immediately before the cursor entered in the cursor line. When the character immediately before the cursor is "(", the editing device 101 inputs the function name up to the program. Is stored in the variable i, and 1 is stored in the variable i representing the number of the argument currently undergoing the complement process, the function name input to the program is extracted, and the extracted function name is used as a key for the function information table 21. , 23 and 24 are searched, and it is determined whether there is a matching function name. Steps 801 to 8
Execute 04.

As a result of step 804, if there is no matching function name, step 813 of presenting the error of the function name input to the program to the user is executed, and if there is a matching function name, the table pointer is matched. The address of the table is stored, the number of function arguments that match the variable n representing the number of function arguments is stored, and the argument number i and the number of function arguments n that are currently undergoing complement processing Steps 805 to 807 are executed.
If i is larger than n in step 807, the table pointer is cleared and the process returns to the key input process step 816.
When i is less than or equal to n, the processing routine 900 that presents the function information indicated by the table pointer to the user and selects the complement candidate of the function argument is executed. Processing routine 9
As a result of 00, if there is an argument complement candidate, the processing routine 700 for supporting the input of the program is executed. If the function argument is complemented as a result of the processing routine 700, i and n are compared, and if i and n are equal, ");" is input to the program. Otherwise, "," is input to the program, and 1 is added to i to complement the next argument.

In step 800, when the character immediately before the cursor is ",", the number of "," described in the cursor line is calculated, and the number obtained by adding 1 to the number of "," is stored in i. Step 817 is executed. This allows
The editing device 101 can recognize the number of arguments of the function currently input to the program. Reference numeral 818 denotes a step of determining whether or not the table address is stored in the table pointer. If the table address is stored, the processing of step 807 and thereafter is executed in the same manner as described above, and if not stored, the processing of step 802 and thereafter is executed. Execute the process.

If one character before the cursor is an alphanumeric character in step 800, step 819 for storing one word up to "(" or "," before the cursor in the work buffer "key character string" is executed. Similarly, step 8
The following processing is executed. FIG. 9 is a flowchart illustrating a processing routine 900 for selecting a complement candidate for a function argument. The processing routine 900 inputs the table pointer obtained in step 308 for complementing the arguments of the function and the variable i representing the number of the argument currently undergoing the complementing processing, and from the function information table indicated by the table pointer. Step 901: extracting the type information of the i-th argument of the function, searching the variable information tables 20 and 22 using the extracted type information as a key, and determining whether there is a variable that matches the i-th type of the function To 903 are executed. If there is a variable that matches the type in step 903, the matching variable name is stored in the complementary candidate storage buffer 106, and steps 904 and 905 that return the completion candidate as a return value are executed. If there is no completion candidate, inform the user that there is no matching variable,
Step 9 to return the return value that there is no complement candidate
Steps 06 and 907 are executed.

FIG. 10 is a flow chart for explaining the step 309 for complementing the function name in FIG. The one word before "=" entered in the program is stored in the work buffer "key character string", the variable information tables 20 and 22 are searched using the character string stored in the key character string as a keyword, and the key Steps 1000 to 1002 for determining whether there is a variable name that matches the character string stored in the character string are executed. Step 1002
As a result, if there is no variable name that matches the key string,
The step 1007 of presenting the error of the variable name input to the program to the user is executed. If there is a variable name that matches the key character string, the type name of the variable that matches the work buffer "key character string" is stored, and the function information table 21 is stored with the character string stored in the key character string as a key.
23 and 24 are searched, and it is determined whether or not there is a function with a type name that matches the key character string.
005 is executed. If there is no matching function as a result of step 1005, step 1008 is executed to present to the user that there is no complementary candidate. If there is a matching function, step 1006 of storing the matching function name in the complementary candidate storage buffer 106 is executed, and the program input support processing routine 700 is executed. Figure 11
FIG. 8 is a diagram illustrating an actual example of creating program global definition information when a source program is saved. When the user inputs a key to save the program 1101, there are externally defined external variables "Number" and "Name" and a user-defined function "Myfunc" in the program 1101. The variable name "Number", the variable type name "int", and the file name "Myfile.c" of the program 1101 are registered. Register the variable "Name" in the same way. Also,
The function name “Myfunc”, the function type name “int”, the function argument type name “char *”, and the file name “Myfile.c” of the program 1101 are registered in the function information table 23.

A series of processes for complementing function arguments will be described with reference to FIGS. 12 to 14 as an actual example. 12
FIG. 8 is a diagram illustrating an actual example of creating program local definition information. In the program 1200, user-defined variables "label", "list", and "text"
Then, since there is "string", the variable name and the variable type name are registered in the variable information table 20. In addition, the program 120
Since 0 has no user-defined function, the function information table 22 is not created.

FIG. 13 is a view for explaining an actual example of creating the program local definition information when there is a key input for complementation. Function name "My entered in Figure 12
Function information table 21 with fucn ″ as the keyword
, 23 and 24 are searched. Since the function “Myfunc” is registered in the function information table 23, it can be determined that the number of arguments is one and the type is char *. Then the variable type name ″
Variable information table 20 using char * ″ as a keyword
And search for 22. The variable of char * type is "Name" registered in 22 and "text" registered in 20.
And the complementary candidates can be narrowed down to three, and the complementary candidates are displayed in the window 1202.

FIG. 14 is a diagram for explaining an actual example of complementing function arguments. Select the variable name to be used from the completion candidates displayed in the window 1202, and select program 1
Enter up to 200 parts that can be limited to one complement candidate,
When the key for complementing is input, the editing device 101 inputs the remaining part of the variable name into the program 1200.

FIG. 15 is a diagram for explaining the function of presenting the definition of the variable to the user when complementing the function name. When the variable name of the completion candidate displayed in the window 1202 is picked with the mouse cursor 1500, the portion in which the variable is defined is displayed in the window 1501. If the picked variable is in the program being edited, the variable being searched is used to search the program being edited, and if it is not in the program being edited, the definition information can be searched for in the global definition. Since the file names defined in the table 22 are registered, they can be easily searched.

(Second Embodiment) FIG. 16 shows another embodiment of the present invention.

FIG. 16 is a diagram for explaining an actual example of complementation using members of a structure. A table 1601 for storing information on the structure defined in the program is prepared. Reference numeral 1601 is a collection of records having the structure tag (type) name, the member name of the structure, and the type information data.

In the program 1600, when the user complements the argument of the function "Myfunc" previously defined, the definition information of the structure "person" is added to the structure information table 16
Stored in 01, variable name and type name of variables "A" and "B""
The person ”is stored in the local variable information table 20.

Using the function name "Myfunc" as a key, the function information tables 21, 23 and 24 are searched to determine the number and types of function arguments. In this example, the function "Myfunc" has one argument and the argument type is "char *" type.

Next, the variable information tables 20 and 21 and the structure information table 1601 are searched using the argument type "char *" as a key, and it is determined whether or not there is a "char *" type variable. In this example, the variable of type "char *" is the global variable "Name" and the member "name" of the structure "person".
And "addr" and "tel" are determined. However, since the member name of the structure is not a candidate for completion as it is, the tag information "person" is used as a key to search the variable information table and select the "person" type variable. In this example, since the "person" type variables are "A" and "B", a completion candidate such as "A. name" is created. By extracting and storing the information about the members of the structure in this way, the complementing process can be similarly performed on the structure members.

(Embodiment 3) FIG. 17 shows another embodiment of the present invention.

FIG. 17 is a diagram for explaining an actual example of complementation using members and member functions of a C ++ language class.

A table 1701 for storing information on the members of the class defined in the program and a table 1702 for storing information on the member functions of the class are prepared. 1701 is a collection of records having data of class name, base class name, member name and type information. 1702 is a collection of records having data of class name, base class name, member function name, type information, and argument information.

In the program 1700, when complementing a member function of a user-defined class, the class "Pers
Definition information of "on" is added to the class member information table 1701.
And the class member function information table 1702 and the object name and type name “Person” of the object “A”.
Is stored in the local variable information table 20. An object is a variable declared using a class.

In the case of this example, since "A.Get" has been input to the program, the variable information tables 20 and 21 are searched using the object name "A" as a key, and the object "
Determines the class type of A ″, in this case “A”
Since the class of is "Person", the class member function information table 1702 is searched with "Person" as a key,
Determine if there is a corresponding class. If there is a corresponding class, search for a member function that can be matched with "Get" in the member functions of that class and the base class of that class. If there is a complementary candidate that can be matched, the complementary candidate is displayed in the window. In this case, it is limited to "GetName", so enter the rest into the program.

By extracting and storing the information about the class in this way, the complementing process can be similarly performed on the members and the member functions of the class.

[0043]

According to the present invention, the name and type information of variables used by the user in the program, and the name of the function and the type and argument information of the function are extracted and stored. , When calling a function or procedure, if the name of a function or variable is entered halfway, the character string up to that point is used as a keyword to search the above definition information and search for completion candidates that match the type. If a character string can be selected and a character string up to a part where the number of completion candidates can be limited is input, the remaining part can be complemented.
Further, by searching the above definition information using the variable type as a keyword, it is possible to select a complement candidate according to the function argument type. As a result, the user's time and effort for key input can be reduced, and the efficiency of program creation can be improved.

[Brief description of drawings]

FIG. 1 is an overall view of an editing apparatus embodying the present invention.

FIG. 2 is a diagram showing stored contents of a storage device that stores program definition information.

FIG. 3 is a flowchart illustrating a processing procedure for complementing a function argument of the present invention.

FIG. 4 is a flowchart illustrating a processing procedure for creating program local definition information.

FIG. 5 is a flowchart illustrating a processing procedure for creating program global definition information.

FIG. 6 is a flowchart illustrating a processing procedure for complementing a function name and a variable name.

FIG. 7 is a flowchart illustrating a program input support processing routine.

FIG. 8 is a flowchart illustrating a processing procedure for performing complementary processing of a function argument.

FIG. 9 is a flowchart illustrating a processing routine for selecting a complement candidate for a function argument.

FIG. 10 is a flowchart illustrating a processing procedure for complementing a function name.

FIG. 11 is a diagram illustrating an actual example of creating program common part program definition information.

FIG. 12 is a diagram illustrating an actual example of creating program local definition information.

FIG. 13 is a diagram illustrating an actual example of creating program local definition information when there is a key input for complementing.

FIG. 14 is a diagram illustrating an actual example of complementing function arguments.

FIG. 15 is a diagram illustrating a function of presenting the definition of a variable to a user when complementing a function name.

FIG. 16 is a diagram illustrating an actual example of complementing using members of a structure.

FIG. 17 is a diagram illustrating an actual example of complementing using a class of C ++ language.

Claims (8)

[Claims] 1. A program definition information extraction unit for extracting variable name and type information defined by a user in a program, function name, type information, and argument information, and a file specified by the user with the definition information. When writing the definition information output part to be output and the functions and procedures to be called in the program, use the above definition information and the same definition information for the program library provided by the system to specify the function name and function arguments. Display candidate names (this is called "function name completion and argument name completion")
An application program editing device having a program input support section for 2. The application program editing apparatus according to claim 1, having a function of presenting the definition of the function and variable to the user when complementing the function name. 3. The application program editing device according to claim 1, having a function of displaying a candidate for a function having a return value corresponding to a variable type. 4. The application program editing apparatus according to claim 1, which prevents a mismatch of the function argument types. 5. The application program editing apparatus according to claim 1, which prevents typographical errors in function and variable names. 6. The application program editing apparatus according to claim 1, having a function of presenting a list of variables and function types and a list of external variables defined externally to the user. 7. The application according to claim 1, wherein the name and type information of the members of the structure defined by the user in the program are extracted and stored in a file, and the same complement is performed for the members of the structure. Application program editing device. 8. A class member name and type information defined by a user in a program and a member function name and type information and argument information are extracted and stored in a file. The application program editing apparatus according to claim 1, which also performs the same complement.