JPH09146783A - Method and device for controlling program - Google Patents

Abstract

PROBLEM TO BE SOLVED: To control plural tasks by a keyboard buffer. SOLUTION: In a step S11, a task 1 is started, prescribed processing is executed and a task 2 to be started next is determined in accordance with the processing result. In a step S12, a task start command for starting the task 2 is written in the keyboard buffer. When the task 1 ends, command interpreting software is started by an operating system (MS-DOS), the task start command written in the keyboard buffer is interpreted in a step S15 and the corresponding task 2 is started in a step S16.

Description

Detailed Description of the Invention

[0001]

BACKGROUND OF THE INVENTION 1. Field of the Invention The present invention relates to a program control method and apparatus, for example, a program control method and apparatus suitable for use when executing a plurality of tasks one by one.

[0002]

2. Description of the Related Art Conventionally, for example, MS-DOS (Microsoft
An operating system such as Disk Operating system (trademark) in which the size of real memory (hereinafter simply referred to as memory) is limited and virtual memory cannot be used, and the memory that can be used by application programs is approximately 640 kilobytes. In such a case, in order to execute a large-scale application program, first, a software group such as a device driver resident in memory is assigned to another address space such as extended memory or video RAM. Address space or external storage device (eg hard disk)
I try to expand the memory as much as possible.

If the memory is still insufficient, the overlay method is used. That is, the application program is divided into a plurality of segments, and only the necessary segments are sequentially loaded from the external storage device into the memory and executed, and when the application program is completed, the application program is again flushed to the external storage device.
In this way, application programs larger than the available memory can be executed.

Further, when the processing of the task scheduler is supported, it is possible to execute a large-scale application program by dividing the application program into a plurality of tasks and sequentially switching the divided tasks. .

Further, a large-scale application program is divided into a plurality of independent programs which can be executed in a memory space smaller than 640 kilobytes, and each divided program is activated and executed in a predetermined order. be able to. In that case, for example, describe in advance the programs to be executed in a batch file etc.,
Start the batch file. Thereby, the programs described in the batch file can be sequentially executed.

Alternatively, if there is a program name and parameters to be executed from the keyboard, the parameters can be input, and the return key can be input to sequentially execute the programs.

FIG. 5 is a flow chart for explaining a procedure for activating a task by inputting a predetermined command from the keyboard. In step S1 of the figure, if there is a task activation command (hereinafter, simply referred to as a command), that is, a program name and parameters corresponding to the task to be activated, the parameters are input from the keyboard. The program name and parameters input from the keyboard (provided that the parameters have been input) are stored in the keyboard buffer by a predetermined interrupt process in step S2. Therefore, even while the predetermined program is being executed, the command input from the keyboard is stored in the keyboard buffer.

In step S3, command interpretation software (COMMAND.
COM) interprets the command stored in the keyboard buffer, reads the corresponding executable program from the external storage device in step S4, loads it into the memory, and then starts it as a child process.

After the processing of the started program is completed or during execution, if there is a program name to be executed next and its parameters, the parameters are input from the keyboard and the return key is further input. The input program name and parameter (however, when the parameter is input) are stored in the keyboard buffer by a predetermined interrupt process. Hereinafter, the same operation is performed. As a result, similarly to the case described above, the program name and the parameter (provided that the parameter is input) are sequentially stored in the keyboard buffer, sequentially interpreted by the command interpretation software, and the corresponding program is activated.

However, as described above, when the program started as a child process by the command interpreting software is terminated and control is transferred to the command interpreting software again, the command interpreting software interprets the command stored in the keyboard buffer. It Therefore, when a command is input from the keyboard during execution of a predetermined program, control is transferred to the command interpretation software after the currently executing program ends, and the command stored in the keyboard buffer is changed by the command interpretation software. It will be interpreted and the corresponding program will be started.

In this way, it is possible to execute a large-scale application program in the limited memory.

[0012]

However, even if the resident software is booted to the outside, the MS-D
Since the maximum memory usable in the OS is limited to 640 kilobytes, there is a problem that a large-scale application program that requires a larger memory cannot be executed.

Further, when the overlay method is used, data reference is generally limited, extra program code is generated, and the processing speed is reduced. for that reason,
The overlay modules that can be segmented will be restricted. Further, since the management data increases due to the overlay execution, there is a problem that the larger the application program becomes, the more efficiently the memory cannot be used.

Further, when the processing of the task scheduler is supported, a memory of a predetermined size is consumed for task switching, so that in the end,
Only the remaining memory after deducting that amount can be assigned to each task, and there is a problem that the size of the task is limited and the memory cannot be fully utilized.

Further, the application program is divided into a plurality of programs, and a batch file in which the names of the plurality of divided programs are described in a predetermined order is created,
When the programs are started, the programs are started in the order described in the batch file, so that there is a problem that the starting order of the programs cannot be changed based on the execution result of the programs.

Furthermore, when a program name and parameters are input from the keyboard and a series of operations for inputting a return key is repeated to execute a plurality of programs sequentially, the operation is troublesome. Moreover, there was a problem that was complicated and not realistic.

The present invention has been made in view of such a situation, and in an operating system in which a virtual memory cannot be used, a large-scale application program can be executed while making the most effective use of limited memory. It allows you to do it.

[0018]

According to a first aspect of the present invention, there is provided a program control method, wherein an application program is divided into a plurality of tasks of a predetermined size that can be executed in a real memory,
The task started by the command control software is characterized in that after executing a predetermined process, a command corresponding to a predetermined one to be executed next among a plurality of tasks is written in the buffer.

A program control device according to a third aspect is
A storage unit (for example, the hard disk 8 in FIG. 1) that stores the application program divided into a plurality of tasks of a predetermined size that can be executed in the real memory, and a part of the task started by the command control software, After the task executes a predetermined process, a command writing unit that writes a command corresponding to a predetermined one of the plurality of tasks to be executed next to the buffer (for example, FIG. 2).
And step S12).

