JPH06274333A - Input support method and editing support method for program - Google Patents

Abstract

PURPOSE:To input a program expressed by a graphic only with a keyboard by displaying the graphic showing a constitution element in response to a character string showing the constitution element of the program and displaying an area to be inputted near the graphic when the other constitution element which is to be inputted in relation to the constitution element exists. CONSTITUTION:It is assumed that the character string rem is inputted to a character string input area 52, for example. When a conversion key on the keyboard is depressed, the character string input area 52 is disappeared, and a template by the graphic as against a function rem, namely, the graphic 54, the character string input areas 55 and 56 for the two arguments and arrows 55A and 55B connecting the areas to the graphic 54 are displayed. Temporary argument names are respectively displayed in the character string input areas 55 and 56, and therefore a user can judge what is to be inputted next. When input from the keyboard is advanced in such a state, the temporary argument name in the character string input area 55 is deleted, and it is changed into the character string inputted from the keyboard.

Description

Detailed Description of the Invention

[0001]

BACKGROUND OF THE INVENTION 1. Field of the Invention The present invention relates to a method for inputting and editing a computer program expressed by using graphics.

[0002]

2. Description of the Related Art Generally, information represented by a diagram is easy to understand. It is a common experience that it is easy to understand when abstract information is represented by a figure, not to mention that it originally has a two-dimensional or three-dimensional shape. Even in the computer world, a method of making it easy to understand program-related information by representing a program and other information in a diagram has been performed for a relatively long time. When it comes to diagrammatic representations of programs, flow charts are the starting point, and after that, the document "A new representation of program control structures: tree structure charts became popular" (Nikkei Computer, 1989.1.9, pp. Various proposals for improvement such as those introduced in 83) have been proposed. Recently, research on so-called visual language, which has only graphical representations, is also active.

As an example of a graphic representation of a program and a program development tool based on it, the document "SEW
B "Development Thoughts and Functions" (Hitachi Review, Vol. 70, N
o. 2 (1988.2)), there is a schematic representation PAD of a program, and a program editor (PAD editor) based on it. PAD is a diagrammatic representation of a program intended to make it easier to see the structure of the program by diagramming three control structures common to procedural languages such as C, FORTRAN, and COBOL-sequential execution, conditional branching, and repetition. Is the way. The PAD editor supports the program creation by this PAD.

FIG. 32 shows a description example of a program in PAD.
Shown in. (A) of the figure is an example of the FORTRAN program,
(B) is the PAD representation of (a). As can be seen from the figure, the repeated do is a box with a vertical bar added to the right end (Fig. 21), the conditional branch IF is a box with a dented right side (Fig. 22), and a normal execution statement is simple. Each is represented by a rectangular box (FIGS. 23, 24, 25). As described above, the basic expression method of PAD is to represent the above-mentioned three control structures by a diagram, while expressing detailed processing as characters (text) according to the grammar specific to each language.

When the program is input by the PAD editor, the graphic portion is designated by selecting a desired one from the parts menu displayed on the display screen with the mouse, as in the case of the general drawing creation tool. Also,
The character part described in the box is input from the keyboard,
The method is called.

By the way, as can be easily understood from FIG. 2, the schematic representation of the program expresses explicitly the structure of the program, that is, the syntactic structure. Therefore,
It would be useful to implement an editor that supports the creation of programs by using the syntax information of the programming language. Specifically, show the syntax of the program in the middle of input to assist the input, check the input program, issue a warning when there is a syntax error, and do not allow the input of the program that causes the syntax error Functions such as, are possible. Such an editor is conventionally called a syntax directed editor.

For a text-based editor,
Several such syntax-driven editors have been proposed, an example of which is the document T. Teitelbaum, et al; The Cor.
nellProgram Synthsizer: A Syntax-directed Program
ming Environment, Communication of the ACM, Vol.2
4, No. 9, pp. 563-573 (September 1981). This is to prepare a syntax template consisting of the name of a language element and the input slot of the argument that constitutes it (this is called a placeholder in the above paper), and input and edit the program based on this syntax template. By doing so, a program that enables input and editing of the program while always maintaining the correct syntax state.
It is an editor.

As another example of a text-based syntax-driven editor, there is a prior application (JP-A-1-118).
925).

This is to alleviate the point that the syntax-driven editor according to the above-mentioned document performs input editing while always maintaining the correct syntax, which is very cramped for the user in some sense, and improves operability. Is aimed at. Specifically, it is based on a normal screen editor that allows input in character units, with the addition of a function for inserting a syntax template.

An example of a syntax-driven program editor based on a diagram is the literature: Tsuguyasu Yasui, Tomoyuki Minamiyama "Syntax-Oriented PAD Editor" (6S-1, The 34th Information Processing Society of Japan (late 1987)) National convention).

[0011]

DISCLOSURE OF THE INVENTION Problems to be Solved by the Invention
For a programmatic representation similar to D, these are
As mentioned above, the main focus is on the visualization of the three main control structures of procedural languages that do not depend on individual languages. Therefore, the input of the program by the PAD editor is divided into two stages, that is, the input by the graphic of the control structure component independent of the individual language and the input by the character of the program in the content of each control structure component. As mentioned above, input of the graphic part is
This is done by selecting a graphic component from the component menu displayed on the screen.

[0012] If there are about three basic graphic parts such as PAD, the number of parts lined up in the menu is about 10 including variations, so that it is easy to display in the menu and select from them. is there. However, programming as described in the previous application (Japanese Patent Application No. 2-056360) or Yoshimitsu Oshima "Diagrammatic representation VEX of LISP program" (Information Processing Society of Japan Symbol Processing Research Group Material 54-3 (1990.3.12)) If all language elements are represented graphically, the number of graphic parts will be on the order of 100,
It is difficult to display in the menu. Even if it can be displayed, it is more difficult to select from it.

Further, as described above, the program input is divided into the graphic part input by menu selection and the detailed part by character input, and the mouse and keyboard must be used alternately. Operation is troublesome. It is expected that more efficient program creation will be possible if the program can be entered using only the keyboard or mouse.

On the other hand, the above-mentioned text-based syntax-driven editor (Cornell Program Synthesizer) can support the creation of a program with the correct syntax by using the syntax template of the language element. There is a problem that it is hard to see compared to the program expressed in the diagram because the expression is based only on the characters (the syntax template looks like a normal text program). Also, since the program is edited based on this syntax template, there is a problem that the editing operation is troublesome. In particular, operations such as changing a template in a program already created and inserting another template are troublesome.

The syntax-driven editor described in the prior application (Japanese Patent Application Laid-Open No. 1-118925) solves this troublesome operation, but the improvement is mainly limited to the input of the program. Various editing operations of the editor --- insert, move,
It does not describe how to use the syntax information for copying, deleting, etc. In addition, the problem that it is difficult to see because it is targeted at character-based programs
Similar to Program Synthesizer.

The diagram-based syntax driven editor is
Although it is a syntax-driven editor, it does not have a mechanism for guiding the syntax of language elements such as syntax templates, and only has the function of checking the syntax of the entered program later.

It is a first object of the present invention to provide a method for inputting a program expressed by a graphic, using only characters, that is, a keyboard, and without special graphic designation.

A second object of the present invention is to provide a program editor which is easy to see and can easily input and edit by using a syntax template expressed by a diagram and at the same time can create a program with few syntactic errors. To provide.

[0019]

In order to achieve the above object, the present invention provides the following method.

(1) A graphic program input / editing method for displaying a program in a graphic format for inputting and editing, and means for providing a character string input area at an arbitrary partial graphic program inputtable position on the graphic program display screen, A table of correspondence between names of graphic program parts or keywords designating graphic program parts and graphic program parts is provided, and after a character string representing the name or the keyword is entered in the area, a specific key or button is pressed. , The graphic program part corresponding to the name or the keyword is displayed at the position of the area in place of the area.

At this time, if the displayed graphic program component has an argument, a character string indicating the name of the argument (dummy argument name) is displayed inside or near the graphic program component.

(2) A graphic program input / editing method for displaying a program in a graphic format for inputting / editing, changing a character string of a graphic program part having a character string representing a name or a keyword as a part thereof, A graphic program input / editing method for changing and displaying the graphic program part corresponding to the changed name or keyword when a specific key or button for instructing a change is pressed.

(3) A graphic program input / editing method for displaying and inputting and editing a program in a graphic format, wherein a character string input area is provided at an arbitrary partial graphic program input position on the graphic format program display screen, A graphic program input method of, after inputting a program in a character format in the area, converting the character program into a corresponding graphic program and displaying it when a specific key or button is pressed.

(4) In the graphic program input method of the above (1), a position at which the character string input area can be inserted on the graphic expression program after the insertion command of the input character string input area of the new graphic program part is issued. A graphic program input / editing method for identifying and displaying a portion of the graphic program corresponding to the insertable position when the graphic cursor is positioned at.

At this time, when the graphic cursor is positioned at a position where the character string input area cannot be inserted and a specific key or button for instructing the insertion is pressed, warning information such as a warning sound and a warning message is issued.

When a specific key or button for instructing execution of insertion is pressed at the insertable position, the graphic program part determined by the insertion position is inserted and displayed at that position.

(5) Regarding a program input editing method for displaying a program in a graphic format and performing input editing, after issuing a paste command for a partial graphic program saved in advance in a save area, or a part specified in advance on the graphic program After issuing the move or copy command to the graphic program, when the graphic cursor is positioned at a position where the partial graphic program can be pasted, moved or copied on the graphic program, the part of the graphic program at the paste, moveable or copyable position is Schematic program input editing method to identify and display.

At this time, when the graphic cursor is positioned at a position where paste, move or copy is not possible and a specific key or button for instructing execution of paste, move or copy is pressed, warning information such as a warning sound and a warning message is displayed. Emit.

(6) A program input editing method for displaying a program in a graphic format for inputting and editing the program by issuing a delete command to one or more partial schematic programs designated in advance on the schematic program. After deleting a partial schematic program from the schematic program, associating each part of the remaining schematic program while associating with each other. As a result, when a syntactically incorrect partial schematic program occurs, the partial schematic program is identified. Schematic program input editing method to display.

[0030]

By the above methods (1), (2) and (3),
It is possible to create a graphic expression program using only the keyboard.

Further, according to the method (1), since the syntax template represented by the graphic representation of the language element is displayed, it is possible to easily input an error-free program.

Further, according to the methods (4), (5) and (6), the syntax check of the program is performed in parallel with the editing of the graphic representation program, so that a program without a syntactic error can be easily created. Is possible. This method also does not reduce the efficiency of the editing operation because there is no restriction on the editing operation due to strict application of syntax information.

