AmigaDOS Introduction

About AmigaDOS Processes

AmigaDOS is a multitasking disk operating system designed for the Amiga. You normally run AmigaDOS for a single user. The multitasking facility lets many jobs take place simultaneously. You can also use the multitasking facility to suspend one job while you run another.

Each AmigaDOS process represents a particular process of the operating system - for example, the filing system. Only one process is running at a time, while other processes are either waiting for something to happen or have been interrupted and are waiting to be resumed. Each process has a priority associated with it, and the process with the highest priority that is free to run does so. Processes of lower priority run only when those of higher priority are waiting for some reason - for example, waiting for information to arrive from the disk.

The standard AmigaDOS system uses a number of processes that you did not start, for example, the process that handles the serial line. These processes are known as system processes. Other system processes handle the console and the filing system on a disk drive. If the hardware configuration contains more than one disk drive, there is a process for each drive.

AmigaDOS provides a process that you can use, called a Command Line Interface or Shell. There may be several Shell processes running simultaneously, numbered from 1 onwards. The Shell processes read commands and then execute them. To make additional Shell processes, you use the NEWSHELL or RUN commands. To remove a Shell process use the ENDSHELL command. (You can find a full description of these commands in Chapter 2).

Console Handling

You can direct information that you enter at the terminal to a Command Line Interface (Shell) that tells AmigaDOS to load a program, or you can direct the information to a program running under that Shell. In either case, a @{b}console@{ub} (or @{b}terminal@{ub}) @{b}handler@{ub} processes input and output. This handler also performs local line editing and certain other functions. You can type ahead as many as 512 characters - the maximum line length.

To correct mistakes, you press the BACKSPACE key. This erases the last character you typed. To rub out an entire line, hold down the Ctrl key while you press X. This @{b}control combination@{ub} is referred to from this point on in the manual as Ctrl-X. You may also use the left and right cursor keys to move within the command line to insert or remove characters if you make a mistake.

You can also search for the most recent occurrence of a specific command by typing the command line, or the beginning of it, then pressing Shift-Up (or Ctrl-R). For instance, if you type DIR and press Shift-Up, you will be returned to the last command to perform a DIR of any directory. Pressing Shift-Down moves you to the bottom of the history buffer, leaving the cursor on a blank line.

In addition to command line editing, the Shell also provides command history, which allows you to recall previously-entered command lines, edit them, and re-enter them. This is useful when you want to repeat a command or enter several very similar commands.

The shell uses a 2K command line buffer to retain command lines. The exact number of lines varies depending on [the] lengths of the lines actually stored. When the buffer fills up, the oldest lines are lost. You access lines in the buffer through the up and down cursor keys:

up cursor	Moves backwards in the history buffer (earlier lines).
down cursor	Moves forwards in the history buffer (later lines).

If you type anything, AmigaDOS waits until you have finished typing before displaying any other output. Because AmigaDOS waits for you to finish, you can type ahead without your input and output becoming intermixed. AmigaDOS recognizes that you have finished a line when you press the RETURN key. You can also tell AmigaDOS that you have finished with a line by cancelling it. To cancel a line, you can either press Ctrl-X or press BACKSPACE until all the characters on the line have been erased. Once AmigaDOS is satisfied that you have finished, it starts to display the output that it was holding back. If you wish to stop the output so that you can read it, simply type any character (pressing the space bar is the easiest), and the output stops. To restart output, press BACKSPACE, Ctrl-X, or RETURN. Pressing RETURN causes AmigaDOS to try to execute the command line typed after the current program exits.

AmigaDOS recognizes Ctrl-\\ as an end-of-file indicator. In certain circumstances, you use this combination to terminate an input file. (For a circumstance when you would use Ctrl-\\, see "Understanding Device Names", below).

If you find that strange characters appear on the screen when you type anything on the keyboard, you have probably pressed Ctrl-O by mistake. AmigaDOS recognizes this control combination as an instruction to the console device (CON:) to display the alternative character set. To undo this condition, you press Ctrl-N. Any further characters should then appear as normal. You could press Esc-C to reset the console. This clears the screen and displays normal text.

The table below summarizes the editing capabilities of the Amiga's Shell interface:

