DOS Concurrent Process

This section applies only to the DOS version.

When you specify the name of a file to Epsilon, Epsilon interprets it with respect to the current directory unless it begins with a slash or backslash. We call a file name that begins with a slash an absolute pathname, and one that does not begin with a slash a relative pathname. Under most operating systems each program has its own current directory, but DOS has only one current directory that all programs share (well, actually one per disk drive).

Some programs temporarily change the current directory for several seconds while the program runs. Older versions of the DOS command processor do this when you give a command which it cannot find in the current directory, and have defined a directory search PATH. If you issue a command like find-file while running such a program concurrently, and use a relative pathname, you may wind up with the wrong file. File names shown on mode lines will change to reflect the current directory, so if a relative file name suddenly turns into an absolute file name in a mode line, you know why. You should wait when DOS starts up a command if you use search paths and an older version of DOS. Alternatively, you can always use an absolute pathname. This issue only arises under older versions of DOS, or with programs that change the current directory.

Under DOS, the stop-process command will not take effect until the program's next DOS call, exclusive of console input or output. If the program does no DOS calls other than typing characters and reading characters or lines, the vanilla version of the stop-process command won't stop the program.

With a numeric argument, however, stop-process uses a different approach, which always stops the program, but certain older programs, if stopped in this way, crash the system. In some versions of DOS prior to version 3.1, the command processor exhibits this problem. Use stop-process with a numeric argument only after a plain stop-process has failed to stop a program, and never with the command processor of a version of DOS prior to version 3.1. With a numeric argument, stop-process can even stop programs with infinite loops which would require rebooting outside of Epsilon.

If you've never tried a particular program before, you should make sure to save your work before you try to run it concurrently. Programs that use DOS for I/O generally work, whereas programs that use the BIOS to display characters or get input will not.

Under DOS, when a concurrent process exits, Epsilon normally reclaims the memory it used. However, some programs leave part of themselves in memory when they exit from their first invocation. The DOS Print and Mode commands do this, and some networking programs may act like this, too. If you run such programs from within Epsilon, Epsilon cannot reclaim the space when the program exits. You should run these programs outside Epsilon the first time you run them.

Epsilon for DOS must divide memory between itself and a concurrent process. The amount of memory available to the concurrent process depends on what types of memory are available to Epsilon (EMS, XMS, upper memory blocks, or conventional), what command line switches you've given, and the size of the files you're editing before starting the process.

To ensure that Epsilon provides the maximum possible space to a concurrent process:

Provide the -m0 flag to make Epsilon use as little memory as possible (see Epsilon Command Line).
If Epsilon can't put its functions in XMS or EMS memory, the process will lose about 64k of potential memory space. If you have an EMS memory manager program that only supports EMS 3.2, Epsilon won't be able to use it for storing its functions. Get a version that supports EMS 4.0, or install an XMS memory manager.
Make sure Epsilon doesn't have to put buffer text in conventional memory.

Epsilon won't have to use any conventional memory for buffer text if:

At least 128k of EMS memory is available, or
At least 128k of XMS memory is available, and at least 64k of memory is available in upper memory blocks.

Otherwise, Epsilon will put up to 30k of buffer text in conventional memory.

Some programs are so big that even with -m0, they still won't fit along with Epsilon. Epsilon can't run such programs concurrently, but you can run them without leaving Epsilon by having Epsilon shrink down before running the program. See Running Other Programs.

Previous Up Next
Compiling From Epsilon Commands by Topic Repeating a Single Command