[0033]

EXAMPLES The present invention will be described in detail below with reference to examples.

The program used in the following examples is represented graphically by the prior application (Japanese Patent Application No. Hei 2-056360) or Yoshimitsu Oshima, “LEX Programmatic Representation VEX” (Information Processing Society of Japan, Symbol Processing Research Group Material 54-3). (199.3.1
2)) is mainly used. In addition, as a programming language that is the basis of the graphic representation, LIS
The P language (especially Common LISP) is mainly used.
However, the present invention is not limited to the LISP language and the graphic representation based thereon. Further, the present invention is not limited to a graphic expression program which is premised on the existence of a character expression program, but can be applied to a program in a so-called visual language having only a graphic expression.

FIG. 1 shows the configuration of a system for realizing the graphic program input / editing method according to the present invention.

In FIG. 1, reference numeral 10 is a control device such as a personal computer or a workstation. Reference numeral 2 is a display device for displaying a graphic. Reference numeral 3 is a keyboard for inputting characters, and 4 is a position indicating device such as a mouse for designating a position on a display screen or a graphic displayed on the screen as an object to be edited.

Reference numeral 20 in FIG. 1 is a schematic program input editing program according to the present invention. This program is composed of a conversion program 12 from a character representation to a graphic representation, a reverse conversion program 14 from a graphic representation to a character representation, and an input editing control program 15.

Reference numeral 11 in FIG. 1 is a source program file created by the user in character representation. The source program in this file is converted into a graphic representation program (file) 13 by the character representation to graphic representation conversion program 12 and displayed on the screen of the display device 8 through the input display control program 6.

The reverse conversion program 14 from the graphic representation to the character representation reversely converts the graphic representation program 13 into the source program 11 in the character representation. After inputting and editing the program at the schematic representation level, if you get a program with character representation with this inverse conversion program, then convert it into machine language with a combiner for this character representation program, or use an interpreter for this character representation program. , The program can be executed. Of course, if there is a compiler or interpreter for the graphic representation program, it is possible to execute the program without converting it into the character representation.

The input edit control program 15 receives information such as character data, function key codes, commands and graphic cursor positions on the screen, which are input from input devices such as the keyboard 3 and the mouse 4, through the input display control program 6. While inputting, interpreting, and utilizing the graphic program parts table 16, the input editing process is advanced, and the programs 12 and 14 are started as appropriate.

It should be noted that the graphic program parts table 16 includes both the description elements of the program structure such as sequential execution, condition judgment, repetition, etc., or the character expressions of the constituent elements of the program such as functions and the corresponding graphic expressions. Are registered in pairs.

The input display control program 6 can be realized by a window system (for example, X window) in a recent personal computer or workstation.

Next, a concrete screen display example of the graphic expression program and an input editing operation method on the screen will be described.

(1) Input Example (1) Function rem (1) FIG. 2 is a diagram showing an example of a schematic program input method according to the present invention. In the figure (a), 50 is a program input screen, and 51 is a figure (a box in this case) representing a one-input / one-output function foo, which is a part of the program already input in the screen. . Reference numeral 52 denotes an area in which a character string (text) can be input from the keyboard, which is connected to the figure 51 by an arrow 58. Reference numeral 53 is a character cursor indicating the position where the character is input next. In the figure, the character string rem has already been input in the character string input area 52.

The character string input area 52 is shown as a figure surrounded by a dotted line in FIG. 2, but instead of this, the color of this area may be changed to that of the other portion. Further, if the existence of a region is clear, such a visual feature may be omitted. The same applies to the input area described below.

When the conversion key provided on the keyboard or a key in place of the conversion key is pressed in the state of FIG. 1A, the display changes to that shown in FIG. The character string input area 52 of (a) disappears, and a graphic template for the function rem, that is, the graphic 54, the character string input areas 55 and 56 for the two arguments thereof, and an arrow connecting them to the graphic 54. 55A and 55B are displayed. By the way, the function rem divides the number into a divider
Co that divides by and returns the remainder
It is a function of mmon LISP. As described above, in this embodiment, the area for inputting the argument of the function rem is automatically displayed at a position on the screen having a predetermined relative positional relationship with the graphic representing the function rem. Especially,
These areas are indicated by arrows 55A and 55B and
The regions 55 and 56 do not necessarily have to be connected to the graphic 54, though it is easy to understand that these regions are in close relationship with the graphic 54.

Although the areas 55 and 56 are displayed by the figure surrounded by the dotted line in FIG. 2, instead of this, the color of this area may be changed from that of the other portions to be displayed. , Fig. 2
This is the same as the case of the area 52 of. If it is clear that the region exists, such a visual feature may be omitted.

In the character string input areas 55 and 56, formal parameter names number and divisor are displayed, respectively. This formal parameter name number and div
isor is used to distinguish it from the characters entered by the user.
It is displayed in italics. By displaying the dummy argument names, the user can easily determine what is to be input next. Further, in order to facilitate the next input, the character cursor is moved to the head of the character string input area 55 representing the first argument of the function rem (57 in the figure). When further input from the keyboard is made in this state, the dummy argument name number in the character string input area 55 is
r is erased and replaced with the character string input from the keyboard. Further, when the input character string is deleted, the dummy argument character string is displayed again.

When the name of the graphic part of the program to be displayed next is entered in the character string input area 55 and the conversion key is pressed again, the character string input area 55 disappears and the character entered at that position disappears, as described above. The graphic parts of the program specified by the column are displayed.

(2) Input Example (2) Case of Function rem (2) FIG. 3 is another example of the graphic template for the function rem. In this example, the dummy argument name number of the function rem
r and divisor are not in the character string input area for inputting arguments, but in the box 54A representing the function, and
Character string input area 55 for inputting each argument,
It is shown in correspondence with 56.

This dummy argument name is usually a language element that the input program component prepares in advance in the system, that is, a built-in function or the like (function rem in this example).
Is displayed. In addition, even if the processing system of the programming language is an interpreter format and the program definition for the specified element is preloaded in memory, by referring to that information,
The parameter name can be displayed.

(3) Input Example (3) Program Input In the above example, the name of the programming language element ("rem" in this example) was input to the character string input area 52 and the conversion key was pressed. . Alternatively, you can enter the complete program in character form.

An example is shown in FIG.

In the figure (a), the program "(* x (+ yz))" is displayed in the character string input area 52 of FIG. 2 (a).
(This represents the program that executes the expression "x * (y + z)" in the LISP language), and when the conversion key is pressed next, the program is converted into the program shown in the figure (b). It That is, a box 6 representing a logical product and a logical sum
A graphic having 3, 64, arguments x, y, z, and arrows associating them is displayed.

It is not necessary for the complete program to be entered. If there are insufficient arguments, the system will automatically fill the string input area corresponding to the missing arguments. Also,
When an extra argument is specified, the system highlights the argument in the program converted into the diagram and calls the user's attention. When you enter an argument that has incorrect syntax and convert it, the system also highlights the graphic representation for that argument to alert the user (or, if it cannot convert to a graphic representation, the Remain displayed and highlighted there). An example is shown in FIG.

FIG. 5A shows that the character string "(re
m (elt list) 3 8) ”is input. When the conversion key is pressed in this state, the same figure (b)
Change to a schematic representation program like. Since the function rem is originally a function of two arguments, the extra argument “8” is hatched and highlighted (61 in FIG. 5B).
The function elt is also a function of two arguments, but since only one argument is given, the character string input area 62 including the remaining argument name index is supplemented and displayed. Incidentally, the function elt is a function of the Common LISP that extracts the element specified by the index (number) from the data given in the form of the list or the vector.

As in the case of this figure, an extra argument (61 in FIG. 5B) remains, or an essential argument (FIG. 5).
If an attempt is made to end editing while input is not given to 62) in (b), a warning sound, a warning message, or the like will alert the user.

(4) Input Example (Part 4) Case of Function Let FIG. 6 is a diagram showing another example of the schematic program input method according to the present invention. This figure shows the state after inputting let in place of rem in the character string input area 52 and pressing the conversion key in FIG. 2A.

The frame in FIG. 70 and the portion surrounded by it are C
This is a diagrammatic representation of a language element let representing the block structure of the OMON LISP. 71 is let
(72 is a schematic representation), 72 is a character string input area for inputting the name of a local variable introduced by the block structure let, 73 is a character string input area for inputting a program indicating its initial value, Reference numerals 74 respectively denote character string input areas for inputting a program body having a block structure let. Character string input areas 72, 73,
A character string va indicating the name of each dummy argument is included in 74.
r, init, and form are shown in italics (var is variable (variable), init is in
Each abbreviation of initial value (initial value),
form is a Com representing an executable partial program.
mon LISP specific name). The character strings displayed in italics are erased when the user inputs a character in the respective character string input areas, as described above. Further, when the input character string is deleted, the dummy argument character string is displayed again.

As in FIG. 2B, in order to facilitate the next input, the character cursor 76 is moved to the beginning of the character string input area 72 of the local variable name.

The vertical bar 75 in FIG. 6 is a schematic representation showing the processing by sequential execution. Extend the vertical bar of 75 vertically, for
By arranging a plurality of partial programs by m and connecting them to this vertical bar, it is possible to express a program that sequentially executes the processing by a plurality of forms.

Generally, a plurality of local variables can be set in the block structure let.

FIG. 7A shows a state in which the variable name x is input to var, the conversion key is pressed, and then the initial value 1 is input to the character string input area 73 in the state of FIG. If the conversion key is pressed in this state, the local variable x
Below, is a character string input area 77 for inputting a new local variable.
Then, a character string input area 78 for inputting an initial value is added.

Since an arbitrary number of local variables can be set, new variables and initial value character string input areas can be added one after another by repeating the above operation.

If the conversion key is simply pressed while nothing is entered in the newly added local variable and the character string input area of the initial value, the additionally displayed local variable and the character string input area of the initial value are erased, You can finish adding new local variables.

Note that it is possible to leave the character string input area of the local variable that is additionally displayed but not input, and perform other work. In this case, the local variable and the initial value character string input area remain. If the character cursor is moved again into this character string input area and the conversion key is pressed without any input, the additionally displayed local variable and the character string input area of the initial value are erased. You can also enter a new variable name without erasing it.

When nothing is done to the additionally displayed local variable (and initial value) character string input area and the editing end operation is performed, this additional area is treated as not existing and the program is In that state, it is stored in a file or the like.