Key	Shell Editing Commands
left cursor	Moves cursor one character to the left.
right cursor	Moves cursor one character to the right.
Shift-left cursor	Moves cursor to the beginning of the line.
Shift-right cursor	Moves cursor to the end of the line.
Backspace	Deletes the character to the left of the cursor.
Del	Deletes the character highlighted by the cursor.
Ctrl-H	Deletes the last character (same as BACKSPACE).
Ctrl-M	Processes the command line (same as RETURN).
Ctrl-J	Adds a line feed.
Ctrl-W	Deletes the word to the left of the cursor
Ctrl-X	Deletes the current line.
Ctrl-K	Deletes everything from the cursor forwards to the end of the line.
Ctrl-Y	Replaces the characters deleted with Ctrl-K.
Ctrl-U	Deletes everything from the cursor backwards to the start of the line.
Space bar (or any printable character)	Suspends output (stops scrolling).
Backspace	Resumes output (continues scrolling).
Ctrl-C	Sends a BREAK command to the current process (halts the process).
Ctrl-D	Sends a BREAK command to the current script (halts the script).
Ctrl-S	Suspends output.
Ctrl-Q	Resumes output if it was suspended with Ctrl-S.
Ctrl-\	Closes the Shell window.

Finally, AmigaDOS recognizes all commands and @{b}arguments@{ub} typed in either upper or lower case. AmigaDOS displays a @{b}filename@{ub} with the characters in the case used when it was created, but finds the file no matter what combination of cases you use to specify the filename.

Using the Filing System

This section describes the AmigaDOS filing system. In particular, it explains how to name, organize, and recall your files.

A file is the smallest named object used by AmigaDOS. The simplest identification of a file is by its filename, discussed below in "Naming Files". However, it may be necessary to identify a file more fully. Such an identification may include the device or volume name, and/or directory name(s) as well as the filename. These will be discussed in [the] following sections.

Naming Files