In the program control method according to the first aspect, the application program is divided into a plurality of tasks of a predetermined size which can be executed in the real memory and stored, and the task is started by the task started by the command control software. During the process of (1), a command corresponding to a predetermined one of the plurality of tasks to be executed next is written in the buffer. Therefore, the task to be executed next can be specified from the currently executing task using the buffer.

According to another aspect of the program control device of the present invention, the storage unit stores the application program divided into a plurality of tasks of a predetermined size that can be executed in the real memory, and the command writing unit writes the command. After the task started by the command control software, to which the means belongs, executes a predetermined process, a command corresponding to a predetermined one of the plurality of tasks to be executed next is written in the buffer. Therefore,
The task currently being executed can specify the next task to be executed by using the buffer.

[0022]

1 is a block diagram showing the configuration of an embodiment of a program control apparatus of the present invention. ROM
2 stores the minimum programs necessary for system startup such as a boot strap loader. The hard disk (HD) 8 is, for example, MS-DO.
An operating system such as S (Microsoft Disk Operating System: trademark), a predetermined application program, and the like are stored. The operating system and application programs stored in the hard disk 8 are loaded into the RAM 3 via the interface (I / F) 7 and the system bus 11.

The keyboard 6 generates key information corresponding to the pressed key and supplies it to the keyboard interface 5 described later. The keyboard interface 5 converts the key information, which is serial data supplied from the keyboard 6, into parallel data, outputs the parallel data, and generates a keyboard interrupt. The keyboard buffer 12 stores the key information output from the keyboard interface 5, as described later.

The CPU 1 controls each unit according to the program stored in the ROM 2, the operating system and the application program loaded in the RAM 3, and executes a predetermined process. Also, CP
The U1 activates a predetermined interrupt processing routine in accordance with a keyboard interrupt generated by the keyboard interface 5, reads key information from the keyboard interface 5 via the system bus 11, and writes the key information in the keyboard buffer 12.

The video RAM (VRAM) 4 stores display data to be displayed on a CRT (Cathode Ray Tube) 10 described later. The CRT controller 9 is a VRAM
The display data stored in 4 is converted into a video signal to be displayed on the CRT 10 and supplied to the CRT 10. CRT
Reference numeral 10 is adapted to display a screen corresponding to the video signal supplied from the CRT controller 9.