In Common LISP, the language elements for which such a plurality of local variables can be set are the language element defun for the function period and the language element d for the repetition.
o, etc. Each can have multiple dummy arguments and multiple repeat control variables.

(5) Input Example (Part 5) Conditional Statement if FIG. 8 is a diagram showing another example of the schematic program input method according to the present invention. FIG. 2A shows a state after inputting if instead of rem in the character string input area 32 and pressing the conversion key in FIG. 2A.

In FIG. 8 (a), a complex figure composed of a frame (80 in the figure) inside of which is written inside if and a figure part on the right side of the box is a language element if representing a conditional branch of Common Lisp by a diagram. It is a representation. 81
Is a graphic that represents the function of the conditional branch if if a graphic that represents a valve that is often used in a design drawing of piping or the like is diverted. Reference numeral 82 is a character string input area for inputting a program representing a branch test condition, and 83 is a
A character string input area for inputting a program executed when the test condition is satisfied, and a character string input area 84 for inputting a program executed when the test condition is not satisfied. Similar to the above, the respective dummy argument names (test, then, else) are displayed in italics in the character string input area.

The argument else in the figure is an additional argument, which may or may not be input. Program that represents the condition "(> x 1)" (this is the expression "x> in the LISP language
1 "is represented in the character string input area 82 and the conversion key is pressed,
Then "(+ x y)" (this is the expression "x + in the LISP language
(representing a program for executing y ”) is input to the character string input area 83, and immediately after the conversion key is pressed, it is shown in FIG. FIG. 93 showing addition and input argument x,
1, x, and y are displayed in such a shape that they are connected to these figures with arrows. At this time, the character cursor 85 is
That is, it is in the character string input area 84. When the conversion key is pressed in this state, the else character string input area 54 is erased, and the schematic representation of the program becomes as shown in FIG.

Character string input area 84 for this else
Is left as it is when another editing is performed in the state of FIG. If nothing is done to the character string input area 84 of else and the editing end operation is performed, it is processed as if there is no character string input area like the character input area for additional input of the local variable. It

In Common LISP, even in a normal function, the same as the argument else of the above if,
You can set optional arguments. Further, similarly to the list of local variables, it is also possible to define an argument having an arbitrary number of elements.

(6) Modification Next, an example of partially modifying the created graphic program will be described.

FIGS. 9 and 10 show the Common LI.
It shows an example in which the language element if of the conditional branch of SP is changed to the language element cond of another conditional branch. if
Is a mechanism for selecting and executing one of the two execution units according to one test condition, as described above. Figure 9
Has a figure 94 obtained after inputting xy to the else section 84 of FIG. In contrast, cond
Describes a plurality of pairs of a condition part and an execution part. At the time of execution, this pair is scanned from the beginning, and the execution part of the part where the condition part is satisfied is executed.

In the state of FIG. 9A, the character cursor 90 is placed on the keyword if with a mouse or the like, and if
Is changed to cond (91 in FIG. 9B) and the conversion key is pressed, the schematic representation program becomes as shown in FIG. i
The part of the test condition that existed at the time of f (Fig. 9 (a) 92)
Is placed in the first part of the conditional / executor pair of cond in FIG. Further, since no condition part is designated for the second condition part / execution part pair, a new character string input area 95 is added and displayed. The part executed when the if test condition is satisfied (then part, FIG. 93) and the part executed when it is not satisfied (else part, FIG. 94) are two condition parts / execution parts, respectively. They are placed in pairs.

In this example, the language elements before and after the change perform similar functions, but in general, the language element after the change does not need to have a particular relationship with the language element before the change. It can be anything. However, since there is generally no correspondence between the argument of the language element before the change and the argument of the language element after the change, the system side will make an appropriate correspondence. In that case, although some have occurred in the above case, there is a possibility that arguments will be over or under. On the other hand, similar to the conversion of the character program including the error into the graphic program described above, the missing arguments are supplemented and the excessive arguments are highlighted to call the user's attention.

In the case of making a slightly larger modification of the program, it is usually carried out by a graphic-based editing operation described later. However, the following method is also possible.

First, the areas to be modified are collectively converted back into a character format program. Next, after making corrections on the basis of characters, the expression on the basis of graphics is restored again. Specifically, a program such as that shown in FIG.
When 63) in (b) is specified with a mouse and a command for conversion from graphic representation to character representation (reverse conversion) is executed,
A display as shown in (a) is obtained. In this state, the program is edited on a character-by-character basis, and the modified graphic key is used to restore the original graphic expression program.

(7) Insert Next, an example of the editing operation of the graphic program will be described.

FIG. 11 is a diagram showing an example of an operation of inserting a new character string input area.

By the way, normally, in a text-based editor, a program can be modified by inserting a character string at an arbitrary position. However, in the program editor using the graphic representation as in the present invention, in order to insert a new program in the middle, an area for inputting at the insertion position, that is, a character string as used in the above description is used. It is necessary to explicitly provide the input area. However, in the schematic program editor of the present invention, the individual program parts in the schematic represent the template of the corresponding language element, that is, the syntactical form, so that the character string input area for insertion is added at a completely arbitrary position. I can't do it. Therefore, when setting the character string input area for insertion, it is appreciated that the user can know beforehand what can be inserted.

FIG. 11 is a diagram for explaining the support function for this purpose.

In FIG. 11A, a graphic is displayed by using a device such as a mouse for designating an insert command using a pull-down menu (not shown) attached to the editor window and then designating a position on the screen such as a mouse. The situation where the cursor 102 has been moved to the position where the cursor 102 is to be inserted is shown. In this example, the positions to insert are two functions fun1 (100 in the figure) and fun2.
(101 in the figure). In this situation, if you press the mouse button or the like to instruct to execute the insert command,
As shown in (b), the character string input area 104 for insertion is inserted at the position designated by the graphic cursor 102, and the character cursor 53 is displayed therein.

By the way, in FIG. 11A, the arrow 103 connecting fun2 to fun1 is a bold line. As described above, in this embodiment, the graphic cursor is positioned at the position of the arrow 10.
If you put it on the top of 3, it will be displayed. In this situation, if the graphic cursor is released from above the arrow 103 by operating the mouse or the like without executing the insertion operation (without pressing the mouse button or the like), the arrow 103 returns to the normal thickness display.

After specifying the insert command,
When the graphic cursor is moved to a position where it can be inserted in the character string input area for insertion, if it is highlighted, the user knows that it can be inserted and the editing operation becomes easy. .

In this example, the graphic indicating the insertable position is highlighted by thickening the arrow line, but this may be performed by another method. For example, there is a method of representing the arrow line by a dotted line or a broken line, changing the color of the line, and the like.

Further, in the present embodiment, when in the insert command execution state, as shown in FIG. 9A, the graphic cursor 102 has a shape behind the arrow to indicate the insert command execution state. It becomes a shape with a rectangle. Usually, it is in the shape of a simple arrow.

FIG. 12 shows another example of the insertion operation of the insertion character string input area. Function fun1 (11 in FIG. 12A)
0) two arguments (function fun2 (111) and function fu
This is an example in which another argument is inserted between n3 (112). When the graphic cursor 113 for insertion is placed on a part 114 of the side sandwiched by the tips of the arrows indicating the two arguments in the box indicating the function fun1, this part is displayed as a thick line.

When the insert command is executed by pressing a mouse button or the like in this situation, as shown in FIG. 12B, the character string input area 11 for inputting new arguments is displayed.
5 is inserted and displayed. The cursor 53 is displayed inside it.

In the example shown in FIG. 12A, the function fun1
It is also possible to insert the character string input area before the first argument (function fun2) or after the last argument (function fun3). When inserting before the first argument, the space between the upper left side of the box of the function fun1 and the tip of the arrow of the first argument is highlighted, and when adding after the last argument, the left side of the box of the function fun1. The area from the bottom to the tip of the last argument arrow is highlighted.

FIG. 13 shows a third example of the insertion operation of the insertion character string input area. This is an example of a case where another local variable is newly added in the middle of the local variable list of the language element let120 representing the block structure of CommonLISP.

In FIG. 13A, the graphic cursor 121 for insertion points between the two variables var1 (122 in the figure) and var2 (123 in the figure) already set in the variable list. At this time, the line separating the two variables is displayed as a thick solid line (124 in the figure).

When an insert command is executed by pressing a mouse button or the like in this state, a character string input area 125 for inputting a local variable name and a program indicating its initial value are input as shown in FIG. 13B. The character string input area 126 is inserted and displayed.

Also in this example, as in the case of FIG. 12, it is possible to insert a new character string input area for a local variable at the beginning or end of the variable list. At this time, the upper or lower end of the variable list is highlighted.

FIG. 14 is a fourth example showing an insertion operation of the insertion character string input area. This is an example of adding a new condition part / execution part pair in the middle of a pair of a plurality of condition parts / execution parts 140 and 141 of a language element cond (130 in the figure) of a conditional branch of Common LISP.

In FIG. 14A, the graphic cursor 131 for insertion has two condition parts / execution parts 140 and 1 on the leftmost line segment of the box representing the title of the condition element cond.
Arrows from pair 41 (132, 133 in the figure)
Refers to the part that is sandwiched between the tips. At this time, a part of the line segment becomes a thick line (134 in the figure).

When an insert command is executed by pressing a mouse button or the like in this state, a character string input area 135 for inputting a new condition part and a new execution part are input as shown in FIG. 14B. A new condition part / execution part pair graphic including a character string input area 136 and a graphic 137 indicating condition determination (similar to if, diversion of valve symbol in piping diagram) is inserted and displayed.

Similar to the previous example, in this case as well, the first condition part /
It goes without saying that it can be inserted before the execution part pair or after the last condition part / execution part pair, and at that time, the corresponding position is highlighted.

As is clear from the above description, in each example of the inserting operation, the character string input area to be inserted corresponds to the syntax at the inserting position. More specifically, the character string input area to be inserted is composed of one or a plurality of character string input areas and a graphic attached to the syntax of the position according to the syntax of the position to be inserted. This can be seen as a variation in the insertion operation of the program input method using the graphic syntax template described at the beginning.

As described above, since an appropriate character string input area corresponding to the insertion location is inserted at the time of insertion, the insertion operation can be easily performed. At the same time, you can create syntactically correct programs.

In the examples of FIGS. 11 to 14, the insertable position is highlighted. On the other hand, the user may try to perform the insertion operation at a position other than the insertable position.

For example, in the example of FIG. 12, the function fun1 is 2
The argument function shall have no other optional arguments or arguments that can have any number of elements.
By the way, the information on the number of arguments is known in advance when the program component is a language element prepared by the system, that is, a built-in function. Further, even a user-defined function or the like can be recognized even when the processing system of the programming language is an interpreter type and the program definition is pre-read in the memory. In such a case, it is impossible to add more arguments as shown in FIG. In such a case, even if the graphic cursor is positioned at the position shown in FIG.
The portion 114 is not displayed with a thick line like the above.
Further, even if the mouse button or the like is pressed in this state to execute the insert command, the insert process is not executed. Instead, a warning sound will be emitted and a warning message will be displayed at an appropriate position on the screen, indicating that it cannot be inserted at that position.

In addition to this example, when the user tries to execute the insert command at an arbitrary position that cannot be inserted, a warning sound and a warning message are similarly issued.

This is the end of the description of the insertion operation of the character string input area.

In the character string input area introduced by the input operation of the graphic program or the insertion operation of the character string input area described above, the character string input area is used as an essential argument (argument that must be specified) of a function or the like. There is an equivalent,
If you try to finish editing without giving them any input, the string input area corresponding to the required argument is highlighted, and a warning sound and a warning message are issued.

Each of the above examples is an example in which a character string input is used to create and edit a program in the form of a diagram.

The above-mentioned example is an example applicable to general program editors in the form of a graphic, independent of the character string input from the keyboard.

(8) Paste, Move, Copy First, the operation of the paste command (paste command) and move / copy command will be described.

The paste command is a part of the graphic expression program displayed on the screen, which is a partial graphic expression program saved in advance in the save area in the editor by a cut command (cut command) or the like. Is a command to insert into. The move / copy command is a command for moving or copying a part of the graphic expression program displayed on the screen to another place. All the commands have a common point of moving a certain target (partial program) to a designated position.

This paste or move / copy command actually has two types of execution formats. One is an execution form that inserts the paste / move / copy target at a specified position, like the insertion of the character string input area, and the other is a form of replacing the paste / move / copy target with another target. It is an execution format that pastes, moves, and copies with.

In the execution form by insertion, if one of the paste, move, and copy commands is specified in the pull-down menu of the editor window and then the target is moved to the place where you want to insert it (in the case of move or copy command, , Before that, there is a step of specifying the object to be moved / copied). The department is highlighted. When a mouse button or the like is pressed in this state to instruct execution of a command, the processing of the specified command is executed. If the location of the graphic cursor is not the target insertable location, move the mouse cursor with the graphic cursor placed at that location.
The command is not executed even if the command is executed by pressing a button or the like. Instead, a warning sound and a warning message are issued (except when the graphic cursor is at a position where a paste / move / copy command can be executed by the following replacement format).

Here, the judgment as to whether or not the target can be inserted at the specified position by the paste / move / copy command is different from the case of the insertion of the character string input area, and is determined only by the type of the graphic part at the insertion position. Absent. It also relates to the type of target to be inserted. That is, FIG. 11 (a) and FIG. 12 (a)
In such a situation, the insertable target is the equivalent of one function that returns a return value, or a compound program whose top level is equivalent to that function. In the case of FIG. 13A, a pair consisting of a local variable and its initial value, FIG.
, Then the Common LISP language element con
It is a condition part / execution part pair that constitutes d. in this way,
Whether or not it is highlighted is determined by the graphic position pointed by the graphic cursor and the insertion target.

Next, paste / move / copy commands
An example of executing the replacement format will be described.

An example thereof is shown in FIG.

FIG. 15A shows a situation in which the graphic cursor 140 has been moved to a position to be pasted in the replacement format after the paste command is designated by the pull-down menu of the window or the like. In the figure, the position where you want to replace the saved target with the paste command (or rather, the target on the screen you want to replace) is the function fun1.
Character string input area 14 at the second argument position of the figure 100
It is 1. Also, cut before executing the paste command.
It is assumed that the program saved in the save area inside the editor by a command (cut command) is the one shown in FIG. In this situation, if you press the mouse button or the like to execute the paste command, you will see Fig.
15A, the character string input area 141 in FIG. 15A is replaced with the program graphic 111 in FIG. 15B and displayed.

By the way, in FIG. 15A, the graphic under the graphic cursor, that is, the graphic 141 is hatched and highlighted. This indicates that the graphic 141 can be replaced by the program saved in the save area and the paste command, as in the case of inserting the character string input area.

In this situation, if the figure cursor is released from above the figure 141 by operating the mouse or the like without executing the paste command (without pressing the mouse button or the like), the figure 14
1 returns to the normal display.

As described above, when the graphic cursor is moved to the pastable object after the paste command is specified, that area is highlighted as in the case of inserting the character string input area. User knows that it can be pasted by the replacement format,
Editing operation becomes easy.

In the example of FIG. 15, the replacement target displayed on the screen is the character string input area. However, the replacement target is not limited to this. You can replace any target displayed on the screen with the paste command. However, this does not mean that the arbitrary object displayed on the screen can be replaced with another completely arbitrary object, and the two need to be similar.

Whether or not the specified object on the screen can be replaced by the paste command depends on the paste format
Similar to command execution, it is determined by both the type of replacement target on the screen and the type of target saved in the save area. That is, in the case of FIG.
It is equivalent to a function that returns a return value, or a compound program whose top level is equivalent to that function. In addition, FIG.
When the local variable denoted by 125 in (b) is designated as the replacement target, the replaceable one is a local variable or a partial program in the form of a pair consisting of the local variable and its initial value. When the graphic 136 (one of the conditional clauses of cond) representing one conditional branch of the cond of FIG. 14B is designated as the replacement target, the replaceable one is the conditional clause of the same shape. Becomes As described above, whether or not replacement is possible is determined by both the graphic pointed by the graphic cursor, that is, the type of the replacement target, and the program in the save area of the editor, that is, the replacement target type. This determines whether or not the replacement target displayed on the screen is highlighted.

In this example, the graphic indicating the pasteable object is highlighted by hatching, but this may be performed by another method.
For example, it is possible to use a method in which a graphic is displayed in black and white in reverse, or when a display device capable of color display is used, the graphic is displayed with a color.

In the paste command execution state, as shown in FIG. 15 (a), the graphic cursor has a shape indicating the paste command execution state (the normal arrow is blacked out). With a small square).

