------------------------------- Page    i -------------------------------

                     A Tutorial Introduction to the

                       UTS Full Screen Text Editor

------------------------------- Page   ii -------------------------------

                            TABLE OF CONTENTS


1.    Acknowledgement . . . . . . . . . . . . . . . . . . . . . . . .   1

2.    Introduction  . . . . . . . . . . . . . . . . . . . . . . . . .   1

3.    Disclaimer  . . . . . . . . . . . . . . . . . . . . . . . . . .   1

4.    Getting Started . . . . . . . . . . . . . . . . . . . . . . . .   1

5.    Directly Creating Text  . . . . . . . . . . . . . . . . . . . .   2

6.    Error Messages  . . . . . . . . . . . . . . . . . . . . . . . .   3

7.    The Append Command - a  . . . . . . . . . . . . . . . . . . . .   3

8.    Writing text out as a file - the Write command w  . . . . . . .   3

9.    Leaving ned - the Quit command q  . . . . . . . . . . . . . . .   4

10.   Exercise 1: . . . . . . . . . . . . . . . . . . . . . . . . . .   5

11.   Reading text from a file - the Edit Command e . . . . . . . . .   5

12.   Reading text from a file - the Read command r . . . . . . . . .   6

13.   Exercise 2: . . . . . . . . . . . . . . . . . . . . . . . . . .   7

14.   Looking at the contents of the buffer . . . . . . . . . . . . .   7

15.   Exercise 3: . . . . . . . . . . . . . . . . . . . . . . . . . .   8

16.   The current line - Dot or . . . . . . . . . . . . . . . . . . .   8

17.   Deleting lines: the d command . . . . . . . . . . . . . . . . .   8

18.   Exercise 4: . . . . . . . . . . . . . . . . . . . . . . . . . .   9

19.   Line Commands . . . . . . . . . . . . . . . . . . . . . . . . .   9

20.   Exercise 5: . . . . . . . . . . . . . . . . . . . . . . . . . .  10

21.   Modifying text: the Substitute command s  . . . . . . . . . . .  10

22.   Exercise 6: . . . . . . . . . . . . . . . . . . . . . . . . . .  12

------------------------------- Page  iii -------------------------------

23.   Context searching - / . . . / . . . . . . . . . . . . . . . . .  12

24.   Exercise 7: . . . . . . . . . . . . . . . . . . . . . . . . . .  14

25.   Special Characters  . . . . . . . . . . . . . . . . . . . . . .  15

26.   Advanced Features . . . . . . . . . . . . . . . . . . . . . . .  18


                                                            Last Page  18

-------------------------------- Page  1 --------------------------------

1.    ACKNOWLEDGEMENT

This tutorial was adapted from "A Tutorial Introduction to the UNIX  Text
Editor" by B. W. Kernighan of Bell Laboratories.




2.    INTRODUCTION

Ned is a "text editor", that is, an interactive program for creating  and
modifying "text", using directions provided by a user at a terminal.  The
text is often a document like this one, or a program or perhaps data  for
a program.

This introduction is meant to simplify learning ned.  The recommended way
to learn ned is to read this document, simultaneously using ned to follow
the examples, then  to read  the Ned  Reference in  the UTS  Programmer's
Manual, all the  while experimenting with  ned.  (Solicitation of  advice
from experienced users is also useful.)

Do the exercises!  They  cover material not  completely discussed in  the
actual text.  An appendix summarizes the commands.




3.    DISCLAIMER

This is an introduction and a tutorial.   For this reason, no attempt  is
made to  cover  more  than  a part  of  the facilities  that  ned  offers
(although this  fraction includes  the most  useful and  frequently  used
parts).  Also, there is not enough space to explain basic UTS procedures.
We will assume that you know how to log on  to UTS, and that you have  at
least a vague understanding of what a file is.




4.    GETTING STARTED

We'll assume that you  have logged in to  UTS and it  has just said  "$".
The easiest way to get ned is to type

-------------------------------- Page  2 --------------------------------

     ned        (followed by a newline)

You are now ready to go - ned is waiting for you to tell it what to do.




5.    DIRECTLY CREATING TEXT

As our first problem, suppose we want  to create some text starting  from
scratch.  Perhaps we are typing the very first draft of  a paper; clearly
it will have to start  somewhere, and undergo modifications later.   This
section will show how  to get some text  in, just to get started.   Later
we'll talk about how to change it.