Next, with reference to the flow chart shown in FIG. 2, a method for sequentially activating a plurality of tasks via the keyboard buffer 12 will be described.

First, when the power of the apparatus is turned on or reset, an IPL (Initial Program Loder) is loaded from the hard disk 8 to the RAM 3 via the I / F 7 by the boot strap loader stored in the ROM 2. Next, the IO. SYS, hard disk 8 via I / F7
Loaded into RAM3, then IO. By SYS, MSDOS. SYS, and COMMAND. C
OM (command interpretation software) is loaded from the hard disk 8 to the RAM 3 via the I / F 7, and COM
MAND. Control transfers to COM. In this way,
MS-DOS is started. At this time, the address space that can be used by the application program is normally about 64.
It becomes 0 kilobytes.

Next, by command interpretation software,
First, it is determined whether or not there is an automatic execution batch file (AUTOEXEC.BAT) in the external storage device, in this case, the hard disk 8, and when it is determined that there is an automatic execution batch file in the hard disk 8, step S11
In, the command described in the automatic execution batch file is interpreted, the corresponding executable program is read from the hard disk 8 through the I / F 7, and the RAM 3
Is loaded and then launched.

Therefore, by describing the first task start command, for example, the executable program name corresponding to task 1, in the automatic execution batch file, the MS-DO
When S starts, this executable program
D. It can be automatically activated by COM. In this automatic execution batch file, in addition to the executable program name (character string (task activation command) that identifies the program), parameters to be passed to this executable program can be described.
In that case, the process by the executable program is performed according to this parameter. However, the executable program must be programmed with the assumption that it will receive parameters.

On the other hand, when the task 1 is not started by the automatic execution batch file, the user directly uses the keyboard 6 to directly name the executable program corresponding to the task 1 (a character string (task start) for specifying the program). Command)) and parameters (if any) and press the return key. The keyboard 6 generates key information corresponding to the typed executable program name and parameters and supplies the key information to the keyboard interface 5 as serial data.

Serial data corresponding to the key information supplied from the keyboard 6 to the keyboard interface 5 is converted into parallel data by the keyboard interface 5. Also, keyboard interface 5
At, a keyboard interrupt occurs and a predetermined interrupt processing routine started by the CPU 1 reads out key information from the keyboard interface 5 via the system bus 11 and stores it in the keyboard buffer 12.

The key information stored in the keyboard buffer 12 is interpreted by the command interpretation software.
In this case, the command interpretation software causes the key information stored in the keyboard buffer 12 to be an external command,
That is, it is interpreted as the name of a predetermined executable program, and this executable program is read from the hard disk 8 via the I / F 7 and loaded into the RAM 3 via the system bus 11. Next, in step S11, this executable program, that is, task 1 is started.

Predetermined processing is executed by task 1,
In step S12, a process for writing the task activation command of the task to be activated next, in this case, the name and parameter of the executable program to be executed next (if there is a parameter) to the keyboard buffer 12 is executed. It At this time, the task 1 can determine the task to be executed next according to the processing situation. As a result, in step S13, the task activation command (in this case, the name and parameter of the executable program corresponding to task 2 (if there is a parameter)) is written.

Then, in step S14, task 1
Is completed, control is transferred to the command interpretation software in step S15, and the keyboard buffer 12
The task activation command stored in is interpreted. In this case, the task start command is interpreted as the name of the executable program corresponding to the task 2, and the executable program is read from the hard disk 8 via the I / F 7 and loaded into the RAM 3, and then step S16.
Is launched in. That is, task 2 is activated.

In this way, for example, the task 1 that is currently being executed is the task start command of the task to be started next,
For example, by writing the name of the executable program corresponding to the task 2 in the keyboard buffer 12 during the processing of the task 1, the command interpreting software started after the task 1 is finished causes the keyboard buffer 1
The task activation command stored in 2 is interpreted, the executable program corresponding to the task 2 is loaded from the hard disk 8 to the RAM 3, and then activated. Therefore, the task 1 can activate the next task to be activated, which is determined based on the status of the processing executed by the task 1, by writing the name of the executable program corresponding to the task in the keyboard buffer 12. it can.