In the above description, the processing of the paste command has been mainly described, but the same applies to the case of the move or copy command. That is, paste
The command only changes the replacement target with a save area to a target in another location on the screen.

In the above description, each process has been described assuming that the paste, move, and copy command execution forms include the insertion form and the replacement form. However, the user need not be aware of each execution form. Which form of execution depends on where the graphic cursor is located, that is, whether the graphic cursor points to a part of the shape on which the command is to be executed in insert form or to the figure target to be executed on the replace form Is decided. However, in either case, the graphic cursor points to a part of some graphic, and it is ambiguous to determine which execution format. However, this can be distinguished by appropriately setting the detection range of each execution format depending on the position of the graphic cursor. Further, since the detection of the figure by the replacement format is the whole figure and the detection of the figure by the insertion format is a part of the figure, the detection of the figure by the insertion format may be prioritized when either is ambiguous. Which executable the system recognizes is indicated by whether the entire graphic at the position of the graphic cursor is highlighted or a part of the graphic indicating the insertable position is highlighted. The user can easily judge the distinction between the execution formats. But,
If the highlighting of the insertion format and the highlighting of the replacement format are distinguished by colors or the like, it is possible to make it easier to understand.

In each of the examples of the insert, paste, move, and copy commands described above, it has been described that only the portion under the mouse cursor of the graphic program part is highlighted. However, it is also possible to highlight all command-applicable parts of the graphical program part under the mouse cursor. This may be more kind to the user. Furthermore, when an insert, paste, move, or copy command is activated, of all the graphic program parts in the graphic program displayed on the screen, all parts to which the command can be applied are highlighted. You can also In this case, it is convenient to see at a glance the parts to which commands can be applied.

(9) Deletion Next, a command for partially deleting the graphic expression program will be described.

FIG. 16 shows an example thereof.

FIG. 16A is a diagram showing the situation before the execution of the delete command. 151 (function fun2) in the figure is the deletion target. A selection operation is performed in advance using a mouse or the like, and as a result, the identification display is performed. If the delete command is executed here, a display as shown in FIG. Function fun
As a result of deleting 2, the function fun1 (150 in the figure),
Function fun3, which was an argument of function fun2 (15 in the figure)
2) and the function fun4 (153 in the figure) are packed, and the functions fun3 and fun4 are connected as the second argument and the third argument of the function fun1, respectively.

Here, the function fun1 is assumed to be a function of two arguments. In that case, the function fun3 is the second of the function fun1.
Since it is an argument, there is no problem in syntax. However, since the function fun4 comes to the third argument position of the function fun1, it is an extra argument of the function fun1. In order to show this situation, the function fun4 is highlighted in FIG. 16 (b) (153 in the figure) to indicate to the user that the function fun4 is in a syntactically incorrect position.

As described above, when a partial program having a syntactical error is generated as a result of the execution of the delete command, the location of the syntactically incorrect portion can be shown to the user by the above processing. This allows the user to create a program that is syntactically correct.

On the other hand, there is a case where the deletion target is deleted by the execution of the deletion command, and there is nothing that is connected to the upper graphic part. At this time, the character string input area in the uninput state is connected to that position.

By the way, the input / edit method of the graphic program described above can be applied not only to the program by the graphic expression method used in the above-mentioned various embodiments but also to the graphic expression program by other methods.

Consider, for example, the case where the C language is used as the base language and the PAD cited in the conventional example is used as the graphic representation method.

FIG. 17 shows an example.

Reference numeral 160 in FIG. 13A is a character string input area. Now, the character string “if” is input in the character string input area 160. When the conversion key is pressed in this state, it becomes as shown in FIG. Reference numeral 161 in FIG. 3B is a PAD graphic representing a conditional branch. Further, 162 is a character string input area for describing the content of the branch condition, and 163 and 164 are characters for inputting a program to be executed when the condition is satisfied (YES) and when the condition is not satisfied (NO). This is the column input area. The character cursor has moved to the beginning of the character string input area 162 to facilitate the next input.

FIG. 18 shows another example.

FIG. 15A shows a state in which the character string “switch” has been input in the character string input area 170, and when the conversion key is pressed in this state, it becomes as shown in FIG.

The C language switch statement is for transferring control to one of a number of subsequent statements (arbitrary number) according to the value of the expression. Each subsequent statement has a constant value for comparison with the value of the expression by the case prefix. swi
When the expression value of the tch statement and the constant value of the case prefix match, the body of the corresponding statement is executed.

