JPH03240154A - Command input system - Google Patents

Abstract

PURPOSE:To reduce the input processing frequency for an interactive program by providing an input data editing part which edits an interactive command and the data inputted interactively from outside and a store part which stores the editing result. CONSTITUTION:The input data editing parts 51-53 edit the data inputted interactively from outside to an interactive command into the reusable data to store these data in a store part 7. Meanwhile a batch type command is stored in the part 7 as it is, and an interactive command is converted into a batch type command and stored in the part 7. Thus not only the commands but the input data contained in these commands can be reused in regard of the contents stored in the part 7. As a result, the contents stored in the part 7 can be used as they are for execution of the same operations.

Description

DETAILED DESCRIPTION OF THE INVENTION [Field of Industrial Application] The present invention relates to a user interface for an interactive program, and particularly to a command input method for reusing input commands.

[Prior Art] In recent years, improving the user interface of interactive programs has become important from the viewpoint of usability.

For this reason, input methods that allow input data to be reused are being considered for the purpose of reducing the number of times the key is pressed manually. Among them, the most famous one is the UNIX C shell.

In order to reuse input data, the C shell has a function for executing commands in a file, called a shell script, and a function for reusing key manual data, called a history.

Shell scripts are created by creating frequently used command sequences in advance using an editor etc. and turning them into file data.
By adding parameters and executing as necessary,
The key is to reduce the number of human labor required. Although it has some programming functions, it is basically used to simplify input for routine work.

The history is used when you want to re-enter a command that you entered interactively, either as is or with some changes. Command input can be quite long if parameters are included, so this is effective in preventing input errors.

[Problem to be solved by the invention] The above conventional technology has the following problems.

First of all, regarding shell scripts, it is necessary to prepare the shell script file in advance, so it is not very suitable for interactive use.For example, depending on the output result of the command to be executed, When the command to be executed is determined, the next command is written by guessing the execution result of the command when preparing the shell script file, so if the guess is wrong, That shell script becomes meaningless. For these reasons, it is difficult to create shell script files for interactive processing in advance.

Next, regarding the history, it is suitable for interactive use as opposed to a shell script, but basically it only remembers the input commands from login to logout, so it is a series of It has not been considered to store the procedure in a file and reuse it.1 For example, if input processing occurs within the command by executing a command, this input data will be processed within the command, so the history Therefore, even if the history is stored in a file, in order to reuse it, various changes must be made, such as creating input data.

As described above, in order to input commands interactively and reuse them, it is necessary to make changes by one person, which poses a problem that it is not very suitable for automation.

An object of the present invention is to provide a command input method that allows interactively input commands to be converted into a file and reused without being changed.

[! l! Means for Solving the Problem] In order to achieve the above object, the present invention provides an input interface section for inputting commands and data from the outside, a command analysis section for analyzing the input commands, and an input interface section for executing the analyzed commands. When the command to be executed is an interactive command, the command execution unit transmits data required in the command from the outside via the input interface unit. In an information processing system where the command is input interactively, when the command executed by the command execution unit is an interactive command, the command execution unit executes an interactive command that is input interactively from the outside via the input interface unit. The input data editing section is provided with an input data editing section for editing the input data, and a storage section for storing the editing results of the input data editing section.

Preferably, when the command executed by the command execution section is an interactive command, the input data editing section changes it into a batch-type command and stores it in the storage section.

Further, the input interface section can input the contents stored in the storage section according to an instruction from the outside.

[Operation] The input data Jg collection section edits data input interactively from the outside in response to an interactive command into a reusable form and stores it in the storage section. Also, change the interactive command to a batch command and store it in the storage unit. Also, batch type commands are stored as they are in the storage unit.

The contents stored in the storage section in this way are in a format that allows not only the command but also the input data within the command to be reused, so if you want to do the same thing, the contents stored in the storage section can be used as is.

[Example] An embodiment of the present invention will be described below with reference to the drawings.

FIG. 1 is a block diagram showing the configuration of a debugger system that employs a command input method according to an embodiment of the present invention.