When ned is first started, it is rather  like working with a blank  piece
of paper - there  is no text or  information present.  This must be  sup-
plied by the person using ned; it is usually done by typing in the  text,
or by reading it into  ned from a file.  We will start by typing in  some
text, and return shortly to how to read files.

First a bit of terminology.  In ned jargon,  the text being worked on  is
said to be "kept in  a buffer." Think of the  buffer as a work space,  if
you like, or simply as the information that you are going to be  editing.
In effect the buffer is  like the piece of paper, on which we will  write
things, then change some of them, and  finally file the whole thing  away
for another day.

The user tells ned  what to do  by typing data  on the screen  in any  of
three areas.  Commands may be entered in the "primary command area" which
is pointed to by the arrow ("==>"), in  the "line command area" which  is
usually filled  with line  numbers,  or by  typing directly  in the  data
display area, where  the current  contents of the  buffer are  displayed.
Finally, the user presses the enter key, or a PF key, or the test request
key, and ned processes the  commands which have  been entered.  The  data
lines and line commands are  processed from top to bottom, then the  pri-
mary command is executed.   To enter lines  of text into  the buffer,  we
just type them directly on the screen, like this:

   Now is the time
   for all good men
   to come to the aid of their party.


After this has been done, the buffer will contain the three lines

   Now is the time

-------------------------------- Page  3 --------------------------------

   for all good men
   to come to the aid of their party.




6.    ERROR MESSAGES

If at any time you make an error in the commands you type to ned, it will
tell you by displaying an appropriate message in the message display area
at the top of the screen and sounding  the bell.  The error messages  are
pretty self-explanatory.




7.    THE APPEND COMMAND - A

You may at some point want to add a  line in between lines which  already
exist in the file.  For example, suppose you wanted to add

   finally

after the first line.  Enter "a" on  the primary command line.  Ned  will
display the current  line at the top  of the screen,  and will leave  the
rest of the screen blank  for the addition of new  lines.  Now enter  the
desired line, then press  enter.  The last  line you entered becomes  the
new current line so you can conveniently do another "a" if you have a lot
of text to enter.




8.    WRITING TEXT OUT AS A FILE - THE WRITE COMMAND W

It's likely that we'll want to save our text for later use.  To write out
the contents of the buffer onto a file, we use the write command

   w

followed by the  filename we  want to write  on.  (The  write command  is
entered on  the  primary  command  line.) This  will  copy  the  buffer's

-------------------------------- Page  4 --------------------------------

contents onto the specified file (destroying any previous information  on
the file).  To save the text on a file named "junk", for example, enter

   w junk

on the primary  command line.   Leave a space  between "w"  and the  file
name.  Ned will respond by  displaying the number of characters it  wrote
out.  In our case, ned would respond with

   68

(Remember that blanks and the newline character  at the end of each  line
are included in the character count.) Writing a file just makes a copy of
the text -  the buffer's  contents are  not disturbed,  so we  can go  on
adding lines to it.  This is an important point.  Ned  at all times works
on a copy of a file, not the file itself.  No change in the contents of a
file takes place until you give a "w" command.  Writing out the text onto
a file from time to time as it is being created is a good idea, since  if
the system crashes or  if you make  some horrible mistake, you will  lose
all the text in the buffer but any text that  was written onto a file  is
relatively safe.   Ned will  do this  automatically for  you through  the
Autosave feature.  This means  that ned will  save a copy  of the  buffer
whenever the number of lines on which changes have been made is, say,  15
or more.  The autosave file will be in  the current directory or in  your
home directory with the name autoxxx, where xxx is the  process id number
of ned.  Ned will delete  this file when you  terminate the editing  ses-
sion, so you'll never see it unless the system goes down in the middle of
your session (which is just when you want it).  You can change the number
15 to  any other  number by  entering "A"  followed by  the number.   Ned
displays the number of changes  made since the last  autosave on the  top
line of the display by the word "alt".




9.    LEAVING NED - THE QUIT COMMAND Q

To terminate a session with ned, save the text you're working on by writ-
ing it onto a file using the "w" command, and then type the command

   q

which stands for quit.  The system will respond with "$".  At this  point
your buffer vanishes, with all  its text, which is why you want to  write
it out before quitting.   Another way to exit  ned is to  press the PF  3
key.  This does a "w" followed by a "q".  If you make some changes to the
buffer and then try to quit, ned will ask if  you really want to quit  by