171 of FIG. 18 (b) is a PAD figure representing a conditional branch, like 161 of FIG. 17 (b).
172 is a character string input area for inputting an expression attached to the switch, 173 and 175 are character string input areas for inputting a constant value for condition matching of the sentence, 174 and 176 are constant values of the expression 173 and 175, respectively. It is a character string input area to enter the program to be executed when it matches the numerical value.

In the state shown in FIG. 18B, the necessary contents are entered in the respective character string input areas (the state shown in FIG. 18C) and the conversion key is pressed, as shown in FIG. A character string input area of the execution program corresponding to the new case constant value is added (177 and 178 in the same figure). This utilizes the same function as the example described in FIG. By repeating the same operation, as many pairs of the case constant value and the character string input area of the execution program as possible can be added.

Further, if the conversion key is simply pressed in a state where neither the newly added case constant value nor the character string input area of the execution program is input, this additionally displayed pair is erased and the new pair of this pair is deleted. You can finish adding.

In addition, the method of inputting the program into the character string input area and converting it into the graphic representation as described with reference to FIGS. 4 and 5 can be easily applied to the PAD.

Various examples of the graphical program input editing method according to the present invention have been described above.

(10) Input Editing Program Next, a method for specifically realizing the input editing method of these graphic programs will be described.

FIG. 19 is a PAD diagram showing a basic control flow of the input edit control program 15 of FIG. FIG. 19
Shows the flow when the editor of the graphic representation program is started and the editor window is displayed on the screen.

As can be seen from FIG. 19, at first, the process waits for a user input from an input device such as a keyboard or mouse, and when an input is received, the corresponding process is performed, and the process returns to the input wait.

When an input is made from the keyboard or the mouse in step 200, the process proceeds to step 201 and the type of input is judged. If the input is from the keyboard, the process proceeds to step 202 and the input processing from the keyboard is performed. If the input is by pressing the mouse button, the process proceeds to step 203. If the input indicates that the command prepared in the pull-down menu of the editor window is selected, the process proceeds to step 204 to process the command.

FIG. 20 is a flow chart showing keyboard input processing.

First, in step 210, the input from the keyboard is determined. If the input is character data, the process proceeds to step 211 and character input processing is performed. If the input is a conversion key, the process proceeds to step 212, and the keyword input in the character string input area is converted into the corresponding graphic template. If the input is various edit keys on the keyboard (eg, insert, delete, backward, etc.), the process proceeds to step 213, and the process corresponding to the input edit key is performed.

Next, regarding character input and conversion processing,
This will be described with reference to the example of FIG.

FIG. 21 shows the contents of the graphic representation program file 13 of FIG. Here, as an example, the internal data 527 corresponding to the schematic program displayed in FIG. 2A is shown.

Reference numeral 300 in FIG. 21 denotes the function fo in FIG.
This is internal data for the figure 51 of o. Hereinafter, such internal data for various graphic program parts on the screen will be referred to as "cell". The cell 300 has a plurality of slots for storing data necessary for displaying the function foo51 on the screen.

In the first slot "classification", a name indicating the cell type is entered. In this case, since it is a function, the name “function” that indicates the function is included.

In the second and third slots "position" and "size", information of position and size information when the figure of the function foo is displayed on the screen, specifically, two-dimensional coordinate values and dimensions. Is included.

The fourth and subsequent slots are slots peculiar to graphic parts expressing functions.

A slot "name" is a pointer to a cell 301 holding data representing a function name, and a slot "argument" is a cell 3 representing data representing a function argument.
A pointer to a pointer 305 that points to 02, a pointer to a cell 308 that represents the graphic data of a frame that represents the concrete shape of the function in the slot “frame”, and a return value of the function in the slot “return value arrow”. The pointers to the cells 303 representing the data representing the graphic of the indicated arrow are respectively entered.

For example, the slot “name” contains not the character string “foo” itself but a pointer pointing to the cell 301 holding the data expressing the character string. The data representing the part name is set as an independent cell because the character string representing the function name has its own "position" and "size" information in addition to the "function" cell. The reason is that is not fixed data, and this is also subject to input editing.

The cell 301 has a slot such as "character string" as a unique slot.

The content of "classification" of the cell 301 is not "mere character string" but "character string input area". This is the name of the function (in this case "f
This is because oo ″) can be modified and changed later. A more detailed description of the “character string input area” will be given later.

The cell 302 is connected to the slot “argument” of the cell 300 via the cell 305. Cell 30
2 is a cell corresponding to the character string input area 52 of FIG. The reason why the cell 302 is not directly connected to the slot argument is that there are generally a plurality of function arguments. The cell 305 is auxiliary data for connecting the plurality of arguments and combining them into one.

In the slot "frame" of the cell 300, the cell 3
08 is connected. A cell 308 is data for displaying a rectangle, and in this case, the function foo of FIG. 2A is used.
It is used to display a box of functions that is the graphical representation of (51).

In the cell 308, in addition to the slots of “classification”, “position”, and “size”, “frame shape” and “frame thickness” are set.
There are slots for "frame color". Shapes of lines that represent rectangular frames-Types such as solid lines, dotted lines, and broken lines-
-, Thickness, and color information are stored.

The slot "return value arrow" of the cell 300 contains the cell of the arrow of the cell 303. This cell 3
03 has slots of “start point”, “end point”, “shape”, “thickness”, and “color”. These slots are the same as the slots of the cell of the line segment shown in FIG. The arrow is basically the same as the line segment, and the shape of the arrow is added to it. Therefore, the arrow
It can be represented by a slot common to the line segment.

The cell 302 has, as a unique slot,
It has slots of "character string" and "return value arrow".

A character string input from the keyboard is entered in the slot "character string" of the cell 302. The slot “return value arrow” contains a pointer indicating the cell 304 corresponding to the arrow 58 pointing from the character string input area 52 to the function 51 in FIG.

Reference numerals 306 and 307 in FIG. 21 are common variables representing the "character string input area with the character cursor" and the "character cursor position" within the character string input area, respectively. In FIG. 2A, the character cursor is in the character string input area 52 (53 in the figure). Therefore, the variable 306, that is, the “character string input area with the character cursor” contains the pointer pointing to the cell 302 corresponding to the character string input area 52 of FIG. Also, the character cursor itself is
Since it is at the 4th character of the 1st line of the character string input area (the 4th character is the position to input the character next), the value (4, 1) is stored in the variable 307, that is, the “character cursor position” .

When a character is further input from the keyboard in this state, the character is inserted and displayed at the position of the variable "character cursor" by the processing (character input processing) of step 211 in FIG. 20, and the character cursor is moved to the right by one. Move.

When a key input corresponding to various editing functions such as insertion and deletion is made, step 21 in FIG.
At 3, processing such as insertion and deletion of characters is performed.

On the other hand, if it is determined in step 210 of FIG. 20 that the input from the keypad is the conversion key, the process proceeds to step 212 and the conversion key is processed.

22 and 23 show details of the conversion key processing.

As can be seen from the figure, the processing differs variously depending on the situation when the conversion key is pressed.

First, in step 220, when the conversion key is pressed, it is determined which character area the character cursor is in. When the character cursor is in the character input area corresponding to the actual argument of the function or the initial value of the variable, the process proceeds to step 221. The case like FIG. 2A corresponds to this (the character cursor 53 is in the character string input area 52 at the argument position of the function foo (51 in the figure)). This also applies to the case where the character cursor is within the character input area corresponding to the initial value of the local variable definition, such as 73 in FIG.

Next, in step 221, it is determined whether or not a character string has already been input in the character string input area. If the character string has already been input (as in the case of FIG. 2A), conversion processing into a graphic program is performed (step 222). Details of the conversion process will be described later.

If it is determined in step 221 that no character string has been input in the character string input area where the character cursor exists,
The type of the character string input area is determined (step 223 in FIG. 22). If the character string input area is an initial value of an optional argument or variable of the upper cell, the character string input area is deleted (step 224). Here, the optional argument or the initial value is, for example, the argument el of the if
se (84 in FIG. 8B) or FIG.
Is the initial value of the local variable of let (73 in the figure). Also, one of the arguments that can be set in any number, such as the variables in the variable list of the let, corresponds to this.

In step 223, if the character string input area in which the character cursor is located corresponds to an argument that cannot be omitted, nothing is done. An argument that cannot be omitted is an argument that must be specified, for example, the argument n of the function rem.
Umber, divisor, etc.

After step 223, next step 22
At 5, 226 and 227, the process of moving the character cursor to the next character input area is performed. At step 225, the user is paying attention (when the corresponding character string input area is deleted,
Check whether there is a subsequent argument in the character string input area. If there is a subsequent argument, move the character cursor to the character string input area for that argument (step 22).
6). If there is no trailing argument, it recursively searches for the argument of the language element higher than the character string input area, and the character cursor is moved to the first character string input area found relatively behind the character string input area. Move (step 22)
7).

In step 220 of FIG. 22, the character string input area where the character cursor is located is one of the variables in the variable list, that is, the local variable list of let and the function definition defun.
If it is one of the variables in the variable list of the parameter list of do or the variable list of the repetition control variable of do, then in step 228, it is checked whether or not a character string is already input in the character string input area. . If the character string has already been input, the variable name is changed to the content of the designated character string (step 229). If the character string has not been input in the character string input area, the character string input area is deleted as in the case of step 224 (step 23).
0).

Although not shown in the figure, step 2
After the processing of 28, 229 and 230, 225 of FIG.
A process of moving the character cursor to the next character string input area as shown by 226 and 227 is performed.

At step 220, the character string input area with the character cursor is the name display area of the graphic part corresponding to the language element, for example, the function foo or the function rem of FIG. 2B.
Character area (59, 60) indicating the name of the
8 is in the name display area (71) of the block structure let or the name display area (80) of the conditional branch if of FIG. 8A, in step 231, the character string and the graphic part displayed in that area are displayed. Match the name of. If they match, do nothing. If they are different, it is interpreted as a change instruction for the graphic component, and the displayed graphic component is changed to the graphic component having the name designated by the character string (step 232). At this time, as described in the example of FIG. 9, if there is a mismatch between the arguments before and after the change, the missing arguments are supplemented and the excessive arguments are highlighted to alert the user.

After the change, the character cursor is moved to the head of the character string input area corresponding to the first argument of the new graphic part (step 233).

Next, the contents of the conversion processing (step 222) into the graphic program of the steps of FIG. 22 will be described.

FIG. 24 is a schematic program parts table 1 of FIG.
6 shows the contents of 6. The elements of the table each include a name, a syntax by a character expression, and data about a graphic representing a corresponding graphic program part for each language element of a used language (Common LISP in this case).