Similarly, in the processing of task 2, task 2
Of the executable program corresponding to the task is determined by the keyboard buffer 12
You can also write to.

In this way, the keyboard buffer 12
By using, it is possible to activate a plurality of tasks one by one and execute predetermined processing.
Therefore, at the time of execution, a large-scale application program that requires a memory area larger than the memory area (for example, 640 kilobytes) that can be used by the application program in the address space of the RAM 3 can be divided into a plurality of independent tasks. Then,
As described above, this application program can be executed by sequentially switching the tasks. However, each divided task has a memory size required at the time of execution smaller than the memory area (640 kilobytes in this case) usable by the application program in the address space of the RAM 3.

FIG. 3 is a block diagram showing the configuration of an embodiment of an insurance card confirmation system to which the program control device of the present invention is applied.

When the patient ID card 31A is inserted, the card reading unit 31 reads the patient information such as the patient number and the insurance policy number for identifying the patient recorded therein, and supplies it to the processing unit 32. It is designed to do.

The insurance card reading section 33 is composed of a scanner or the like, reads the insurance card inserted therein while scanning it, performs binarization processing, and converts it into digital image data, and then the processing section 32. It is designed to be supplied to. Alternatively, it is constituted by a CCD camera or the like, and an image of an insurance card is picked up, binarized, converted into digital data, and then supplied to the processing unit 32. Further, the insurance card reading unit 33 can read the health insurance card 33A and the geriatric medical insurance card 33B as insurance cards.

Further, the processing unit 32 has basically the same configuration as the case of the program control device described above with reference to FIG. 1, and operates by a predetermined application program to control each unit. Has been done. Therefore, although detailed description of the configuration and operation thereof is omitted, here, based on the patient information supplied from the card reading unit 31, it is determined whether or not the patient is covered by the geriatric medical insurance, and the insurance. From the digital image data supplied from the certificate reading unit 33, the items described on the insurance card are recognized.

Further, the processing unit 32 determines whether or not the medical insurance for the elderly is applicable based on the patient information supplied from the card reading unit 31, and determines that the patient is the medical insurance for the elderly. If the health insurance card 33A inserted in the insurance card reading unit 33 is recognized and the predetermined confirmation processing is performed, and if it is valid (health insurance can be applied), After recognizing the medical insurance card for the elderly 33B and performing predetermined confirmation processing, the reception slip 34A
Is issued to the issuing unit 34. On the other hand, when it is determined that the patient is not covered by the old-age medical insurance, the insurance card reading unit 3
Only the health insurance card 33A inserted in No. 3 is recognized, a predetermined confirmation process is performed, and then the issuing unit 34 is instructed to issue the acceptance slip 34A.

The issuing unit 34 is adapted to issue a predetermined acceptance slip 34A in accordance with an instruction from the processing unit 32.

FIG. 4 is a flow chart for explaining the operation of the insurance card confirmation system shown in FIG. As shown in the figure, the application program for operating the insurance card confirmation system is composed of four tasks A to D. First, task A is started. That is, after starting the system (after starting MS-DOS), the task A is started by directly inputting the name of the executable program corresponding to the task A from the keyboard 6, or the automatic execution batch is performed in advance. File (A
UTOEXEC. The name of the executable program corresponding to the task A is described in BAT) so that the task A is automatically started by the command interpretation software when the system is started up.

When the patient ID card 31A in which the patient information such as the patient's unique ID number and insurance policy number is recorded is inserted into the card reading section 31 while the task A is activated, the task A causes the step S21 to be performed. And the process of step S22 is performed.

First, in step S21, patient information is read from the patient ID card 31A inserted in the card reading section 31. Next, patient ID card 3
The patient information read from 1A is supplied to the processing unit 32.

