JPH06187139A - Editor - Google Patents

Abstract

PURPOSE:To prevent the generation of format errors due to a program with the little experience and the carelessness of an operator or the like by format controlling an inputted instruction sentence based on format definition information extracted from a format definition file and guiding its format. CONSTITUTION:The format definition information such as the information of delimiters such as processing conditions, kinds and insertion positions including the line feed of parentheses corresponding to the instruction sentences stored in the format definition file 8 is extracted by a format control part 9. Successively, input is performed from a keyboard 1 and input control is performed by an input control part 3. Then, when the input is the instruction sentence, the format control part 9 performs format control based on the format definition information extracted from the format definition file 8 and information stored in a format control information file 10. In this case, the automatic input of else sentences to if sentences or the like is performed for instance and also a cursor is continuously moved until the input completion information of the instruction sentence is confirmed. The format controlled information is stored in the format control information file.

Description

Detailed Description of the Invention

[0001]

BACKGROUND OF THE INVENTION 1. Field of the Invention The present invention relates to an editor for input control as well as format guide when coding a program.

[0002]

22 is a block diagram showing a conventional editor, for example. In the figure, reference numeral 1 is a keyboard into which command statements of a program are input by key operation, and 2 is an editor for controlling the input. In the editor 2, reference numeral 3 is an input control unit for identifying a key input from the keyboard 1 and controlling the input, and 4 is an input for performing a position adjustment or cursor movement when the key is a specific key. The key control unit 5 is an input key control file in which control information used by the input key control unit 4 is stored. Reference numeral 6 is a cathode ray tube display (hereinafter referred to as CRT) on which the output of the editor 2 is displayed, and 7 is a source file in which the program coded by the editor 2 is stored.

Next, the operation will be described. Here, FIG.
3 is a flowchart showing the flow of processing of the editor 2. First, in step ST1, key information is input to the editor 2 by operating a key on the keyboard 1.
The editor 2 receives the key information at the input control unit 3, and identifies the input key at step ST2. Next, in order to identify whether or not the received key information is a command statement, it is determined in step ST3 whether or not the key is a specific key, such as a parenthesis key or a tab key. If it is a specific key, in step ST4, the closing parenthesis is positioned, automatic input is performed, and the cursor is moved with respect to the parenthesis key or the tab key. The key control process in step ST4 is executed by the input key control unit 4 based on the control information stored in the input key control file 5.

The control result is sent from the editor 2 to the CRT 6 and is displayed on the screen in step ST5 to guide the input. On the other hand, when it is determined in step ST3 that the key is not the specific key, the key information is sent to the CRT 6 as it is and displayed on the screen. Then, in step ST6, it is determined whether the input is awaited or the edit is completed. If the input is awaited, the process is returned to the step ST1 and the series of processes described above is repeated. To finish.

[0005]

Since the conventional editor is constructed as described above, when a program is coded using it, the programmer lacks experience.
Alternatively, there is a problem that a format error is likely to occur due to carelessness of a worker, and if the format error occurs, it cannot be detected until a debugging tool or compilation is executed.

The present invention has been made in order to solve the above problems, and an object thereof is to obtain an editor capable of preventing the carelessness of an operator and the occurrence of a format error caused by an inexperienced programmer.

[0007]

An editor according to a first aspect of the present invention is a format definition file storing format definition information of a statement, and a format control of a statement based on the format definition information extracted from the format definition file. A format control section for performing the above, and a format control information file for storing the format-controlled information are provided.

In the editor according to the second aspect of the present invention, information for assigning each command statement to a function key is added to the format definition file.

[0009]

The format control section in the invention described in claim 1
By controlling the format of the input command statement based on the format definition information extracted from the format definition file and guiding the format, the carelessness of the operator and the occurrence of format errors by inexperienced programmers etc. can be prevented. Realize an editor that can be prevented.

The format definition file according to the second aspect of the present invention has information for assigning each command statement to a function key, so that the command statement can be input from the keyboard function keys.

[0011]

【Example】