Note that "..." In FIG. 24 indicates that any number of the same items are repeated. For example, in “general function” of item number 1, “...” after <argument 2> in the “character expression syntax” column is <argument 3><
It indicates that the arguments 4> ... Continue as many times as necessary.
The same applies to "schematic program parts". However, since it is an arbitrary number, it is not necessary to continue anything. In addition, although the case where the "general function" has one argument is not shown, the description is omitted because it is almost the same as the case of item number 1.

FIG. 25 shows a conversion process 2 into a schematic program.
22 shows a flow of No. 22.

In step 240, first, the contents of the character string input in the character string input area are examined. If this is a character string that represents the name of a function, variable, etc., the processing proceeds to step 241, where it is the schematic program parts table 16
Check if it is registered in. If a match is found in the table, the graphic part corresponding to the language element represented by the character string and the character string input area corresponding to each argument are displayed. Also, the character string input area for each argument is displayed. The formal parameter name of the argument is displayed in italics (steps 242 and 243 in FIG. 16). At this time, part of the function of the program 12 from the character representation to the graphic representation conversion in FIG. 1 is used for the conversion from the character string to the corresponding graphic part or the like. The function rem of FIG. 2B, the block structure let of FIG. 6, the conditional branch if of FIG. 8A, and the like are displayed by this processing. In addition, step 2
43, when the dummy argument name is designated to be displayed in the box of the function or the like as shown in FIG. 3 instead of the character string input area corresponding to the argument as shown in FIG. 2B, The processing is performed accordingly.

On the other hand, when the character string is a name not registered in the conversion rule table 6 in step 241, it is determined that the name is the name of the user-defined function. Then, a general-purpose function call graphic part and a character input area corresponding to one argument thereof are displayed (step 244). Figure 2
The function foo in (a) is displayed as a result of this processing.

After step 241, the process proceeds to step 245, and the character cursor is moved to the beginning of the character string input area corresponding to the first argument of the newly generated and displayed graphic component.

When it is determined in step 240 that the character string represents a (partial) program, the "partial" program is used by using the "program for converting character representation to schematic representation" 12 in FIG. Is converted into a graphic representation program (step 246).

In the above description, FIG. 25 is the "conversion processing to the graphic program", and step 246 in it.
The processing content of is "Convert character representation program to diagram representation"
Therefore, there is a fear that they may represent the same thing. However, there are the following differences between the two.

First, in the processing contents of step 246, the character expression program is converted into a graphic expression program. That is, it is a process of converting a certain form of “program” into another form of “program”.

On the other hand, the processing of FIG. 25 as a whole includes the processing of step 246, but other processing, that is,
When the name of the graphic program part is given as the input character string, the process of converting this into the corresponding graphic program part is included (steps 241, 242, 243, 24.
4, 245).

The latter process is not a (complete) program conversion process, but a "very small part" of the program, that is,
This is a process of giving a “name” of a graphic program component and displaying a corresponding graphic component. Please do not misunderstand this point.

Note that the processing of step 246, that is, the "program for converting from character representation to graphic representation" 12 in FIG.
For details of the above, as described above,
Since the method described in (056360) can be used, the description is omitted here.

The conversion from FIG. 4 (a) to FIG. 4 (b) described above is performed by the process of step 246 described above, that is, the process of the "program for converting character representation to diagram representation" 12 of FIG. It is a thing. If the character string given at this time is a program containing an error as shown in FIG. 5A, a character string input area for an insufficient argument is appropriately added as shown in FIG. Highlights and alerts the user.

Next, the mouse button processing 203 of FIG.
Will be described.

The mouse is usually used to operate a graphic cursor displayed on the screen to select an object on the screen, specify a location to which a command is applied, and the like.

If the graphic expression program is already displayed on the screen, the graphic cursor is moved to the vicinity of the graphic component forming the program and the mouse button is pressed to select the graphic component. The selected graphic is highlighted by reverse display or the like in order to notify the user that the graphic has been selected. After that, commands such as cut (cut), move, copy, and delete can be executed on the selected graphic part.

When the graphic cursor is moved to one character input area and the mouse button is pressed, the character cursor is moved to the position designated by the graphic cursor in the character input area.

Next, the command processing 204 of FIG. 19 will be described.

FIG. 26 is the detailed flow thereof.

First, in step 250, the type of command is determined. If the command is an insert command, step 2
51, to step 252 if it is a paste command,
If it is a move command, go to step 253, if it is a copy command, go to step 254, and if it is a delete command, go to step 2
If it is a reverse conversion command to 55, that is, a command to (reverse) convert a partial graphic program designated on the screen to a character program, the process proceeds to step 256.

27 and 28 show the processing flow of the insert command.

Before entering the description of FIGS. 27 and 28, the method of highlighting the insertable position described in FIGS. 11 to 14 will be described.

In order to highlight the portion when the graphic cursor comes to the insertable position, first the coordinates of the position where the graphic cursor is at that time are read. This is then checked against the coordinates of the graphic at that location. If this is within a certain error and it is determined that the position of the graphic is the insertable position, that part is highlighted. At this time,
The problem is how to determine whether or not the corresponding part of the figure is the insertable position, but this can be easily done as follows.

Corresponding to the highlighted portion shown in FIGS. 11 to 14 (insertable position display figure)
Are created in advance corresponding to the insertable positions of all the graphic parts displayed on the screen. However, it is usually generated only in a form invisible to the user, that is, as an internal data. Then, when the insert command is activated and the insert command mode is entered, the position coordinates of the graphic cursor are compared with the coordinates of this insertable position display graphic, and if within a certain error, this graphic is displayed on the screen. When the figure cursor moves away from the figure, the figure is returned to the invisible state.

A concrete explanation will be given by taking the example shown in FIG. 12 as an example. FIG. 29 is a diagram in which FIG. 12 is almost reproduced.
However, in addition to the elements shown in FIG. 12, two insertable position display diagrams 116 and 118 are added. In addition, FIG.
Insertable position display figure 114 that was displayed with a thick line in
Is displayed as a dotted line like the figures 116 and 118. The figures 114, 116 and 118 schematically show the above-mentioned invisible figures, and the dotted lines are shown in FIG. 29 for the convenience of description. Similarly, for convenience of description, the positions where the figures 114, 116, and 118 are present are shown in the figure 1.
Although slightly deviated from the right side of 10 to the right, these figures are actually at positions overlapping the right side of the figure 110 representing the function fun1. These three figures are for showing that a program can be inserted in each position.

Now, in this state, it is assumed that the figure cursor comes over the figure 114. Then, according to the above explanation,
The figure 114 is revealed, and the figure 114 is displayed in a thick actual battle as shown in FIG.

The same applies to the figures 116 and 118. When the figure cursor is placed on either of the figures, the corresponding figure is kept alive and displayed in a bold line, indicating that the program can be inserted at that position. The figures 116 and 118 are
They are prepared in advance to indicate that they can be inserted before the first argument and after the second argument of the function fun1, respectively.

FIG. 30 shows the internal data of the schematic program shown in FIG.

Reference numerals 310, 311, and 312 in FIG. 30 are cells corresponding to the functions fun1, fun2, and fun3 in FIG. 30, respectively. As compared with the cell 300 of FIG. 21, a slot “insertable position display graphic” is newly added to each cell. This is omitted in FIG. 21 for simplification. Further, in order to simplify the drawing, a character string representing the name is directly described in the slot "name". Also, the cells representing the frames are not shown for simplicity.

Numerals 316 to 318 in the figure are cells respectively corresponding to the figures 114, 116 and 118 for displaying the insertable position in FIG. "Classification" of a normal cell
In addition to each slot of "position" and "size", it has a slot "display" as a unique slot. This slot "display"
Has “display” or “non-display” as a value. Normally, the value of this slot is "non-display", but when the figure cursor comes near these figures, that is, the position coordinate of the figure cursor is the area indicated by the slot "position" and "size". When overlapping within a certain error, the slot value changes to "display". At this time, the corresponding graphic is displayed on the screen by the input display control program 6 of FIG.

By the way, in FIG. 30, a slot "display" is newly added to the cells 314 to 315 corresponding to the graphic of the arrow indicating the return value of the function or the like. Figure 11
As is clear from (a), in the case of an arrow, when the graphic cursor comes over it, the entire arrow is highlighted. Therefore, in the case of the arrow, the insertable position display figure is not provided separately, and the function is set as the arrow attribute. The value of this "display" slot is "normal display" or "highlighted", unlike the above. When the graphic cursor is on the arrow, the value of the slot "display" becomes "highlighted", and when the graphic cursor leaves it, it returns to "normal display".

The cells 320 to 324 are cells used to connect a plurality of elements together into one slot, like the cell 305 in FIG.

By the above method, when the graphic cursor comes over the graphic indicating the insertable position, that graphic is highlighted.
When the graphic cursor moves away from it, the highlighting of that graphic is removed.

By using this method, it is possible to easily detect an error when the mouse button is pressed at a position where it cannot be inserted. This is done as follows. Find out which cells with a "display" slot are displayed on the screen and whose value is "display" or "highlight". When there is no such thing, the graphic cursor is pointing at a position other than the insertable position,
If the mouse button is pressed at this time, it is known that there is an error.

The method of highlighting the insertable position is as follows.
In case of the above insert command, paste, move,
In addition to the case of a copy command, etc., it can also be used in the case of displaying a position-dependent attribute generally only when the graphic cursor comes there.

The above-described method is also applicable to highlighting all positions where insertion (or paste, move, copy) is possible in the above-described schematic program part unit, and also to the schematic displayed on the screen. It can be easily extended to a method of highlighting all the parts to which commands can be applied among all the graphic program parts in the program.

This is the end of the basic description of the insertable position highlighting display method, and returns to the description of the processing flow of the insert command of FIGS. 27 and 28.

When the insert command is instructed, the keyboard / mouse input mode is first set to the insert mode (step 260 in FIG. 27). When you enter insert mode,
Input from other than the mouse is not accepted until the command execution is completed. That is, it is a mode in which only the position specification input by the mouse and the input of the mouse button press are accepted. At the same time, the graphic cursor displayed on the screen is changed to a shape indicating the insert mode to notify the user that the insert mode is currently set.

After that, until the mouse button is pressed,
The highlighting and cancellation of the insertable position corresponding to the position of the graphic cursor are repeated (step 261).

At the beginning of the repetition, the position of the graphic cursor is first read (step 262). The display position of the graphic cursor is controlled by the mouse, which is performed in the input display control program 6 of FIG. Here, an inquiry is made to the input display control program 6 to obtain the position coordinate value of the graphic cursor.