In step S22, the processing unit 32 determines, based on the patient information supplied from the card reading unit 31, whether or not the patient is covered by the medical insurance for the elderly. When it is determined in step S22 that the patient is not a patient to whom the medical insurance for the aged is applied, the task A then activates the task B by using the name of the executable program corresponding to the task B in the keyboard buffer 12 and the medical care for the aged. A predetermined parameter indicating that the patient is not covered by insurance is written. After that, the task A ends.

When the task A is completed, the control is transferred to the command interpreting software, the name and parameter of the executable program written in the keyboard buffer 12 are interpreted, and the executable program corresponding to the task B is executed by the I / F 7. Is read from the hard disk 8 via
It is started after being loaded into AM3.

As a result, the process proceeds to step S23, and the verification process of the health insurance card 33A as the process of task B is performed. In this case, since the parameter indicating that the patient is not covered by the geriatric medical insurance is handed over from task A,
Based on this, task B provides a medical insurance card for the elderly 33
The processing is performed on the assumption that the task C for performing the collation processing for B is not activated.

That is, first, the health insurance card reading unit 33 reads the health insurance card 33A, performs binarization processing and the like with a predetermined threshold value, and then converts it into digital image data for processing. Is supplied to the section 32. In the processing unit 32, the insurer number, the insured person number, the insured person number, and the like are recognized from the image data supplied from the insurance card reading unit 33.

Further, the processing unit 32 causes the health insurance card 3
The contents of 3A and the contents of the patient ID card 31A are collated. In this case, since it is not a patient to whom the elderly medical insurance is applied, based on the collation result, next issuance of a predetermined reception slip 34A is instructed. For example, if the result of the collation shows that health insurance can be applied, a predetermined instruction to issue a reception slip 34A in which the name of the executable program corresponding to the task D, the reception number, and the consultation desk number are described is issued. The parameters are written to the keyboard buffer 12.

On the other hand, as a result of the collation, if the health insurance cannot be applied due to, for example, the expiration date having passed, the name of the executable program corresponding to the task D, the reception number, and the predetermined message "come to the reception window". A predetermined parameter for instructing to issue the acceptance slip 34A in which "Please" is written in the keyboard buffer 12. Then, the task B ends.

Upon completion of task B, control is transferred to the command interpreting software, and keyboard buffer 1
Interpretation of the command written in 2 is done, in this case
The executable program corresponding to the task D is read from the hard disk 8 via the I / F 7, loaded into the RAM 3, and then activated.

Since the parameters written in the keyboard buffer 12 are passed to task D, task D
As a result, in step S27, the process of issuing the acceptance slip 34A based on this parameter is executed. That is, when the parameter instructing to issue the reception slip 34A in which the reception number and the consultation counter number are written is passed to the task D via the keyboard buffer 12, the processing unit 32 controlled by the task D Instructs the issuing unit 34 to issue a reception slip 34A in which the reception number and the consultation window number are described. Issuer 3
In accordance with an instruction from the processing unit 32, 4 prints the reception number and the consultation window number on a predetermined sheet and issues it as a reception slip 34A.

On the other hand, for task D, keyboard buffer 1
When the parameter for instructing to issue the reception slip 34A in which the reception number and the predetermined message “Please come to the reception counter” are given via 2, the processing unit 32 controlled by the task D The issuing unit 34 is instructed to issue the reception slip 34A in which the reception number and a predetermined message "Please come to the reception counter" are described. The issuing unit 34 follows the instruction from the processing unit 32.
The reception number and the message "Please come to the reception counter" are printed on a predetermined sheet and issued as a reception slip 34A. Thereby, the patient can perform a predetermined procedure with the person in charge of reception at the reception counter.

On the other hand, if it is determined in step S22 that the patient is covered by the geriatric medical insurance, the health insurance card 33A is first verified. That is, task A
Next, in order to activate the task B, the keyboard buffer 12 is written with the name of the executable program corresponding to the task B and the parameter indicating that the patient is a patient to whom the medical insurance for the elderly is applied. After that, the task A ends.

When the task A is completed, the control is transferred to the command interpreting software, the name of the executable program written in the keyboard buffer 12 and the parameters are interpreted, and the executable program corresponding to the task B is executed by the I / F 7. Is read from the hard disk 8 via
It is started after being loaded into AM3.