Example 1. An embodiment of the present invention will be described below with reference to the drawings. FIG. 1 is a block diagram showing an embodiment of an editor according to the present invention. In the figure, 1 is a keyboard, 2 is an editor, 3 is an input control unit, 6 is a CRT, and 7 is a source file, which are the same as or equivalent to those of the conventional ones shown in FIG. The description is omitted. Further, 8 is a format of information such as a delimiter character such as an insertion position and type including cursor line breaks (opening and closing) corresponding to the command language, and a cursor position (plurality), a processing condition, and the like. This is a format definition file in which definition information is stored. The format definition file 8 also describes a format unique to the target language. Reference numeral 9 denotes a format control unit that inserts parentheses and moves a cursor based on the format definition information, and 10 is a format control information file that stores information that is format-controlled by the format control unit 9. is there.

Next, the operation will be described. Here, FIG.
Is a flow chart showing the flow of processing of the editor 2 configured as described above. First, at step ST11, the insertion position and type, including the line break of the parentheses (open and close) corresponding to the command statement, stored in the format definition file 8,
The format control unit 9 extracts format definition information such as cursor positions (plurality) and information about delimiters such as processing conditions. Next, in steps ST12 and ST13, keyboard input from the keyboard 1 and input control by the input control unit 3 are performed as in the conventional case. Then, in step ST14, it is determined whether or not it is a statement. In this case, unlike the conventional case where the parenthesis key or the tab key is used for the determination, the instruction statement itself, which is a collection of key information, is used for the determination.

If the result of determination in step ST14 is that it is an imperative sentence, the format control section 9 determines in step ST1.
5, the format definition information extracted from the format definition file 8 in step ST11 and the format control information file 10
Format control based on the information stored in. Note that this format control is different from the conventional key control that positions the closing brace, automatically inputs, moves the cursor, etc. for the parenthesis key and the tab key. The cursor is moved to a position, and an instruction sentence paired with the instruction sentence, for example, an else sentence for an if sentence is automatically input, and the like. It will continue until confirmed. It also provides formatting guides specific to other target languages.

The information subjected to the format control in this manner is stored in the format control information file 10 in step ST16. In addition, in this format control information file 10,
The format of the source file 7 such as the input command statement, the position of parentheses corresponding to the command statement, and the position of the judgment statement is stored. Here, when an operation such as insertion or deletion is executed in the format control of step ST15, the correct parenthesis insertion position and cursor movement position are calculated by referring to this format control information file 10. , Or when deleting a statement, the corresponding closing parenthesis can be deleted, or the deletion of only the closing parenthesis can be rejected.

The result of this format control is CR from the editor 2.
It is sent to T6 and displayed on the screen in step ST17. On the other hand, if it is determined in step ST14 that it is not a command statement, the key information is sent to the CRT 6 as it is and displayed on the screen in step ST17. Then, in step ST18, it is determined whether the input is awaited or the editing is completed. If the input is awaited, the process is returned to the step ST12, and the series of processes described above are repeated.
When the end of editing is detected in 18, all processing is ended.

Next, how to guide the format at the time of coding will be specifically described by using an if sentence as an example. Here, FIG. 3 to FIG. 21 are explanatory views showing the display state of the screen of the CRT 6 which changes with keyboard input.
In the figure, the black rectangle indicates the cursor position, and the underline indicates the portion that is format-guided to the corresponding input operation.

First, when "if (" is input and it is recognized that it is an if sentence, as shown in FIG. 3, the closing parenthesis ")" of the judgment expression part and the parenthesis "{}" of the processing instruction part are shown. Is automatically entered. At this time, the opening parenthesis of the processing instruction part is changed to the last column of the if statement, and the closing parenthesis is changed to the i
Describe in the same column as the f sentence. Hereinafter, all the parentheses in the processing instruction part are subjected to the same level matching. Also,
Emphasize that one line is required between the opening and closing parentheses in the processing instruction section. Note that the cursor moves to the judgment formula portion and enters the insertion state. Here, if the judgment formula “a = b” is input and the return key is operated,
As described above, the judgment expression is described between the opening parenthesis and the closing parenthesis of the judgment expression portion, and the cursor moves to the processing instruction portion and enters the insertion state. However, the cursor position is lower than the if sentence. Hereinafter, it is assumed that all the processing instruction parts perform similar alignment.

