JPS61285525A - Command input method - Google Patents

Abstract

PURPOSE:To attain the reuse of a command by storing a command supplied by a key operation into a processing memory. CONSTITUTION:A command supplied through a keyboard 3 is stored in a memory 2 and also written to a screen buffer 4 and written on a CRT 5. The command written to the buffer 4 and displayed on the CRT 5 is erased out of the screen as soon as it is executed. If it is desired the previous screen is recovered after execution of the command and this command is edited on the screen for reuse, the contents written into the memory 2 are read out and written to the buffer 4 to be displayed again on the CRT 5. These displayed contents are edited for execution of a command. The screen is saved by key operations.

Description

DETAILED DESCRIPTION OF THE INVENTION [Field of Application of the Invention] The present invention relates to a command input method for a computer, etc., and a command input method suitable for repeatedly inputting extremely complex commands.

[Background of the invention]

In the conventional command input method, once a command is input,
If it remains on the screen and is displayed, moving the cursor to that position and editing it on one screen, then pressing the ENTER key will execute the command line.

However, sometimes the screen gets overwritten or disappears when a certain command is executed.

The problem was that it was not always possible to re-execute a command.

You can also save several lines of the most recently input command lines in a command buffer, call these command lines one by one, edit them, and re-execute them. However, in this case, the degree of freedom in editing is low because the relationship between the commands before and after 1 is unknown
One problem was that it was not suitable for interactive operation.

[Purpose of the invention]

SUMMARY OF THE INVENTION An object of the present invention is to provide a command input method that allows commands to be edited and re-executed by operating on a single screen, and also enables reuse of commands that have been deleted by execution of the command.

[Summary of the invention]

In the present invention, in order to reproduce previously input commands, it is possible to store them somewhere other than the screen, but since it is difficult to use if the commands are stored in chronological order as in the conventional example, I decided to recreate the memory.

[Embodiments of the invention]

FIG. 1 is a diagram showing an overview of the computer system.

This computer system includes a CPUI, memory 2. Keyboard 8, screen buffer 4. Consists of CRT5.

Memory 2 stores various programs, and the CPU
1 reads this program from memory 2.

Perform processing. This memory 2 is the main memory.

It can also be called CPUI processing memory. The keyboard 8 has various keys and serves as an input device. It also provides command manpower.

The screen buffer 4 stores a screen to be displayed on a CRTK. The CRT 5 displays the screen stored in the one-screen buffer 4.

Commands input from the keyboard 8 are stored in the memory 2, simultaneously written to the one-screen buffer 4, and displayed on the CRT 5. The method of inputting this command will be explained in detail.

FIG. 2 shows how commands are created on a CRT screen.

A command is created for each line.

Use the keyboard to create this command. A line is indicated with a cursor, and characters and symbols constituting a command are indicated one after another on the keyboard 8 within that line. The designated characters and symbols are stored in the screen buffer 4 and then displayed on the CRT 5.

The characters and symbols in the command are corrected by instructions using the cursor 6. This modification result is stored as is in the screen buffer 4. After the command input is completed, the contents of the one-screen buffer 4 are sent to the memory 2 and used as processing commands by the CPU IK. At this time, the memory 2 is provided with a dedicated area for commands.

FIG. 3 shows a more specific flowchart of command input.

In FIG. 8, in step 20, one character is input by operating the keyboard 3. If cursor key operation is required, the cursor key operation is performed in step 30, and the cursor is moved (step 40).

In addition, backspace (Stella 7'50.60), insert key (step 70% 80), plate key (
Steps 90, 100), Clear Gear (Step 110)
．． 120), the process is executed. The processing from steps 50 to 120 is a so-called editing process.

If it is a normal character key operation (step 150).

At step 160, the characters manually input by the keys are displayed on the CRT 5, and the process returns to step 20 for manually inputting the keys.

In step 170, it is determined whether the input character is the command final key, and in step 190, a display indicating that the input character is the end of the command line is displayed. Then step 200
Save the contents of screen buffer 4 with , and then proceed to step 21.
When set to 0, the command of the first line is sent and stored in the memory 2.

The storage area in the memory 2 is a capture area by keyboard input, and is determined in advance.

In step 220, the CPUI reads the command on the area in the memory 2 and executes the command.

The functions of steps 180 and 140 are as follows.

When the execution of the command is completed, the process returns to step 20 and waits for the next command input. At this time, when the redisplay key is pressed in step 180, the contents of the screen buffer 4 when the previous command was input are read out in step 140, and the CRTS
display on top. At this time, since the contents of the screen buffer 4 are not stored in the screen buffer 4 but in the memory a, they are read out from the memory 8 and displayed.

According to this operation, the screen when the previous command was input is redisplayed, allowing reuse. Also,
It can also be used for processing such as checking the immediately previous command and making some corrections. When reusing it, you may enter it as a new command.

You may modify some of the commands and input them as new commands.

This has the advantage of shortening the time from command input to execution. Furthermore, it has the advantage that commands can be easily re-executed.

Similarly, if the final command key is not pressed in step 170, a buzzer will sound in step 180 to warn you that you have forgotten to press it.

In this implementation, when you enter a command, the previous screen is automatically saved, but in some cases it may not be useful, so we have provided a save one screen key and press this key. When this happens, you can save the screen only with K and take the other option. In this case, it is possible to forget to press the screen save key, so it is desirable to be able to switch from the previous embodiment.

〔Effect of the invention〕

According to the invention, the previously entered command line.

Even if it disappears from the screen due to execution of a command, you can restore the previous screen and edit the command line on the screen so that it can be used continuously without having to enter the same command each time. This has the effect of allowing command input. Another advantage is that commands can be easily re-executed.

[Brief explanation of drawings]

Figure 1 is a computer system diagram, Figure 2 is CR7 in the present invention.
The side view of command setting on the screen, FIG. 8, is a flowchart from command setting to processing in the present invention. 1...CPU, 2...Memory, 3...Keyboard, 4...Screen buffer, 5...CRT, 6...Kernol. 1st mouth $2 figure

Claims (1)

[Claims] A command input method in which commands by key operations on a keyboard are displayed on a CRT via a screen buffer, and the commands in the screen buffer are stored in a processing memory.