JPH0997234A - Automatic executing device for command when using editor at general-purpose machine - Google Patents

Abstract

PROBLEM TO BE SOLVED: To eliminate the work at the time of re-inputting by storing the input contents of a command while starting an editor at a general-purpose machine. SOLUTION: When a program is executed, the command inputted from an input device 1 on an editor editing picture by a data operation S2 is stored in a buffer inside a storage device 3 and when a new command is inputted from the input device 1 by a data input/interaction operation S3, it is stored in the storage device 3. When it is desired to execute the command again, a key designated by data processing S4 is depressed from the input device 1, a data processor 2 calls processing start, and the contents of command in the storage device 3 are outputted onto an output device 4.

Description

Detailed Description of the Invention

[0001]

BACKGROUND OF THE INVENTION 1. Field of the Invention The present invention relates to an automatic execution device, and more particularly to pressing a specified key while an editor is running on a general-purpose machine to output the content of a command that has already been executed on the screen, and to use the keyboard. The present invention relates to an automatic execution device that simplifies re-entry.

[0002]

2. Description of the Related Art In a conventional general-purpose machine, while an editor is running,
If you want to re-execute a command you have already executed, you will have to re-type it from the beginning with the keyboard. The editor environment of a conventional general-purpose machine will be briefly described below.

Here, a general-purpose machine means that a large number of batch jobs or TSS processes run under the control input of a job control language (JCL), for example.
A so-called large or medium computer system.
When creating and modifying a program source file in order to create or debug a program on such a general-purpose machine, the user usually starts a predetermined editor from the terminal connected to the general-purpose machine and After making and modifying the above, save it, compile and link the source file to create an execution module, and submit the job to the scheduler for execution.

[0004]

As described above, in the conventional editor of a general-purpose machine, when the user wants to re-execute a command that has already been executed, the user (operator) must re-enter the command from the beginning with the keyboard. Therefore, if the content of the command is long and complicated, there is a problem that the input work from the keyboard is very troublesome.

Further, in order to input the same command as the previous command when re-entering the command, the user must record the command on a predetermined sheet or the like in order not to forget the command. In addition to the above-mentioned problems, an input error or the like is likely to occur when the command is re-entered, and therefore improvement in work efficiency cannot be expected.

The present invention has been made in view of the above problems, and stores an input command in a buffer by using an execution file described in the job control language (JCL) so that the user can specify the command. It is an object of the present invention to provide an automatic execution device capable of setting the contents of the buffer to be output to the screen when the key of is pressed and making it possible to omit the input work.

[0007]

In order to achieve the above-mentioned object, the present invention stores a command input from the input means while the editor is running in the computer system in a predetermined storage area and stores it in advance. There is provided an automatic execution device configured to output the content of a command that has been input to the screen when a predetermined key is pressed, and to eliminate the need to re-input a command from the input means.

According to the present invention, even if the contents of the command input from the keyboard are long and complicated, the contents of the command already executed can be promptly displayed by storing the input command in the buffer and pressing one predetermined key. With the function to output to, by pressing the specified key when re-entering a command, the contents of the entered command are output to the screen, so even if the command statement is long and complicated It is not necessary to re-enter the contents of the command from.

[0009]

BEST MODE FOR CARRYING OUT THE INVENTION Embodiments of the present invention will be described below with reference to the drawings.

FIG. 1 is a block diagram for explaining the configuration and operation of one embodiment of the present invention.

Referring to FIG. 1, in the present embodiment, an input device 1 such as a keyboard, a data processing device 2 which operates under program control, a storage device 3 for storing information, and an output device 4 such as a display device. It consists of and.
The data operations S2 to S2 shown inside the data processing device 2
The data processing S4 and the like show the flow of processing in the data processing device 2 including the control relationship with the input device 1, the storage device 3, and the output device 4.

Next, the operation of this embodiment will be described with reference to FIG.

In the data operation S1, a predetermined buffer is secured in the storage device 3, and in the data operation S2, the command input from the input device 1 while the editor is running is stored in the storage device 3.

After that, when it is desired to re-execute the same command as this, a key designated in advance in the data processing S4 (for example, Ctrl + PF11; control (Ctr)
l) Pressing the function key 11 while pressing the key) is pressed from the input device 1 (keyboard),
The data processing device 2 prompts the process to be activated, and the content of the command in the storage device 3 is output to the output device 4.

When a new command is input from the input device 1 in the data input / interactive operation S3, it is stored in the storage device 3.

FIG. 2 is a flow chart showing the flow of macro processing in the job control language (JCL), which is automatically executed in the form of an execution file.