Next, when "if (" is input as a processing instruction, as shown in FIG. 5, the determination expression portion and the parentheses of the processing instruction portion are automatically input by the same processing as in FIG. 3, and further, When the judgment expression "c <0" is input and the return key is operated, the judgment expression is described as shown in Fig. 6. Next, "d = 1" is input as a processing instruction, and the return key is pressed. When operated, the delimiter ";" is automatically input as shown in Fig. 7, one line is added to the next line and the cursor is also moved.Next, if there is no need to input, only the return key is operated. As a result, as shown in FIG.
The else sentence corresponding to the f sentence and the parentheses of the processing instruction portion are automatically input, and the cursor moves after “else”.

Next, "if" is input to change the command statement to "el".
If "seif" is set, the parentheses of the judgment expression portion are automatically input as in the case of the if statement as shown in Fig. 9. After that, when the opening parenthesis "(" is input to combine the judgment expressions, it is shown in Fig. 10. Then, the corresponding closing parenthesis is automatically input.When the judgment expression “c = 0” is input and the return key is operated, the judgment expression is described in the parentheses as shown in FIG. Move to the part.
Next, when the join command “&&” is input and the return key is operated, the cursor moves to the determination part as shown in FIG. 12, and further, by inputting the opening bracket “(”, as shown in FIG. The closing parenthesis is automatically entered.When the judgment expression "x>0" is input and the return key is operated, the judgment expression is described in the parentheses as shown in FIG. Move to the join processing part.

If there is no need to perform the combining process, only the return key is operated. As a result, the cursor moves to the processing instruction portion and enters the insertion state as shown in FIG. here,
When the processing command “d = 2” is input and the return key is operated, the delimiter “;” is automatically input as shown in FIG. 16, one line is added to the next line, and the cursor is moved there. . Here again, if there is no need to input, only the return key is operated, and as shown in FIG. 17, the else statement and the parentheses of the processing instruction are automatically input, and the cursor is "e".
Then, when the return key is operated to change the command statement to “else”, the cursor moves to the processing command portion and enters the insertion state as shown in FIG.

If the return key is operated after "d = 3" is input as the processing instruction, the delimiter ";" is automatically input as shown in FIG. In this case,
Since the instruction statement is “else”, it is determined that the second if statement has ended, and the parentheses of the else statement and the processing instruction portion are further automatically input according to the first if statement. At this time, the cursor moves after "else". Next, if you operate the return key to set the statement to "else",
As shown in FIG. 20, the cursor moves to the processing instruction portion and enters the insertion state. When the processing instruction is not necessary, the return key is operated, thereby ending the first if sentence and moving the cursor to outside the if sentence as shown in FIG.

Although an example of the format guide for the if statement has been described above, the same applies to other command statements such as a for statement and a do statement, and the format guide basically performs the following four processes. Automatic input of parentheses and delimiters such as ")", "{", "}", ";", ":". Positioning of statements, parentheses, processing instructions, etc. Move the cursor to the input position such as the required input field. else statement for if statement and whi for do statement
case statement and default for le statement and switch statement
Automatically input command statements corresponding to command statements such as ult statements.

Here, the above-mentioned format guide shows one example thereof, and the alignment (format) of command statements, parentheses, processing instructions, etc. can be arbitrarily set in the format definition file 8. Needless to say.

By having the format definition file 8 of the above embodiment for each language, it is possible to realize an editor that can support a plurality of languages.

Example 2. Further, in the first embodiment described above, the case where the command sentence of the programming language is input by the operation of the keyboard 1 by the operator has been described. 8 may be added, and the command statement may be input to the editor 2 with one touch of the function key. Specifically, for example, when the # 1 function key is operated, each command sentence such as “if (” and when the # 2 function key is operated, “for (”, etc. is automatically input to the editor 2, and the editor 2 inputs the keyboard. In step ST11 prior to the above, if the command statement is associated with the function key, the subsequent steps will be described in the first embodiment.
The processing can proceed in exactly the same way as in the case of.

As a result, the number of times of key input can be reduced, and the command statement can be easily recognized. Further, in the first embodiment, the end of the input is confirmed by the operation of the return key, so it is impossible to insert a blank line. However, as in the second embodiment, the input end recognition is also a function. A blank line can be input by setting with the key.

[0027]

As described above, according to the first aspect of the present invention, the format of the input command statement is controlled based on the format definition information to guide the format.
It is possible to prevent the occurrence of format errors due to carelessness of workers and inexperienced programmers, and it is possible to reduce the time for correcting the source code and rechecking the format, thus improving software productivity. There is an effect that an editor that can be obtained is obtained.

According to the second aspect of the invention, since the information for assigning each command statement to the function key is added to the format definition file, the command statement is input from the function key of the keyboard. This makes it possible to reduce the key input and easily recognize the command statement.

[Brief description of drawings]

FIG. 1 is a block diagram showing an embodiment of an editor according to the present invention.

FIG. 2 is a flowchart showing a flow of operations in the above embodiment.

FIG. 3 is an explanatory diagram showing a screen display in response to a keyboard input in the above embodiment.

FIG. 4 is an explanatory diagram showing a screen display in response to a keyboard input in the above embodiment.

FIG. 5 is an explanatory diagram showing a screen display in response to a keyboard input in the above embodiment.

FIG. 6 is an explanatory diagram showing a screen display in response to a keyboard input of the above embodiment.

FIG. 7 is an explanatory diagram showing a screen display in response to a keyboard input of the above embodiment.

FIG. 8 is an explanatory diagram showing a screen display in response to a keyboard input of the above embodiment.

FIG. 9 is an explanatory diagram showing a screen display in response to a keyboard input in the above embodiment.

FIG. 10 is an explanatory diagram showing a screen display in response to a keyboard input of the above embodiment.

FIG. 11 is an explanatory diagram showing a screen display in response to a keyboard input in the above embodiment.

FIG. 12 is an explanatory diagram showing a screen display in response to a keyboard input of the above embodiment.

FIG. 13 is an explanatory diagram showing a screen display in response to a keyboard input of the above embodiment.

FIG. 14 is an explanatory diagram showing a screen display in response to a keyboard input of the above embodiment.

FIG. 15 is an explanatory diagram showing a screen display in response to a keyboard input of the above embodiment.

FIG. 16 is an explanatory diagram showing a screen display in response to a keyboard input of the above embodiment.

FIG. 17 is an explanatory diagram showing a screen display in response to a keyboard input in the above embodiment.

FIG. 18 is an explanatory diagram showing a screen display in response to a keyboard input of the above embodiment.

FIG. 19 is an explanatory diagram showing a screen display in response to a keyboard input of the above embodiment.

FIG. 20 is an explanatory diagram showing a screen display in response to a keyboard input of the above embodiment.

FIG. 21 is an explanatory diagram showing a screen display in response to a keyboard input of the above embodiment.

FIG. 22 is a block diagram showing a conventional editor.

FIG. 23 is a flowchart showing the flow of the operation.

[Explanation of symbols]

 1 keyboard 3 input control section 7 source file 8 format definition file 9 format control section 10 format control information file

Claims (2)

[Claims] 1. An input control unit for identifying information input from a keyboard to determine whether or not it is a command statement of a programming language, and a format definition file storing format definition information of the command statement. And a format control unit that controls the format of the information determined to be a command statement by the input control unit based on the format definition information extracted from the format definition file, and information that is format-controlled by the format control unit. An editor with a format control information file to be stored. 2. The format definition file is provided with information for assigning each of the command statements to a function key of the keyboard, and the command statement is input through the function keys of the keyboard. The editor according to claim 1.