-------------------------------- Page  5 --------------------------------

displaying "Unsaved changes." in the error message area, and ringing  the
bell.  If you do really  want to quit, re-enter the  quit command and  it
will take effect.




10.   EXERCISE 1:

Enter ned and create some text by typing in the data area.  Write it  out
using "w".  Then leave ned  with the "q" command, and print the file,  to
see that everything worked.  (To print a file, say

   pr filename

or

   cat filename

in response to "$".  Try both.)




11.   READING TEXT FROM A FILE - THE EDIT COMMAND E

A common way to get text into the buffer is to read it from a file in the
file system.  This is  what you do to edit  text that you saved with  the
"w" command in  a previous  session.  The  edit command  "e" fetches  the
entire contents of a file into the buffer.  So if  we had saved the three
lines "Now is the time", etc., with a "w" command in an earlier  session,
the ned command

   e junk

would fetch the entire contents of the  file "junk" into the buffer,  and
respond

   68

which is the number of characters in "junk".  If anything was already  in
the buffer, it is deleted first.

If we use the "e"  command to read a file  into the buffer, then we  need
not use a  file name after  a subsequent "w"  command; ned remembers  the

-------------------------------- Page  6 --------------------------------

last file name used in an "e" command, and  "w" will write on this  file.
Thus a common way to operate is

   ned
   e file
   [editing session]
   w
   q


You can find out at any time what file name ned is remembering by  typing
the file command "f".  In our case, if we typed

   f

ned would reply

   junk




12.   READING TEXT FROM A FILE - THE READ COMMAND R

Sometimes we want to read a file into the buffer without destroying  any-
thing that is already there.  This is done by the  read command "r".  The
command

   r junk

will read the file "junk" into the buffer; it adds it to the end of what-
ever is already in the buffer.  So if we do a read after an edit:

   e junk
   r junk

the buffer will contain two copies of the text (six lines).

   Now is the time
   for all good men
   to come to the aid of their party.
   Now is the time
   for all good men
   to come to the aid of their party.

Like the "w" and "e" commands, "r"  prints the number of characters  read

-------------------------------- Page  7 --------------------------------

in, after the reading operation is complete.

Generally speaking, "r" is much less used than "e".




13.   EXERCISE 2:

Experiment with the "e" command - try reading and printing various files.
You may get an error "New file.", typically because you  spelled the file
name wrong, or because the  file doesn't already exist.  Try  alternately
reading and appending to see that they work similarly.  Verify that

   ned filename

is exactly equivalent to

   ned
   e filename

What does

   f filename

do?




14.   LOOKING AT THE CONTENTS OF THE BUFFER

Ned always displays twenty or  so lines on the screen.   If your file  is
larger that this, you may command ned to display various  groups of lines
by scrolling.  This is done by pressing PF 7 to scroll towards the begin-
ning of the file, and  PF 8 to scroll towards the end of the file.   (You
can remember which is which by looking at the arrows on the keys just  to
the left of the PF keys.) You can also select a line by entering its line
number as a primary command.  The selected line will become the  "current
line" (see below).  There is a special way of selecting  the last line of
the buffer - it is designated as "$".

If the data in your file has more than 74  characters on a line, you  can
scroll left and right  using the PF  10 and 11  keys.  Any time the  data
extends off the right of the screen, ned will display an asterisk in  the

-------------------------------- Page  8 --------------------------------

first position of the line command area to remind you  that there is more
data.




15.   EXERCISE 3:

As before, create some text using the append command and experiment  with
scrolling.  Enter a line number on the primary command line.  Enter a "$"
on the primary command line.  You will find, for example, that you  can't
scroll to line 0 or a line beyond the end of the buffer.




16.   THE CURRENT LINE - DOT OR .

In order to display  lines on the  screen, ned must  remember which  line
goes at the top.   This line is called  the "current" line, or "."  (read
"dot").  When you enter a line number  on the primary command line,  that
line becomes the current line.  You can also enter relative numbers, such
as "+11".   This means  that the  new current  line is  11 past  the  old
current line.  Negative numbers  may also be  entered.  You can find  out
what dot is at any time by typing

   .=

Ned will respond by displaying the value of dot.




17.   DELETING LINES: THE D COMMAND

Suppose we want to get rid of the three extra lines in the buffer.   This
is done by the delete command

   d