As a result, the process proceeds to step S24, and the verification process of the health insurance card 33A as the process of task B is performed. That is, first, the health insurance card reading unit 33 reads the health insurance card 33A, performs binarization processing and the like with a predetermined threshold value, and then converts the digital image data into the processing unit 32. Supplied. In the processing unit 32, from the image data supplied from the insurance card reading unit 33, the insurer number, the insured person symbol,
And the insured person number is recognized.

Further, the processing unit 32 causes the health insurance card 3
The contents of 3A and the contents of the patient ID card 31A are collated. In step S25, it is determined whether or not the health insurance card 33A is valid based on the comparison result, and the task to be activated next is determined. For example, when the health insurance certificate 33A is determined to be valid and the health insurance can be applied, the name of the executable program corresponding to the task C is written in the keyboard buffer 12.

On the other hand, for example, when it is determined that the health insurance card 33A is not valid because the expiration date has passed and the health insurance cannot be applied, the name of the executable program corresponding to the task D and the reception number And a reception slip 3 with the specified message "Please come to the reception desk"
A predetermined parameter instructing to issue 4A is written in the keyboard buffer 12. Then task B
Ends.

The task B causes the keyboard buffer 12
In the case where the name of the executable program corresponding to the task C is written in, when the task B ends, the control shifts to the command interpretation software, and the keyboard buffer 12
The name of the executable program written in
Be executed. That is, the executable program corresponding to the task C is read from the hard disk 8 via the I / F 7, loaded into the RAM 3, and then started.

As a result, the process proceeds to step S26, and the collation process of the medical insurance card for the elderly 33B is performed. That is, first, in the insurance card reading unit 33,
3B is read, binarization processing or the like is performed with a predetermined threshold value, and then converted into digital image data. Next, from this image data, the processing unit 32
The municipality number and the recipient number are recognized by.

Further, in the processing unit 32, the contents of the medical insurance card for the elderly 33B and the contents of the patient ID card 31A are collated, and based on the collation result, issuance of a predetermined acceptance slip 34A is instructed. For example, as a result of the collation, if it is possible to apply the medical insurance for the elderly, it is instructed to issue the reception slip 34A in which the name of the executable program corresponding to the task D, the reception number, and the consultation desk number are described. Predetermined parameters are written in the keyboard buffer 12.

On the other hand, as a result of the collation, if the medical insurance for the elderly cannot be applied because the expiration date has passed, task D
A predetermined parameter for instructing to issue the reception slip 34A in which the name of the executable program corresponding to the above, the reception number, and the predetermined message "Please come to the reception counter" are written in the keyboard buffer 12. After that, the task C ends.

When the task C is completed, the control is transferred to the command interpreting software, and the keyboard buffer 1
Interpretation of the command written in 2 is done, in this case
The executable program corresponding to the task D is read from the hard disk 8 via the I / F 7, loaded into the RAM 3, and then activated. Since the processing content of the task D is the same as that described above, the details thereof will be omitted here.

On the other hand, in step S25, it is determined that the health insurance card 33A is not valid, and according to task B,
Predetermined parameters for instructing to issue the reception slip 34A in which the name of the executable program corresponding to the task D, the reception number, and the predetermined message "Please come to the reception counter" are written in the keyboard buffer 12. In this case, when the task B ends, the control shifts to the command interpretation software, the name of the executable program written in the keyboard buffer 12 is interpreted, and the command is executed. That is, the executable program corresponding to the task D is read from the hard disk 8 via the I / F 7, loaded into the RAM 3, and then started. Since the processing content of the task D is the same as that described above, detailed description thereof will be omitted here.

After executing the issuing process of the acceptance slip 34A, the task D writes the task start command, that is, the name of the executable program corresponding to the task A in this case, in the keyboard buffer 12 in order to restart the task A. . As a result, after the task D is completed, control is transferred to the command interpretation software, and the keyboard buffer 12
The command written in is interpreted, the executable program corresponding to the task A is read from the hard disk 8 via the I / F 7, loaded into the RAM 3, and then activated.