Next, it is determined whether or not the position coordinates of the read graphic cursor are in the vicinity of the graphic for displaying the insertable position described above (step 263). If it is in the vicinity, then it is determined whether or not there is a previously insertable position graphic (highlighted) (step 26).
4). If there is an insertable position display graphic that is (highlighted) displayed, it is further determined whether the (highlighted) displayed graphic is the same as the graphic under the graphic cursor (step 265). If they match, do nothing (that is, keep the (highlight) display as is). If the two are different, the (highlight) display of the previously insertable position display graphic (highlight) is canceled (step 266),
The insertable position display graphic pointed by the graphic cursor is displayed (emphasized) (step 267).

If it is determined in step 264 that there is no previously insertable position graphic (highlighted) displayed, the insertable position display graphic under the graphic cursor is simply (highlighted) displayed (step 268). .

If it is determined in step 263 that the graphic cursor is not on the insertable position display graphic, then
It is determined whether or not there is an insertable position display graphic that has been (highlighted) displayed before (step 269), and if there is, that (highlighted) display is canceled (step 270).

The above processing is repeated until the mouse button is pressed.

When it is detected that the mouse button has been pressed, the loop in step 261 is exited and the process proceeds to step 271. In step 271, it is determined whether or not there is an insertable position display graphic that is (highlighted) displayed.
If there is an insertable position display graphic that is (highlighted) displayed, the insertion processing of the character string input area is executed at the position indicated by the graphic (step 272). (Emphasis)
When there is no insertable position display graphic displayed, a warning sound and a warning message indicating that insertion is impossible are issued (step 273).

Finally, the insert mode is canceled and the keyboard and mouse inputs are returned to the normal mode. Also, the graphic cursor is made into a normal shape (step 274).

Next, details of the insertion processing in step 272 of FIG. 33 will be described.

As described with reference to FIGS. 11 to 14, the graphic part to be inserted differs depending on the insertion position. The type of the component to be inserted is determined using the table of FIG. 31 as follows.

The table of FIG. 31 shows the correspondence between the insertion positions and the parts to be inserted. In the table, the insertion position is indicated by the type of graphic component and the slot name of the cell of the graphic component. The slot name of the cell of the latter graphic component corresponds to the position of the insertable portion of the graphic component.

The insertable position highlighting function allows the insertable position display graphic to be highlighted when the mouse button is pressed in the insert command mode.
Therefore, first, the cell of the internal data for this graphic is taken out, and then the cell of the graphic component above it is taken out from this cell. Here, in FIG. 30, the directions of the pointers between the insertable position display graphic and the graphic parts to which the insertable position display graphic belongs are opposite to each other. Therefore, it is not easy to take out the upper graphic part as it is. However, since the internal data of the graphic expression program as shown in FIG. 30 basically has a tree structure, if the tree structure is traced from the head, the (insertable) position at which insertion is possible is displayed. It is easy to find a graphic component above the display graphic. Alternatively, the slot of the cell may be expanded and a reverse pointer may be provided from the insertable position display graphic to the graphic component of the upper level.

Next, it is checked which slot of the cell of the higher-order graphic component the connected insertable position display graphic of interest is connected to. And the name of the obtained slot,
Referring to FIG. 31, using the information on the type of higher-order graphic parts,
Determine the type of graphic part to be inserted.

By the way, in order to perform the insertion processing on the graphic representation program, it is necessary to know to which position of the upper-order graphic component the position designated by the insertable position display graphic corresponds.

In the case of the example shown in FIG. 11, the insertable position display figure is an arrow indicating the return value of a function or the like, and since there is normally only one arrow, the insert position is the place where this arrow is. I understand. However, in the case of Fig. 12,
Although the insertion position is the position of the argument of the function, there are three further possibilities: before the first argument, between the first and second arguments, or after the second argument. To determine which it is, do the following:

The insertable position display figure 114 shown in FIG.
In the internal data of the schematic representation program of FIG. 30, cell 3
Corresponds to 17. The cell 317 is the front and rear cells 316, 3
18 together with cell 3 of the higher-order graphic part (function fun1)
It is connected to the slot 10 "insertable position display graphic". The arrangement of these cells corresponds to the spatial arrangement order of the cells. Therefore, it is possible to clarify the specific insertion position by checking the position of the cell of interest in these cells belonging to the same group.

With respect to the cells 316 to 318, since the cell 316 corresponds to the insertable position display graphic 116 of FIG. 29, the position before the first argument is the cell 317 of FIG.
Since it corresponds to the insertable position display figure 114 of 9,
The position between the first and second arguments is also cell 318.
Corresponds to the insertable position display figure 118 of FIG. 29, and therefore, respectively indicates the positions after the second argument.
Therefore, in the example of FIG. 12A, it can be seen that the insertion process may be performed at the position between the first argument and the second argument.

The character string input area insertion processing is executed by using the information of the insertion component type and insertion position obtained as described above.

In the above, the description has been given mainly using the examples of FIGS. 11 and 12, but also in FIGS. 13 and 14, the insertion processing can be executed using the same method.

Next, the processing of the paste command (step 252 in FIG. 26) will be described.

As described above, the paste command is
The command can be executed in the insertion format or the replacement format. In any case, there is a command execution position highlighting function and an error notification function when command execution is instructed at a command execution impossible position. These can be executed using a method similar to the case of the above insertion command.

When the figure cursor is brought to the position where the paste command in the insert format can be executed, it is checked whether or not there is an insertable position display figure at the position of the figure cursor as in the case of the above-mentioned insert command. If there is, the slot of the upper graphic part to which the insertable position display graphic is connected is checked. If you can compare this slot with the topmost graphic component of the graphic program that is the paste target and connect the graphic component that is the paste target to that slot, the insertable position display graphic that you are paying attention to Is displayed (emphasized).

This connection availability check is performed by adding an attribute of a connectable target to the slot, or separately.
This can be easily done by preparing a comparison table of slot names and connectable objects.

When the graphics cursor is brought to the position where the paste command in the replacement format can be executed, the slot of the graphics component above the graphics component under the graphics cursor and the topmost graphics program of the paste program Check the parts. If it is known that the paste target graphic component can be connected to the slot, the graphic component under the graphic cursor is displayed (emphasized). Note that, for this (emphasized) display, each graphic component cell needs a slot (for example, “display”) for expressing it.
Also, the connection availability check can be performed in exactly the same manner as the connection check in the above insertion format.

Error detection when the mouse button is pressed at a position where paste is not possible can be performed in substantially the same manner as in the case of the insert command. That is, it suffices to check the presence or absence of (highlighted) display by the paste command on the screen. If nothing is (highlighted) displayed, the graphic cursor points to a position other than the pasteable position, and if the mouse button is pressed at this time, it is known that an error has occurred.

The specific execution of the paste command also follows the case of the insert command. That is, in the case of execution by the insert format, the insertion position is specifically obtained in the same manner as in the case of the insertion command, and the graphic program saved in the save area is inserted at that position. In replacement form,
Replace the contents of the corresponding slot of the cell of the upper graphic part under the graphic cursor with the schematic program saved in the save area.

Now, the processing of the delete command in step 255 of FIG. 26 will be described. In order to execute the delete command, it is necessary to select in advance a graphic part to be deleted by a position specifying device such as a mouse. Next, when the delete command is specified, the cell of the selected graphic component which is highlighted is obtained, and further the superordinate cell thereof is obtained. Remove the cell of the selected graphic part from the corresponding slot of the upper cell. If this graphic part has an argument, the cell of the graphic part corresponding to this argument is removed from the corresponding slot of the cell of the selected graphic part. Then, the cell of the removed graphic component is connected to the slot of the cell above the cell of the selected graphic component to which the graphic component selected so far is connected. At this time, when the selected graphic part has multiple arguments, the remaining arguments except one are generally excessive arguments, so these are set as the slots of the "extra argument" of the cell of the higher-order graphic part. Connect to. After the above processing for the internal data is completed, the schematic program displayed on the screen is corrected based on this data. The graphic program connected to the slot of "extra argument" is highlighted so as to notify the user that the argument is excessive. If the selected graphic part has no argument in the lower order, the cell of the character string input area is newly connected to the cell of the higher order graphic part.

Finally, the process of reverse conversion from the graphic program to the character program in step 256 of FIG. 26 is performed.

To do this, the cell for the previously selected graphic program may be taken out and the processing may be requested to the inverse conversion program 14 from the graphic expression to the character expression in FIG.

For the processing of the reverse conversion program 14, the method described in the prior application (Japanese Patent Application No. 2-056360) can be used. Therefore, the detailed description of the processing is omitted here.

The specific implementation methods of various input editing methods have been described above.

[0252]

As described above, according to the present invention, it is possible to input a figure only with characters, that is, only with a keyboard. With this, even when there are many graphic parts, the graphic can be directly displayed on the screen by using the name thereof, without the troublesome operation of searching for a desired one from many items on the menu.

Further, according to the present invention, a program represented by a graphic can also be written only with characters, that is, a keyboard.
It is possible to input without specifying a special figure. As a result, the problem of input, which has been a bottleneck in creating a conventional graphic expression program, is solved, and the program can be input with the same input efficiency as that of the character expression program.

Furthermore, when inputting the program,
When the name of a programming language element is entered, the schematic representation corresponding to that language element and the accompanying arguments are shown together, so even if the user is uncertain about the type and order of the arguments that the language element has, You can enter the program without checking the manual one by one.
Naturally, the error of the program due to the misunderstanding regarding the kind and order of the arguments can be completely eliminated by using the schematic program input editing method according to the present invention.

In addition, when a new program is inserted, a program saved in the save area in advance by a cut command or the like is pasted, and a command such as move or copy is executed, the command can be executed at a position where the command can be executed. Will be displayed on the screen, so you will never execute the above command at the wrong position.

Even in the case of deletion, if the syntax of the program is improper as a result, it will point to the incorrect part, so that the editing of the program ends with the syntax being incorrect. Will prevent.

As described above, by using the method according to the present invention, it is possible to efficiently create a program that is syntactically error-free by using a program expression in an easy-to-understand diagram.

In the above description of the input / editing method of the graphic program, an example in which the program in the existing programming language is graphically expressed has been described. However, it is needless to say that the present invention can be applied to a so-called visual language, that is, a programming language based only on a diagram that does not have a character representation format, as described above. Furthermore, it can be easily applied to not only the program by the graphic representation but also various drawings represented by the tree structure or network structure such as the electronic circuit diagram and the chemical plant piping diagram. It is also effective in preventing a syntactic error in the created drawing.