The lines to be deleted are specified for "d" like this:

   starting line, ending line d

-------------------------------- Page  9 --------------------------------

Thus the command

   4,$d

deletes lines 4 through the end.




18.   EXERCISE 4:

Experiment with "a", "e", "r", "w", "p", and "d" until you are sure  that
you know what they  do, and until you  understand how dot, "$", and  line
numbers are used.

If you are adventurous, try using line numbers with "a", "r", and "w"  as
well.  You will  find that "a"  will append lines  after the line  number
that you specify (rather than after dot); that "r" reads a file in  after
the line number you specify  (not necessarily at the end of the  buffer);
and that "w" will  write out exactly  the lines you  specify, not  neces-
sarily the  whole buffer.   These  variations are  sometimes handy.   For
instance you can insert a file at the beginning of a buffer by saying

   0r filename

and you can enter lines at the beginning of the buffer by saying

   0a

and then entering the text.




19.   LINE COMMANDS

In addition to commands which may be entered on the primary command line,
ned accepts certain commands as line commands.  These commands are  typed
over the line numbers at the side of the screen.

Try typing a "." in the line command area.   You will find that the  line
you typed it  on became the new  current line after  you typed the  enter
key.  Try typing an "a".  This adds a new line  after the line it is  on.
What does an "i" do?

-------------------------------- Page 10 --------------------------------

You can also move lines around with  line commands.  Suppose you want  to
move line 2 to be  after line 5.  Place an  "m" in the line command  area
for line 2 and a "t" (for "target") in the line command area for line  5.
Press the enter key and  the line will be moved.  You can copy a line  by
using a "c" in place of the "m".

There are also "block commands".  For example, to move several lines to a
new place in the file, type a "mm" in the  line command area of the first
and the last line to be moved, then type a  t (for "target") in the  line
command area of the line after which the data is  to be placed.  Then ned
will move the data.  You can also  use this technique for copying  ("cc")
and deleting ("dd").

A word of caution here.  When different line commands are used in  combi-
nation on a  single screen,  unexpected results may  occur.  For  safety,
stick to doing things simply, or else experiment first before you try  to
get fancy.




20.   EXERCISE 5:

Experiment with the line  commands described above.   What does "3>"  do?
The command "s" will split a line at the position  the cursor is left at.
What does "j" do?




21.   MODIFYING TEXT: THE SUBSTITUTE COMMAND S

The normal way to modify text in ned is by typing directly on the screen.
In some cases, such as when the same change must be made several times in
the file, it is more convenient to use the substitute command

   s

This command is used to change individual words or letters within a  line
or group of lines.

The general way to use the substitute command is

   starting-line, ending-line s/change this/to this/

-------------------------------- Page 11 --------------------------------

Whatever string of characters  is between  the first pair  of slashes  is
replaced by whatever is between the second pair, in all the lines between
starting line and ending line.  Only the first occurrence on each line is
changed, however.  If you want  to change every occurrence, see  Exercise
6.

Thus we can say

   1,$s/speling/spelling/

and correct the first spelling mistake on  each line in the text.   (This
is useful for people who are consistent misspellers!)

If no line numbers are given, the "s"  command assumes we mean "make  the
substitution on line dot", so it changes things only on the current line.
This leads to the very common sequence

   s/something/something else/

which makes some correction on the current line.

It's also legal to say

   s/ . . . //

which means "change  the first  string of characters  to nothing",  i.e.,
remove them.  This is useful for deleting extra words in a line or remov-
ing extra letters from words.  For instance, if we had

   Nowxx is the time

we can say

   s/xx//

to get

   Now is the time

Notice that "//" here  means "no characters",  not a blank.   There is  a
difference!  (See below for another meaning of "//".)

-------------------------------- Page 12 --------------------------------

22.   EXERCISE 6:

Experiment with the substitute command.  See what happens if you  substi-
tute for some word on a line with several occurrences  of that word.  For
example, on this line:

   the other side of the coin

do this

   s/the/on the/

You will get

   on the other side of the coin

A substitute  command changes  only  the first  occurrence of  the  first
string.  You can change all occurrences by adding a "g" (for "global") to
the "s" command, like this:

   s/ . . . / . . . /g

Try other characters instead of slashes to delimit the two sets of  char-
acters in the "s" command - anything should work except blanks or tabs.