In this way, each of the tasks A to D can activate the next task via the keyboard buffer 12. In addition, as in the case of task A or task B (however, when started when there is medical insurance for the elderly), the task to be started next should be determined according to the processing result. Is also possible.

As described above, in each of the above embodiments, the keyboard buffer 12 is used to control the task. That is, the task control is not performed by the system task scheduler, but a task activation command that is normally input from the keyboard is directly written into the keyboard buffer 12 by the application program.

Writing a task activation command to the keyboard buffer 12 is an extremely low-level process (for example, a process of directly writing to an address where the keyboard buffer exists by an assembler or the like), so that the program size required for task control is small. Fewer, application programs can make maximum use of memory. Further, the task activation command written in the keyboard buffer 12 is treated as an input from the keyboard 6 by the command interpreting software, so that various activation parameters can be used as in the case of the command input from the keyboard 6. There is also an advantage that it is easy to handle.

Further, the command interpretation software in each of the above-mentioned embodiments is resident software (a part of which is non-resident), and is software that always exists in the operating system. As described above, the command interpretation software terminates the processing of the started program,
When control is transferred to the command interpretation software again,
The task activation command stored in the keyboard buffer 12 is interpreted and the corresponding process is executed.

The above second embodiment (embodiment of FIG. 3)
In the above, the case where the present invention is applied to the insurance card confirmation system has been described, but the present invention is not limited to this, and other systems,
For example, it can be applied to FA (Factory Automation) and control systems.

In each of the above embodiments, the operating system has been described as MS-DOS, but the present invention is not limited to this.

Further, in each of the above embodiments, another display device such as a liquid crystal display device may be used instead of the CRT, and another recording medium such as a CD-ROM or floppy disk may be used instead of the hard disk. It is possible.

[0075]

The program control method according to claim 1,
According to the program control device of claim 3,
A command corresponding to a predetermined task to be executed next among a plurality of tasks after the application program is divided into a plurality of tasks of a predetermined size that can be executed in real memory, and the task performs a predetermined process. Is written in the buffer, so the task to be executed next can be specified from the currently executing task using the buffer. Therefore, task control can be performed by control substantially similar to command input from the keyboard, and the actual memory can be effectively used.

[Brief description of the drawings]

FIG. 1 is a block diagram showing a configuration example of a program control device of the present invention.

2 is a flow chart for explaining the operation of the apparatus of FIG.

FIG. 3 is a block diagram showing a configuration example of an insurance card collation system to which the program control device of the present invention is applied.

FIG. 4 is a flowchart for explaining the operation of the system of FIG.

FIG. 5 is a flow chart for explaining a conventional task activation method.

[Explanation of symbols]

 1 CPU 2 ROM 3 RAM 4 VRAM 5 keyboard interface 6 keyboard 7 I / F 8 hard disk (storage means) 9 CRT controller 10 CRT 11 system bus 12 keyboard buffer 31 card reading unit 32 processing unit 33 insurance certificate reading unit 34 issuing unit

Claims (3)

[Claims] 1. A buffer for accumulating a command input from a keyboard, and command interpretation software for interpreting the command accumulated in the buffer and activating a corresponding task, the size of an actual memory being limited, In a program control method for controlling the execution of an application program under an operating system in which virtual memory or multitasking cannot be used, the application program is divided into a plurality of tasks of a predetermined size that can be executed in the real memory, The task started by the command control software, after executing a predetermined process, writes the command corresponding to a predetermined one of the plurality of tasks to be executed next in the buffer. Program control method. 2. The program control method according to claim 1, wherein the operating system is a Microsoft disk operating system. 3. A buffer for accumulating a command input from a keyboard, and command interpretation software for interpreting the command accumulated in the buffer and activating a corresponding task, and the size of an actual memory is limited. In a program control device that controls the execution of an application program under an operating system in which virtual memory or multitasking cannot be used, the application program divided into a plurality of tasks of a predetermined size that can be executed in the real memory A storage unit that stores the part of the task started by the command control software, and after the task executes a predetermined process, a predetermined one to be executed next among the plurality of tasks. Command writing to write the corresponding command to the buffer Program control device, characterized in that it comprises a means.