AmigaDOS holds information on disks in a number of @{b}files@{ub}, named so that you can identify and recall them. The filing system allows filenames to have up to 30 characters, where the characters may be any printing character except slash (/) and colon (:). This means that you can include space ( ), equals (=), plus (+) and double quote ("), all special characters recognized by the CLI, within a filename. However, if you use these special characters, you must enclose the entire filename within double quotes. To introduce a double quote character within a filename, you must type an asterisk (*) immediately before that character. In addition, to introduce an asterisk, you must type another asterisk. This means that a file named:

A*B = C"

should be typed as follows:

"A**B = C*""

for the CLI to accept it.

@{b}Note:@{ub} This use of the asterisk is in contrast to many other operating systems where it is used as a universal @{b}wild card@{ub}. An asterisk by itself in AmigaDOS represents the keyboard and the current window. For example,

COPY filename TO *

copies the filename to the screen. On the Amiga, the universal wild card is #?.

When spaces are used within a file, directory, or device name, quotes are required when accessing the name. For example,

COPY "df0:My file" TO ram:

Avoid spaces before or after filenames because they may cause confusion.

Using Directories

The filing system also allows the use of @{b}directories@{ub} as a way to group files together into logical units. For example, you may use two different directories to separate program source from program documentation, or to keep files belonging to one person distinct from those belonging to another.

Each file on a disk must belong to a directory. An empty disk contains one directory, called the @{b}root directory@{ub}. If you create a file on an empty disk, then that file belongs to the root directory. However, directories may themselves contain other directories. Each directory may therefore contain files, or yet more directories, or a mixture of both. Any filename is unique only within the directory it belongs to, so that the file "fred" in the directory "bill" is a completely different file from the one called "fred" in the directory "mary".

This filing structure means that two people sharing a disk do not have to worry about accidentally overwriting files created by someone else, as long as they always create files in their own directories.

WARNING: When you create a file with a filename that already exists, AmigaDOS deletes the previous contents of that file. No message to that effect appears on the screen. You can also use this directory structure to organize information on the disk, keeping different sorts of files in different directories.

An example might help to clarify this. Consider a disk that contains two directories, called "bill" and "mary". The directory "bill" contains two files, called "text" and "letter". The directory "mary" contains a file called "data" and two directories called "letter" and "invoice". These subdirectories each contain a file called "jun18". [This figure] represents this structure as follows:

                       ROOT
                         |
              +----------+----------+
              |                     |
            BILL                  MARY
              |                     |
         +----+----+           +--------+--------+
         |         |           |        |        |
       TEXT     LETTER       DATA    LETTER   INVOICE
                                        |        |
                                      JUN18    JUN18

@{b}Note:@{ub} The directory "bill" has a file called "letter", while the directory "mary" contains a directory called "letter". However, there is no confusion because both...are in different directories. There is no limit to the depth that you can "nest" directories.

To specify a file fully, you must include the directory that owns it, the directory owning that directory, and so on. To specify a file, you give the names of all the directories on the path to the desired file. To separate each directory name from the next directory or filename, you type a following slash (/). Thus, the full specification of the data files on the disk shown...above is as follows:

bill/text
bill/letter
mary/data
mary/letter/jun18
mary/invoice/jun18

Setting the Current Directory

A full file description can get extremely cumbersome to type, so the filing system maintains the idea of a @{b}current directory@{ub}. The filing system searches for files in this current directory. To specify the current directory, you use the CD (@{u}C@{uu}urrent @{u}D@{uu}irectory) command. If you have set "mary" as your current directory, then the following names would be sufficient to specify the files in that directory:

data
letter/jun18
invoice/jun18

You can set any directory as the current directory. To specify any files within that directory, simply type the name of the file. To specify files within subdirectories, you need to type the names of the directories on the path from the current directory specified.

All the files on the disk are still available even though you've set up a current directory. To instruct AmigaDOS to search through the directories from the root (top level) directory of a volume (disk or partition), you type a colon (:) at the beginning of the file description. Thus, when your file description [sic] has the current directory set to "mary", you can also obtain the file "data" by typing the description ":mary/data". Using the current directory method simply saves typing, because all you have to do is specify the filename "data".

To obtain the other files on the disk, first type ":bill/text" and ":bill/letter", respectively. Another way might be to CD or type / before the filename. Slash [(/)] does not mean "root" as in some systems, but refers to the directory above the current directory. AmigaDOS allows multiple slashes. Each slash refers to the level above. So a UNIX ../ is a / in AmigaDOS. Similarly, an MS-DOS ..\\ is a / in AmigaDOS. Thus, if the current directory is ":mary/letter", you may specify the file ":mary/invoice/jun18" as "/invoice/jun18". To refer to the files in ":bill", you could type:

CD :bill

or

CD //bill

Then you could specify any file in "bill" with a single filename. Of course, you could always use the // feature to refer directly to a specific file. For example,

TYPE //bill/letter

displays the file without your first setting "bill" as the current directory. To go straight to the root level, always type a colon (:) followed by a directory name. If you use slashes, you must know the exact numbewr of levels back desired.

Setting the Current Device

Finally, you may have many disk drives. Each [floppy] disk device has a name in the form DFn (for example DF1), where the "n" refers to the number of the device. (Currently, AmigaDOS accepts the device names DF0 to DF3.) Each individual disk is also associated with a unique name, known as a volume name (see below for more details).

In addition, the logical device SYS: is assigned to the disk you started the system up from. You can use this name in place of a disk device name (like DF0:).

The current directory is also associated with a @{b}current drive@{ub}, the drive where you may find the [current] directory. As you know, prefacing a file description with a colon serves to identify the root of the current drive. However, to give the root directory of a specific drive, you precede the colon with the drive name. Thus, you have yet another way of specifying the file "data" in directory "mary", that is "DF1:mary/data". This assumes that you have inserted the disk into drive DF1. So, to reference a file on the drive DF0 called "project-report" in directory "peter", you would type "DF0:peter/project-report", no matter which directory you had set as the current one.

@{b}Note:@{ub}When you refer to a disk drive or any other device, on its own or with a directory name, you should always type the colon; for example, DF1:.

This table illustrates the structure of a file description

Left of the :	Right of the :	Right of a /
Device name or Volume name	Directory name or Filename	Subdirectory name or Filename

Here are some examples of valid file descriptions.

SYS:commands
DF0:bill
DF1:mary/letter
DF2:mary/letter/jun18
DOC:report/section1/figure
FONTS:silly-font
C:cls

To gain access to a file on a particular disk, you can type its unique name, which is known as the disk's @{b}volume name@{ub}, instead of the device name. For instance, if the file is on the disk "MCC", you can specify the same file by typing the name "MCC:peter/project-report". You can use the volume name to refer to a disk regardless of the drive it is in. You assign a volume name to a disk when you format it (for further details, see FORMAT in @{" Chapter 2 " link Two}). You can also change the volume name using the RELABEL command.

A device name, unlike a volume name, is not really part of the name. For example, AmigaDOS can read a file you created on DF0: from another drive, such as DF1:, if you place the disk in that drive, assuming of course that the drives are interchangeable. That is, if you created a file called "bill" on a disk in drive DF0:, the file is known as "DF0:bill". If you then move the disk to drive DF1:, AmigaDOS can still read the file, which is then known as "DF1:bill".

Attaching a Filenote

Although a filename can give some information about its contents, it is often necessary to look in the file itself to find out more. AmigaDOS provides a simple solution to this problem. You can use the command called FILENOTE to attach an associated comment. You can make up a comment of up to 80 characters (you must enclose comments containing spaces in double quotes). Anything can be put in a file comment: the day of the file's creation, whether or not a bug has been fixed, the version number of a program, and anything else that may help to identify it.

You must associate a comment with a particular file - not all files have them. To attach comments, you use the FILENOTE command. If you create a new file, it will not have a comment. Even if the new file is a copy of a file that has a comment, the comment is not copied to the new file. However, any comment attached to a file which is overwritten is retained. To write a program to copy a file and its comment, you'll have to do some extra work to copy the comment. For details, see @{" Chapter 6 " link Six}.

When you rename a file, the comment associated with it doesn't change. The RENAME command only change the name of the file. The file's contents and comment remain the same regardless of the name change. For more details, see LIST and FILENOTE in @{" Chapter 2 " link Two}.

Understanding Device Names

Devices have names so that you can refer to them by name. Disk names such as DF0: are examples of @{b}device names@{ub}. Note that you may refer to device names, like filenames, using either upper or lower case. For disks, you follow the device name by a filename because AmigaDOS supports files on these devices. Furthermore, the filename can include directories because AmigaDOS also supports directories.

You can also create files in memory with the device called RAM:. RAM: implements a filing system in memory that supports any of the normal filing system comands.

@{b}Note:@{ub} If you are running AmigaDOS 1.3 or an earlier version, RAM: requires the library L:ram-handler to be on the disk. (Under 2.0 the RAM-handler is in the ROMs).

Once the RAM: device exists, you can, for instance, create a directory to copy all the commands into memory. To do this, type the following commands:

MAKEDIR ram:c
COPY sys:c TO ram:c
ASSIGN C: ram:c

You could then look at the output with DIR RAM:. It would include the direcotry "c" (DIR lists this as "c (dir)"). This would make loading commands very quick but would leave little room in memory for anything else. Any files in the RAM: device are lost when you reset the machine.

AmigaDOS also provides a number of other devices that you can use instead of a reference to a disk file. The following paragraphs describe these devices including NIL:, SER:, PAR:, PRT:, CON:, and RAW:. In particular, the device NIL: is a dummy device. AmigaDOS simply throws away output written to NIL:. While reading from NIL:, AmigaDOS gives an immediate "end-of-file" indication. For example, you would type the following:

EDIT abc TO nil:

to use the editor to browse through a file, while AmigaDOS throws away the edited output.

You use the device called SER: to refer to any device connected to the serial line (often a [modem or] printer). Thus, you would type the following command sequence:

COPY xyz TO ser:

to instruct AmigaDOS to send the contents of the file "xyz" down the serial line. Note that the serial device only copies in multiples of 400 bytes at a time. Copying with SER: can therefore appear granular.

The device PAR: refers to the parallel port in the same way.

AmigaDOS also provides the device PRT: (for PRinTer). PRT: is the printer you chose in the Preferences program. In this program, you can define your printer to be connected through either the serial or parallel port. Thus, the command sequence:

COPY xyz TO prt:

prints the file "xyz", no matter how the printer is connected.

All output sent to PRT: is translated through the printer driver selected in Preferences. The printer driver will translate standard ANSI escape codes into the specific code required by the printer. PRT: translates every linefeed character in a file to carriage return plus linefeed. Some printers, however, require files without translation. To send a file with the linefeeds as just linefeeds, you use PRT:RAW instead of PRT:.

AmigaDOS supports multiple windows. To make a new window, you can specify the device CON:. The format for CON: is as follows:

CON:x/y/width/height/[title]

where "x" and "y" are coordinates, "width" and "height" are integers describing the width and height of the new window, and "title", which is optional, is a string. The title appears on the window's title bar. You must include all the slashes, including the last one. Your title can include up to 30 characters (including spaces). If the title has spaces, you must enclose the whole description in double quotes (") as shown in the following example:

"CON:20/10/300/100/my window"

Under 2.0 and later versions of AmigaDOS, CON: windows have additional special features. Refer to @{" Chapter 8 " link Eig} for a complete description.

There is another window device called RAW:, but it is of little use to the general user. (See @{" Chapter 8 " link Eig} for further details.) You can use RAW: to create a raw window device similar to CON:. However, unlike CON:, RAW: does no character translation and does not allow you to change the contents of a line. That is to say, RAW: accepts input and returns output in exactly the same form that it was originally typed. This means characters are sent to a program immediately without letting you erase anything with the BACKSPACE key. You usually use RAW: from a program where you might want to do input and output without character translation.

WARNING: RAW: is intended for the advanced user. Do not use RAW: experimentally.

There is one special name, which is * (asterisk). You use this to refer to the current window, both for input or for output. You can use the COPY command to copy from one file to another. Using *, you can copy from the current window to another window, for example,

COPY * TO CON:20/20/350/150/

from the current window to the current window, for example,

COPY * TO *

or from a file to the current window, for example,

COPY bill/letter TO *

AmigaDOS finishes copying when it comes to the end of the file. To tell AmigaDOS to stop copying from *, you must give the Ctrl-\\ combination. Note that * is NOT the universal wild card.

Using Directory Conventions and Logical Devices

In addition to the aforementioned physical devices, AmigaDOS supports a variety of useful @{b}logical devices@{ub}. AmigaDOS uses these devices to find the files that your programs require from time to time. (So that your programs can refer to a standard device name regardless of where the file actually is.) All of these "logical devices" may be reassigned by you to reference any directory.

The logical devices described in this section are as follows:

Logical Device Name	Description	Directory
SYS:	System disk root directory	SYS:
C:	Commands directory	SYS:C
L:	Library directory	SYS:L
S:	Script directory	SYS:S
LIBS:	Directory for OpenLibrary() calls	SYS:LIBS
DEVS:	Directory for OpenDevice() calls	SYS:DEVS
FONTS:	Loadable fonts for OpenFonts() calls	SYS:FONTS
T:	Temporary workspace	RAM:T

SYS:

Typical directory name: Workbench:

"SYS" represents the @{u}SYS@{uu}tem disk root directory. When you first start up the Amiga system [from floppy], AmigaDOS assigns SYS: to the root directory name of the disk in DF0:. If, for instance, the disk in drive DF0: has the volume name Workbench, then AmigaDOS assigns SYS: to Workbench:. After this assignment, any programs that refer to SYS: use that disk's root directory.

C:

Typical directory name:@{ui} Workbench:c

"C" represents the @{u}C@{uu}ommands direcotry. When you type a command to the CLI (DIR, for example), AmigaDOS first searches for that command in your cuurent directory. If the system cannot find the command in the current directory, it then look for "C:DIR". So that, if you have assigned "C:" to another directory (for example, "Boot_disk.c"), AmigaDOS reads and executes from "Boot_disk:c/DIR".

L:

Typical directory name:@{ui} Workbench:l

"L" represents the @{u}L@{uu}ibrary directory. This directory keeps the overlays for large commands and nonresident parts of the operating system. For instance, the disk-based run-time libraries (Aux-Handler, Port-Handler, and so forth) are kept here. AmigaDOS requires this directory to operate.

S:

Typical directory name:@{ui} Workbench:s

"S" represents the @{u}S@{uu}cript directory. This directory contains command scripts that the EXECUTE command searches for and uses. EXECUTE first looks for the script (or batch) file in your current directory. If EXECUTE cannot find it there, it looks in the directory that you have assigned S: to.

LIBS:

Typical directory name:@{ui} Workbench:libs

[OpenLibrary()] looks here for the library if it is not already loaded in memory.

DEVS:

Typical directory name:@{ui} Workbench:devs

OpenDevice()...looks here for the device if it is not already loaded in memory.

FONTS:

Typical directory name:@{ui} Workbench:fonts

OpenFonts() looks here for your loadable fonts if they are not already loaded in memory.

T:

Typical directory name: RAM:T

You use this directory to store temporary files. Programs such as editors place their temporary work files, or backup copies of the last file edited, in this directory. If you run out of space on a disk, this is one of the first places you should look for files that are no longer needed.

During booting

When the system is first booted, AmigaDOS initially assigns C: to the :C directory. This means that if you boot with a disk that you had formatted by issuing the command:

FORMAT DRIVE DF0: NAME "My.Boot.Disk"

SYS: is assigned to "My.Boot.Disk". The "logical device" C: is assigned to the C: directory on the same disk (that is, My.Boot.Disk:c). Likewise, the following assignments are made:

C:             My.Boot.Disk:c
L:             My.Boot.Disk:l
S:             My.Boot.Disk:s
LIBS:          My.Boot.Disk:libs
DEVS:          My.Boot.Disk:devs
FONTS:         My.Boot.Disk:fonts

If a directory is not present, the corresponding logical device is assigned to the root directory.

If you have a non-bootable hard disk (here called DH0:) and you want to use the system files on it, you must issue the following commands to the system:

ASSIGN SYS:    DH0:
ASSIGN C:      DH0:c
ASSIGN L:      DH0:l
ASSIGN S:      DH0:s
ASSIGN LIBS:   DH0:libs
ASSIGN DEVS:   DH0:devs
ASSIGN FONTS:  DH0:fonts

If your hard disk is bootable, you don't need to make these assigns since the system handles it for you.

Please keep in mind that assignments are global to all Shell processes. Changing an assignment within one window changes it for all windows.

If you want to use your own special font library, type:

ASSIGN FONTS: "Special font disk:myfonts"

If you want your commands to load faster (and you have memory "to burn"), type:

MAKEDIR ram:c
COPY sys:c ram:c ALL
ASSIGN c: ram:c

This copies all of the normal AmigaDOS commands to the RAM disk and reassigns the commands directoy so that the system finds them there. Another way to speed up AmigaDOS commands is by making them resident. See the description of the RESIDENT command in @{" Chapter 2 " link Two}.

Using AmigaDOS Commands

An AmigaDOS command consists of the command name and its arguments, if any. To execute an AmigaDOS command, you type the command name and its arguments after the Shell prompt.

When you type a command name, the command runs as part of the Command Line Interface (Shell). You can type other command names ahead, but AmigaDOS does not execute them until the current command has finished. When a command has finished, the current Shell prompt appears. In this case, the command is running interactively.

The Shell prompt is initially n> where n is the number of the Shell process. However, it can be changed to something else with the PROMPT command. (For further details on the PROMPT command, see @{" Chapter 2 " link Two}.

WARNING: If you run a command interactively and it fails, AmigaDOS continues to execute the next command you typed anyway. Therefore, it can be dangerous to type many commands ahead. For example, if you type COPY a TO b DELETE a and the COPY command fails (perhaps because the disk is full), then DELETE executes and you lose your file.

Running Commands in the Background

You can instruct AmigaDOS to run a command, or commands, in the background. To do this, you use the RUN command. This creates a new Shell as a separate process of the same priority. In this case, AmigaDOS executes subsequent command lines at the same time as those that have been RUN. For example, you can examine the contents of your directory at the same time as sending a copy of your text file to the printer. To do this, type

RUN TYPE text_file TO prt:
LIST

RUN creates a new Shell and carries out your printing while you list your directory files on your original Shell window.

You can ask AmigaDOS to carry out several commands using RUN. RUN takes each command and carries it out in the given order. The line containing commands after RUN is called a command line. To terminate the command line, press RETURN. To extend your command line over several lines, type a plus sign (+) before pressing RETURN on every line except the last. For example,

RUN JOIN text_file1 text_file2 AS text_file +
SORT text_file TO sorted_text +
TYPE sorted_text TO prt:

If you want to start a command using RUN and then close the Shell window from which it was launched, you will have to redirect input and output. To do this use:

RUN <NIL: >NIL: command

Executing Command Files

You can also use the EXECUTE command to execute command lines in a file instead of typing them in directly. The Shell reads the sequence of commands from the file until it finds an error the end of the file. If it finds an error, AmigaDOS does not execute subsequent commands on the RUN line or in the file used by EXECUTE, unless you have used the FAILAT command. See @{" Chapter 2 " link Two} for details on the FAILAT command. The Shell only gives prompts after executing commands that have run interactively.

Directing Command Input and Output

AmigaDOS provides a way for you to redirect standard input and output. You use the > and < symbols as commands. When you type a command, AmigaDOS usually displays the output from that command on the screen. To tell AmigaDOS to send the output to a file, you can use the > command. To tell AmigaDOS to accept the input to a program from the specified file rather than from the keyboard, you use the < command. The < and > commands act like traffic cops who direct the flow of information. For example, to direct the output from the DATE command and write it to the file named "text_file", you would type the following command line:

DATE > text_file

If you want to redirect output to a file that already exists use >>. For example, to direct the output of the TYPE command to a file that already exists use:

TYPE >>more_text original_text

The text stored in the file original_text will be appended to any text that is already stored in the file my_text. Under 2.0 and later versions of AmigaDOS, if you redirect output to a file using >> and the file does not exist, then the file will be created for you.