[Brief description of drawings]

FIG. 1 is a diagram showing a system configuration of a schematic program input editing method according to the present invention.

FIG. 2 is a diagram showing an input example of a schematic program according to the present invention.

FIG. 3 is a diagram showing another display method of dummy arguments.

FIG. 4 is a diagram showing an example of conversion of a character program into a graphic program.

FIG. 5 is a diagram showing an example of conversion of a character program including an error into a graphic program.

FIG. 6 is a diagram showing an input example of a schematic program according to the present invention.

FIG. 7 is a diagram showing an example of automatic addition of an argument in which an arbitrary number can be set.

FIG. 8 is a diagram showing an input example of a schematic program according to the present invention.

FIG. 9 is a diagram showing an example of changing a graphic part by changing a name.

FIG. 10 is a diagram showing another example of changing a graphic part by changing a name.

FIG. 11 is a diagram showing an example of inserting a character string input area.

FIG. 12 is a diagram showing an example of inserting a character string input area.

FIG. 13 is a diagram showing an example of inserting a character string input area.

FIG. 14 is a diagram showing an example of inserting a character string input area.

FIG. 15 is a diagram showing an example of executing a paste command in a replacement format.

FIG. 16 is a diagram showing an example of partial deletion of a schematic program.

FIG. 17 is another schematic representation (PAD) of the method according to the invention.
It is a figure which shows the example of application to.

FIG. 18 is another schematic representation (PAD) of the method according to the invention.
It is a figure which shows the other example of application to.

FIG. 19 is a diagram showing a flow of an input editing program.

FIG. 20 is a diagram showing a flow of keyboard input processing.

FIG. 21 is a diagram showing an example of internal data representation of a graphic representation program.

FIG. 22 is a diagram showing a part of the flow of the conversion key processing.

FIG. 23 is a diagram showing an original flow of conversion key processing.

FIG. 24 is a diagram showing the contents of a schematic program parts table.

FIG. 25 is a diagram showing a flow of conversion processing into a schematic program.

FIG. 26 is a diagram showing a flow of command processing.

FIG. 27 is a diagram illustrating a part of the flow of an insert command process.

FIG. 28 is a diagram showing the flow of another portion of the insert command processing.

FIG. 29 is a conceptual diagram for explaining a method of highlighting an insertable position.

FIG. 30 is a diagram showing another internal data representation of a schematic program.

FIG. 31 is a table showing the correspondence between the insertion position of the character string input area and the parts to be inserted.

FIG. 32 is a diagram showing a conventional program.

[Explanation of symbols]

1 ... Control device such as personal computer or workstation, 2 ... Display device, 3 ... Keyboard,
4 ... Position indicating device such as mouse, 5 ... Graphic data file, 6 ... Input display control program, 7 ... Graphic input editing program, 8 ... Graphic input program, 9 ... Name graphic correspondence table, 10 ... Personal computer, work Control device such as station, 11 ... Source program file by character representation, 12 ... Conversion program from character representation to graphic representation, 13 ... Schematic representation program file,
14 ... Program for reverse conversion from schematic representation to character representation, 1
5 ... Input editing program for schematic representation program, 16 ...
Schematic program parts table, 501-537 ... Title of each figure.

Claims (33)

[Claims] 1. In response to a character string representing any constituent element of a program to be input, which is input at any position on a display screen, it is stored in advance corresponding to the character string. , A graphic representing that component is displayed at that position, and if there is at least one other component to be entered in relation to that component, the area where that other component should be entered is Input support method to display in the vicinity of. 2. The input support method according to claim 1, wherein the area is displayed at a position having a predetermined relative positional relationship with respect to the graphic. 3. The input support method according to claim 1, wherein the program is displayed by connecting the area to the graphic. 4. If the above component requires an argument,
The program input support method according to claim 1, wherein an area where the argument is to be input is displayed as an area where the other component is input. 5. The program input support method according to claim 1, further comprising the step of displaying a character string representing the type of the other component to be input. 6. When the above component requires an argument,
The program input support method according to claim 5, wherein the area is an area in which the argument is to be input, and the character string indicating the type of the other component is a name of a dummy argument included in the component. 7. The character string representing the type of the other component is
The program input support method according to claim 5, which is displayed inside the area. 8. The character string representing the type of the other component is
7. The program input support method according to claim 6, which is displayed inside the area. 9. The character string representing the type of the other component is
The program input support method according to claim 9, wherein the program is displayed at a position close to the area inside or near the graphic. 10. The program input support method according to claim 1, further comprising the step of moving a cursor indicating a character input position to a head position in the area after displaying the area. 11. When the component does not require another component to be input in relation to the component, display is made for the component represented by the closest graphic behind or above the graphic. 11. The program input support method according to claim 10, further comprising the step of moving the character cursor to a head position of an area for inputting another component required by the character cursor. 12. When a program statement forming another constituent element is input as the other constituent element, the syntax of the program statement is analyzed, and a group of figures reflecting the syntax is displayed in the area. Instead of
2. The program input support method according to claim 1, further comprising a step of displaying the graphic at a position having a predetermined relative positional relationship with the graphic. 13. The other structure displayed in the area in response to input of a part of the character string or the character string representing the other constituent element in the displayed area. 8. The program input support method according to claim 7, further comprising the step of deleting a character string representing the type of element and displaying the input character string in the area. 14. When the input constituent element requires a plurality of other constituent elements, a plurality of areas for inputting the plurality of other constituent elements are respectively displayed at the time of the display.
The program input support method according to claim 1, wherein the program input support method is displayed in the vicinity of the figure. 15. The program input support method according to claim 14, wherein the plurality of areas are displayed simultaneously. 16. When the input constituent elements require a plurality of other constituent elements of the same type but the number thereof is arbitrary, the plurality of areas are sequentially displayed at the time of the display.
In the sequential display, one of the plurality of areas is displayed, and after a character string representing another component is input to the displayed one area, another one of the plurality of areas is displayed. 15. The program input support method according to claim 14, which is performed as displayed. 17. The program input support method according to claim 16, wherein the plurality of areas are displayed below an area previously displayed therein. 18. The program input support method according to claim 1, further comprising the step of erasing the area in response to a user instruction when the other component is an optional component. 19. The erasing is performed when a character string is not yet input to the area or only a blank character is input, and when a character cursor is in the area. 19. The program input support method according to claim 18, wherein the program input support method is performed when a user depresses a specific key or button. 20. When the user gives an instruction to finish editing the program later, the other constituent elements are constituent elements that cannot be omitted, and a character string has not yet been input to the area. Or if only blank characters are being input, and if the result of the determination is affirmative, then the area must be identified so that it can be identified that the character input to this area has not ended. 2. The program input support method according to claim 1, further comprising a step of changing the display of. 21. When a program input by a character string in the area has one or more insufficient constituent elements, a graphic corresponding to the program in a form including an input area corresponding to the constituent element at a corresponding position. 2. The program input support method according to claim 1, wherein is displayed. 22. A graphic corresponding to the program is displayed in such a manner that when the program input by a character string in the area has one or more excessive constituent elements, the constituent elements are identified and displayed. Program input support method. 23. In response to a character string representing any constituent element of a program to be input, which is input at any position on the display screen, the character string is stored in advance in correspondence with the character string. , A graphic representing the component is displayed at that position, and when there is at least one other component to be input in relation to the component, that other component should be input, the vicinity of the graphic. And a program input support method for instructing on the display screen a position determined by the above components. 24. The program input support method according to claim 23, wherein said instruction is performed by moving a character cursor to that position. 25. In response to a character string representing any constituent element of a program to be input, which is input at any position on the display screen, the character string is stored in advance in correspondence with the character string. , A graphic representing the constituent element is displayed at that position, and the above display step is repeated in response to a plurality of character strings respectively representing other constituent elements, thereby displaying a plurality of graphic figures. A program input support method, wherein a position for displaying a graphic representing a subsequent component required by the preceding input component is determined depending on a position of the graphic representing the preceding input component. 26. In response to a character string that is input at any position on the display screen and that represents any of the constituent elements of the program to be input, it is stored in advance in correspondence with the character string. , A graphic representing that component is displayed at that position, and when a character string representing that other name is entered as another component to be entered in relation to the above-mentioned component, When a program statement is input as another component described above, the syntax of the program statement is analyzed, and a group of figures reflecting the syntax is displayed as described above. A program input support method for displaying a figure at a position having a predetermined positional relationship. 27. In response to a character string, which is input at any position on the display screen and represents one of the constituent elements of the program to be input, the character string is stored in advance in correspondence with the character string. , A graphic representing the constituent element is displayed at that position, and the above display steps are repeated in response to a plurality of character strings respectively representing other constituent elements, thereby displaying a plurality of graphic shapes and displaying the plurality of graphic shapes. Editing in response to the edit mode instructed with respect to at least one of the above, so that the one graphic becomes a graphic representing a new component, the graphic is edited according to the edit mode specified by the edit instruction. How to help. 28. When the graphic cursor is positioned at a position where a new component can be inserted on the program displayed in the form of a graphic after the insertion command is issued, the corresponding part of the graphic representing the program is identified and displayed. Item 27. A program editing support method according to Item 27. 29. After issuing the insert command, when the graphic cursor is positioned at a position where a new component cannot be inserted on the program displayed in the form of a graphic, and a specific key or button for instructing execution of insertion is pressed. The program editing support method according to claim 27, wherein warning information such as a warning sound, a warning message, and the like is presented. 30. After issuing the insert command, when the graphic cursor is positioned at a position where a new component can be inserted on the program displayed in the form of a graphic, and a specific key or button for instructing execution of insertion is pressed. 28. The program editing support method according to claim 27, wherein the character string input area expressed in a form corresponding to the category of the component determined by the insertion position is inserted at that position. 31. When a constituent element of a program displayed as a graphic part includes a name or a keyword designating the constituent element as a part thereof, a character string representing the name or the keyword is replaced by a character designating another constituent element. 28. The program according to claim 27, wherein by changing to a column and issuing a command instructing to change the constituent element, the constituent element is changed to a graphic corresponding to the constituent element designated by the name or keyword represented by the changed character string. Editing support method. 32. By issuing a command instructing conversion to a character format, a predesignated portion of a program displayed in a graphic format is converted into a corresponding character format program, and the original graphic format program is replaced and displayed. Item 27. A program editing support method according to Item 27. 33. The program input support method according to claim 27, further comprising the step of converting the plurality of displayed graphics after the editing into a program in which the constituent elements represented by them are connected.