In FIG. 1, 1 is the entire debugger system, 2 is an input/output interface section, 3 is a command analysis section, 41 is a memory edit/command execution section (screen edit), and 42 is a memory edit/command execution section ( 43 is another command execution section, 51 is an input data editing section of the memory edit/command execution section 41, 52 is an input data editing section of the memory edit/command execution section 42, 53 is another command execution section 43 is an input data editing section; 6 is a learning file access processing section; 7 is a learning file access processing section;
is the learning file.

The overall general operation of the debugger system 1 of this embodiment will be described below.

The operator sends the command CMD and parameters PARM to the command analysis unit 3 via the human output interface unit 2.
When the command CMD is input, the command analysis unit 3 analyzes the input command CMD. As a result of the analysis, it is determined which command execution unit 41 to 43 should execute the command, and control is transferred to the corresponding command execution unit 41 to 43.

The command execution units 41 to 43 to which control has been transferred simultaneously receive the parameter PARM, and execute the command CMD based on the received parameter PARM.The input data accompanying the execution of the command CMD is input as necessary. , the input data editing unit 51 corresponding to the corresponding command CMD.
Passed to ~53.

The input data editing units 51 to 53 input the received data,
It is edited into a reusable command format and parameter format, and stored in the learning file 7 via the learning file access processing section 6.

Next, the above-mentioned operation will be explained in detail, taking as an example the case where a memory edit command is input.

The command CMD input by the operator is analyzed by the command analysis section 3;

When it is determined that the command CMD is a memory edit (screen), control is transferred to the command execution section 41, and in particular, the parameter FARM is passed thereto.

The memory edit command execution unit 41 executes the command CMD based on the parameter PARM passed from the command analysis unit 3, but in reality, the memory edit
Since the command execution unit 41 performs editing processing in the screen edit format, the memory data is stored in the parameter PAR.
It is not passed as M, but as changed data PARMI obtained interactively using the cursor key and data key.

That is, the operator inputs the command CMD without inputting the parameter PARM at the time of inputting the command CMD, and after the control is transferred from the command analysis section 3 to the memory edit/command execution section 41, the operator edits it using the cursor keys. Move the cursor to the target memory and change the memory data using the data keys. Therefore, the changed data P
ARM1 is a command input type process, and in the conventional history, this changed data PARMI is not subject to history.

In this embodiment, the memory edit command execution unit 41
As a result of the change, the input data editorial department 5
Pass the change data PARMI to 1.

Input data editing 7v151 changes the passed change data PA
In order to take advantage of RMI, for example, the command CMD is edited into a command CMDI in line editing format, and then passed to the learning file access processing unit 6.

The edited command CMD1 is in a format that is input to the memory edit command execution section 42, and when it is input to the command analysis section 3, control is passed to the memory edit command execution section 42 as a result of analysis. It is a form.

The learning file access processing unit 6 receives the passed command C.
Store the MDI in the learning file 7.

By performing the above operations for each command input by the operator, the data input by the operator is stored in the learning file 7 in a reusable format.

Therefore, by using the data in the learning file 7 instead of the input from the operator, it is possible to realize input equivalent to the input from the operator.

This process is realized by the input interface unit 2 based on the operator's instructions.

Although the description of the other command execution section 41 and input data editing section 53 has been omitted, they collectively represent a plurality of command execution processes other than memory editing. These function similarly to the memory edit/command execution sections 41 and 42 and the input data editing sections 51 and 52, respectively. That is, it has two types of command execution units: an interactive input format and a batch input format.

In this embodiment, separate command execution units are provided for the screen edit and line edit, but the same command execution unit may be used for processing.

Furthermore, the present invention can be similarly applied to the classification of interactive type and batch type, instead of the screen editing and line editing.

As described above, according to this embodiment, not only the input command but also the data input within the command can be reused.

[Effects of the Invention] As explained above, according to the present invention, not only the input commands but also the data input within the commands can be reused, so that input in interactive programs such as debuggers can be reused. This has the effect of reducing processing.

[Brief explanation of drawings]

FIG. 1 is a block diagram showing the configuration of a debugger system that employs a command input method according to an embodiment of the present invention. DESCRIPTION OF SYMBOLS 1... Debugger system, 2... Input interface section, 3... Command analysis section, 41... Memory edit/command execution section (screen edit), 4
2...Memory edit/command execution unit (line editor), 43...Other command execution units, 51.5
2.53... Input data editing section, 6... Learning file access processing section, 7... Learning file. Figure 1

Claims (1)

[Claims] 1. An input interface unit that inputs commands and data from the outside, a command analysis unit that analyzes the input commands, and a command execution unit that executes the analyzed commands; When the command to be executed is an interactive command, the unit executes the command in an information processing system in which data required in the command is input interactively from the outside via the input interface unit. an input data editing section that edits the interactive command and data input interactively from the outside via the input interface section when the command executed by the section is an interactive command; A command input method comprising: a storage section for storing editing results of the input data editing section. 2. The input data editing unit according to claim 1, wherein when the command executed by the command execution unit is an interactive command, the input data editing unit changes the interactive command to a batch command. Command input method. 3. The command input method according to claim 1 or 2, wherein the input interface section inputs the contents stored in the storage section according to an instruction from the outside. 4. If the command to be executed is an interactive command, change the interactive command to a batch command, and edit data input interactively from the outside for the above interactive command. A command input method characterized in that a changed command and edited data are stored, and when a command to be executed is a batch type command, the batch type command is stored.