Details of the processing will be described with reference to FIG.
FIG. 2 shows the flow of macro processing in the job control language (JCL), and the macro processing is called and executed in the execution file format while the editor is running.

First, a buffer for the started execution file is secured in the storage device 3 (step 11), and the input device 1
When a command is input from, the command is stored in the buffer (step 12).

Then, it is judged whether or not a new command has been input (step 13), and when a new command has been input, the process returns to step 12 (the contents of the buffer are updated with the latest input command) and input. If not, it is determined whether or not the "Ctrl + PF11" key is pressed from the keyboard of the input device 1 (step 14).

If the "Ctrl + PF11" key is pressed, the contents of the buffer are output to the output device (step 15), and if not pressed, the process returns to step 13.

The above sequence is repeated until the process of step 15 is completed.

An example of operation when one embodiment of the present invention is actually applied will be described with reference to FIG. FIG. 3 is a diagram showing a state of a display device for showing an operation example of an editor when the automatic execution device according to the embodiment of the present invention is applied to a general-purpose machine.

It is assumed that an editor is started, a certain source file (here, a COBOL program) is displayed on an output device (display device), and correction / update work is performed.

For example, a search display command (GL command) is used to search and display a line containing "@ HIZB0100" in a source file, and a line "YOTEB" containing "@ HIZB0100" found in a certain line is searched.
"A" (not shown) is converted into "YOTEI" by a predetermined replacement command (S command), and the modified file (file name HLP0410) is saved by a write command (W command), and then compiled and linked, and then an editor. Command to submit the job stream in the buffer to the system scheduler as a job (RJ command)
To execute.

FIG. 3A shows a part of the display screen in a state where the above RJ command is input in the command input field (SCMD ==>) of the editor.

The "BACK" following the RJ command
The "2" command is a command for instructing display output two pages backward from the page where the output process is interrupted, and ";" is a delimiter for designating a plurality of commands on one line of the command line.

Here, after the job is submitted by the RJ command, as shown in FIG. 3B, the execution state of the job is displayed on the screen which is output two pages backward from the page where the output process is interrupted.

Referring to FIG. 3B, the job (job name is “HLP0410”) is completed (result column is “DON”).
E ”), a predetermined key (for example, CTRL + PF
When 5) is pressed, the screen display of the original editor is restored as shown in FIG.

Then, in the present embodiment, FIG.
When the “Ctrl + PF11” key is pressed in this state, as shown in FIG. 3D, the previously input command “RJ; * BAC” is displayed in the command input field of the editor.
“K 2” is displayed again.

The user displays the "RJ; * BA" displayed again.
The "CK 2" command can be re-executed as it is, or can be executed after the command is modified.

The present embodiment can be similarly applied to not only a line editor but also a screen editor having a command buffer and a command input mode. As described above, according to the present embodiment, the function of outputting the content of the input command to the screen when the designated key is pressed is described by the macro processing in the job control language (JCL). By calling this in the execution file format while the editor is running, labor can be saved in the input process when a command is re-entered while the editor is running. In particular, according to the present embodiment, the redisplay of the command input is controlled by the macro processing in the job control language, and it is not necessary to specially modify the editor program itself, and it can be applied to various editors. It is said that

[0032]

As described above, according to the present invention,
With the job control language, it is possible to describe a function that outputs the contents of the entered command to the screen when the specified key is pressed, and call this in the executable file format while the editor is running. When a command is re-entered in the middle, it has an effect that labor saving of the input process can be achieved, and its practical value is extremely high.

[Brief description of drawings]

FIG. 1 is a block diagram showing a basic configuration of an embodiment of the present invention.

FIG. 2 is a flowchart showing a flow of processing according to an embodiment of the present invention.

FIG. 3 is a diagram showing an editor screen when one embodiment of the present invention is actually applied.

[Explanation of symbols]

 1 Input Device 2 Data Processing Device 3 Storage Device 4 Output Device S1 Data Operation S2 Data Operation S3 Data Input / Interactive Operation S4 Data Processing

Claims (3)

[Claims] 1. A computer system stores a command input from an input means in a predetermined storage area while an editor is being activated, and stores a command when a predetermined predetermined key is pressed. An automatic execution device configured to output the contents of a command on a screen and eliminate the need to re-input the command from the input means. 2. A job control language (JCL) defines a processing function of storing the contents of an input command in a buffer and outputting the input command to a screen when a designated key is pressed, and executes the JCL. 2. The automatic execution device according to claim 1, wherein the automatic execution device is in a file format and is automatically executed while the editor is running. 3. The automatic execution apparatus according to claim 1, wherein at least the last input command is displayed again on the screen by the predetermined key input.