(If you get funny results using any of the characters

   ^    .    $    [    *    \

read the section on "Special Characters".)




23.   CONTEXT SEARCHING - / . . . /

The normal way to move around the file in ned is to use the PF7 and PF  8
keys to scroll up and down in the file.  Sometimes  it is necessary to go
directly to a certain  line in  the file, usually  containing a  function
name, variable, etc.  This can be done by using context searching.

Suppose we have our original three line text in the buffer:

   Now is the time
   for all good men
   to come to the aid of their party.

-------------------------------- Page 13 --------------------------------

Suppose we want to find the line that  contains "their" so we can  change
it to "the".  Now with  only three lines in the buffer, it's pretty  easy
to keep track of  what line the word  "their" is on.   But if the  buffer
contained several hundred lines,  and we'd been making changes,  deleting
and rearranging lines, and  so on, we  would no longer  really know  what
this line  number would  be.   Context searching  is simply  a method  of
specifying the desired line, regardless of what its number is, by  speci-
fying some context on it.

The way we say "search for a line that contains this particular string of
characters" is to type

   string of characters we want to find

For example, the ned line

   /their/

is a context search  which is sufficient  to find the  desired line -  it
will locate  the  next  occurrence  of  the  characters  between  slashes
("their").  It also sets dot to that line.  "Next occurrence" means  that
ned starts looking for the  string at line ".+1", searches to the end  of
the buffer, then continues at line 1 and searches to line dot.  (That is,
the search "wraps around" from  "$" to 1.) It scans all the lines in  the
buffer until it either finds the desired line or gets back to dot  again.
If the  given  string of  characters  can't be  found  in any  line,  ned
displays the error message

   "Not found."


We can do both the search for the desired line and a substitution all  at
once, like this:

   /their/s/their/the/

which will yield

   to come to the aid of the party.

There were two parts to that last command: context search for the desired
line, and make the substitution.

The expression "/their/" is a  context search expression.  In their  sim-
plest form, all context  search expressions are  like this - a string  of
characters surrounded by slashes.   Context searches are  interchangeable
with line numbers, so  they can be used  by themselves to find a  desired
line, or as line numbers for some other command, like "s".  We used  them
both ways in the examples above.

-------------------------------- Page 14 --------------------------------

24.   EXERCISE 7:

Experiment with  context searching.   Try  a body  of text  with  several
occurrences of the same string  of characters, and scan through it  using
the same context search.

Try using context searches as line numbers for the substitute and  delete
commands.  (They can also be used with "r", "w", and "a".)

Try context searching  using "?text?"  instead of  "/text/".  This  scans
lines in the buffer in  reverse order rather than normal.  This is  some-
times useful if you go too far while  looking for some string of  charac-
ters - it's an easy way to back up.

(If you get funny results with any of the characters

   ^    .    $    [    *    \

read the section on "Special Characters".)

Ned provides a  shorthand for  repeating a  context search  for the  same
string.  For example, the ned line number

   /string/

will find the next occurrence of "string".  It often happens that this is
not the desired line, so  the search must be repeated.  This can be  done
by typing merely

   //

(or by pressing  PF5, which  contains "//").  This  shorthand stands  for
"the most recently used context  search expression." It can also be  used
as the first string of the substitute command, as in

   /string1/s//string2/

which will  find the  next  occurrence of  "string1" and  replace  it  by
"string2".  This can save a lot of typing.  Similarly

   ??

means "scan backwards for the same expression." (PF4 contains "??".)

-------------------------------- Page 15 --------------------------------

25.   SPECIAL CHARACTERS

You may have noticed that things just don't work right when you used some
characters like ".",  "*", "$",  and others in  context searches and  the
substitute command.  The reason is  rather complex, although the cure  is
simple.  Basically, ned treats these characters as special, with  special
meanings.  Ned will make  these characters non-special  if you issue  the
"B"command.  If you issue  the "B" command  again, the characters  become
special again.  The following discussion assumes that the special charac-
ters are special, i.e. that you have not issued the "B" comamnd.

In a context search or the first string of the substitute command only, .
means "any character," not a period, so

   /x.y/

means "a line with an x, any character, and a  y," not just "a line  with
an x, a period, and a y." A complete list  of the special characters that
can cause trouble is the following:

   ^    .    $    [    *    \

Warning: The backslash character \ is special to ned.  For safety's sake,
avoid it where possible.  If  you have to use one of the special  charac-
ters in a substitute  command, you can  turn off its  magic meaning  tem-
porarily by preceding it with the backslash.  Thus

   s/\\\.\*/backslash dot star/

will change "\.*" into "backslash dot star".

Here is a hurried synopsis of  the other special characters.  First,  the
circumflex  " ^ " signifies the beginning of a line.  Thus

   /^string/

finds "string" only if it is at the beginning of a line: it will find

   string

but not

   the string...

The dollar-sign "$" is just the opposite of the circumflex; it means  the
end of a line:

   /string$/

-------------------------------- Page 16 --------------------------------

will only find an occurrence of "string" that is at the end of some line.
This implies, of course, that

   /^string$/

will find only a line that contains just "string", and

   /^.$/

finds a line containing exactly one character.

The character  ".", as we mentioned above, matches anything;

   /x.y/

matches any of

   x+y
   x-y
   x y
   x.y

This is useful in conjunction with "*", which is a repetition  character;
"a*" is a shorthand for  "any number of a's," so ".*" matches any  number
of anythings.  This is used like this:

   s/.*/stuff/

which changes an entire line, or

   s/.*,//

which deletes all characters  in the line  up to and  including the  last
comma.  (Since ".*" finds the longest possible match, this goes up to the
last comma.)

"[" is used with "]" to form "character classes"; for example,

   /[1234567890]/

matches any single digit -  any one of the  characters inside the  braces
will cause a match.

Finally, the "&" is another shorthand character - it is used only on  the
right-hand part  of a  substitute command  where it  means "whatever  was
matched on the left-hand side".  It is used to save typing.  Suppose  the
current line contained

   Now is the time

-------------------------------- Page 17 --------------------------------

and we wanted to  put parentheses around  it.  We could  just retype  the
line, but this is tedious.  Or we could say

   s/^/(/
   s/$/)/

using our knowledge of "^" and "$".  But the easiest way uses the "&":

   s/.*/(&)/

This says "match the whole line, and  replace it by itself surrounded  by
parens." The "&" can be used several times in a line; consider using

   s/.*/&?  &!!/

to produce

   Now is the time?  Now is the time!!


We don't have to match the whole line, of course: if the buffer contains

   the end of the world

we could type

   /world/s//& is at hand/

to produce

   the end of the world is at hand

Observe this expression carefully, for it illustrates how to take  advan-
tage of ned to save typing.  The string "/world/" found the desired line;
the shorthand "//" found the same word in the line; and the "&" saved  us
from typing it again.

The "&" is a special character only within the replacement text of a sub-
stitute command, and has no  special meaning elsewhere.  We can turn  off
the special meaning of "&" by preceding it with a "\":

   s/ampersand/\&/

will convert the  word "ampersand"  into the  literal symbol  "&" in  the
current line.

-------------------------------- Page 18 --------------------------------

26.   ADVANCED FEATURES

Ned has several  screen formats  which it can  use to  display the  data.
Enter a  "D" on  the primary  command line.   Next, enter  a "D=".   This
causes ned to give you the display  number.  Now enter "D1".  This  tells
ned to go to display 1.  If you don't give ned a number, it cycles to the
next screen in numeric order.

Enter "p"  on the  primary  command line.   This  gives you  the  PF  key
display.  You may change the contents of any PF key  either by typing the
new contents directly on the screen, or by giving the primary command  "p
n contents", where n is the pf key number.  Notice  that the default con-
tents of the PF 1 key are ";H" This means the primary  "H".  The  default
contents of PF 9 are  "j".  This is the line command "j" which joins  the
lines.  In general, the contents of a PF key  may consist of a line  com-
mand, followed by a semicolon, followed by one or more  primary commands,
separated by semicolons.  For  example, change  the contents of  PF 1  to
"a".  Then get out of the PF key display (by typing enter).  Now move the
cursor down a few lines and hit the PF 1  key.  Notice the line that  was
added.  The action  is exactly as though  you had entered  an "a" in  the
line command area for the line the cursor was on.

If you find that you always want to start ned with certain commands,  for
example to use a  different display or  set some pf keys to  non-standard
values, you can do this with a profile file.  This file may contain  pri-
mary commands, on  separate lines,  which are to  be executed before  the
first display is generated.  Ned will  search for the profile file  first
in the current directory  under the name  ".ned", then in  $HOME/.../ned.
Normally you would want to have just one file, in your $HOME/...   direc-
tory.
