Return to ted.hlp CVS log

Up to [CSRG BSD Unix] / 43BSDTahoe / new / X / src / usr / clu

Annotation of 43BSDTahoe/new/X/src/usr/clu/ted.hlp, revision 1.1

1.1     ! root        1: **** Menu for TED help ****
        !             2: A: Introduction                                L: Multiple buffers
        !             3: B: Characters                          M: Multiple windows
        !             4: C: Short examples                      N: Incremental search
        !             5: D: Keypad and function keys            O: Macros
        !             6: E: Moving the cursor                   P: Pattern matching
        !             7: F: Moving and deleting text            Q: Pattern matching summary
        !             8: G: Searching                           R: Sorting
        !             9: H: Init files                          S: Miscellaneous options
        !            10: I: Running programs                    T: TED variables
        !            11: J: Adjusting text                      U: Indenter variables
        !            12: K: Multi-file buffers                  V: File names/backup/protection
        !            13:                                        X: XTED features
        !            14: **** Menu for TED help ****
        !            15: 
        !            16: **** Introduction ****
        !            17: TED  is         a  real-time  editor written in CLU.  It was inspired by the real-time
        !            18: TECO developed at MIT. TED will work with just  about  any  display  terminal.
        !            19: (However,  TED seems to push terminals harder than Emacs, so you may find that
        !            20: /etc/termcap does not specify enough padding  for  scrolling  or  insert/delete
        !            21: line.)  Originally written by Russ Atkinson, TED has been extensively modified
        !            22: by Bob Scheifler (RWS) and  Eliot  Moss         (EBM)  at  MIT-XX,  and  is  currently
        !            23: maintained by Bob Scheifler.
        !            24: 
        !            25: To start a TED, just type
        !            26:        ted
        !            27: at  CSH         level.  TED will start up, clear the screen, and indicate that you are
        !            28: using the Main buffer. If you want to edit  an  existing  file  (or  group  of
        !            29: files), type
        !            30:        ted filespec
        !            31: or
        !            32:        ted filespec ... filespec
        !            33: Filespecs can only be given the first time you start up a TED.
        !            34: 
        !            35: To  get         out of TED and back to CSH temporarily, type ^C.  To continue TED from
        !            36: CSH, use the FG command.  To get out of TED permanently, type ^U0^C.
        !            37: 
        !            38: TED is intended to manipulate ASCII text files.          Files  can  be  copied  to  a
        !            39: buffer;         the  buffer  can  be changed by commands; and the buffer can be copied
        !            40: back to files, possibly many times.
        !            41: 
        !            42: While editing the buffer, a cursor  is kept  and  displayed  to  indicate  the
        !            43: current position in the buffer.         Common actions include inserting characters at
        !            44: the  cursor,  deleting characters  at  the cursor, and moving the cursor.  TED
        !            45: attempts to display a portion of the buffer around the cursor to show the  user
        !            46: the  text  being  edited.    The  displayed portion of the buffer is called the
        !            47: window.
        !            48: 
        !            49: Most characters typed are normally self-inserting.  That is, as         the  character
        !            50: is  typed it is immediately inserted into the buffer and the display is changed
        !            51: to show the insertion. All control characters (except ^M)  are  commands  that
        !            52: change the  current  position,  change  the  buffer,  or have more complicated
        !            53: effects.  For example, control-N (usually written as ^N) causes the  cursor  to
        !            54: move  to  the  start  of  the next line.  Control characters can be inserted by
        !            55: typing ^Q before typing the control character.
        !            56: 
        !            57: Commands that take numeric arguments (the numeric argument is indicated         by  #)
        !            58: usually have their numeric arguments set by the ^U command.  ^U may be followed
        !            59: by  a  signed number to explicitly specify the argument.  If ^U is not followed
        !            60: by a signed number then # becomes the previous # * 4.  The default for # is  1.
        !            61: A  lone         minus  sign  is  equivalent  to -1.  As the number is typed it will be
        !            62: displayed at the top of the screen.  A number is  terminated  by  a  non-digit.
        !            63: Most  simple  commands,         and all self-inserting characters, will take a numeric
        !            64: argument.  For example, ^U10_ will cause ten underscores to  be         inserted,  and
        !            65: ^U^N  will  cause  the cursor to move down four lines.  For some commands, the
        !            66: exact value of the numeric argument is not important, but whether it is greater
        !            67: than one, or less than zero, or some similar condition.         For example,  ^A  will
        !            68: move  the  cursor to the start, but ^U^A (in fact, any numeric argument greater
        !            69: than one) will move the cursor to the start of the buffer.
        !            70: 
        !            71: Some commands require string or file name arguments, and will request  them  at
        !            72: the  bottom  of         the screen.  String arguments and file names are terminated by
        !            73: carriage return, with most control characters  having  normal  editing effects
        !            74: while  typing  in  arguments.   To  insert a newline into the argument, type a
        !            75: linefeed.  A default string or file name is usually  supplied, which  will  be
        !            76: used  if  no  argument is  typed.    ^R replaces the current argument with the
        !            77: default, ^U^R inserts the default before the cursor, ^U-^R inserts the default
        !            78: after  the  cursor,  ^W         replaces  the  default with the current argument, ^U^W
        !            79: deletes the default, and ^G quits from the command.
        !            80: 
        !            81: For file name arguments, the default is used to fill in any  missing  parts  of
        !            82: the  file  name(s).  A file name is considered to consist of four components in
        !            83: the form "dir/name.suffix.other", where         the  name  and  suffix  parts  do  not
        !            84: contain         periods.    The  defaults are always used when modifying a file.  When
        !            85: reading a file, first all of the defaults are tried, then  just         the  directory
        !            86: default,  then all  but  the  directory default, and finally with no defaults.
        !            87: Empty or relative directory fields are completed from the connected  directory,
        !            88: which  is  settable  via  ^\W. The last string or file name argument is always
        !            89: remembered, and can be inserted at any time via ^VG.  For example, if  you  try
        !            90: to  read  in  a file, but misspell its name, you can save typing the whole name
        !            91: again by typing ^R^VG. Similarly, in the ^Z command, if the replace string  is
        !            92: similar         to  the search string, you can use ^VG in typing the replace string to
        !            93: insert the search string.
        !            94: 
        !            95: Some commands require a 1-character option (preceded  by  an  optional numeric
        !            96: argument).  Examples of these are ^V, ^X, ^\, ^], and ^_.  The optional numeric
        !            97: argument  defaults  to 1 where applicable, and has an optional minus sign.  The
        !            98: actual numeric argument used will be the implicit argument  (from  a  preceding
        !            99: ^U)  times any explicit argument given after the option.  ^G will quit from the
        !           100: option, ^L will re-display, and ? will type help for the options.  The case  of
        !           101: the option character does not matter.
        !           102: 
        !           103: Some  commands require a Yes/No confirmation.  A question will be displayed at
        !           104: the top of the screen, to be answered by typing Y or N (case  is  unimportant).
        !           105: ^G can also be typed to abort the command, so that no action is taken.
        !           106: 
        !           107: Long  lines  are  not  displayed on multiple lines of the screen.  If a line is
        !           108: longer than the width of the screen, TED will display an exclamation  mark  (!)
        !           109: in the last column to indicate that the line is too long to display completely.
        !           110: ^V! can be used to (find and) display more of a long line.
        !           111: 
        !           112: Every  so  often  the buffer is saved to the file "_ted.sav.#" (where # is your
        !           113: process id) in your login directory if the buffer has been changed.    This  is
        !           114: intended to allow recovery from system crashes.         In addition, if TED receives a
        !           115: SIGHUP signal,  a  save  will  be  performed  if  the buffer has been changed.
        !           116: However, it is still  a         good  idea  to  periodically  write  out  your  buffer
        !           117: manually.  The ^U-^H command can be used to turn saving on or off.
        !           118: 
        !           119: Suppose         that  you want to create a text file from scratch.  When TED starts up
        !           120: you have an empty buffer.  To insert normal text into the buffer, just type  as
        !           121: you  would  on a  typewriter.  The delete key (usually represented here as ^?)
        !           122: will allow you to undo minor errors quickly.  Then, to save the results of your
        !           123: typing, use the ^W command to write the buffer to a file.  For a new  file  you
        !           124: must give a file name in order to save your work.
        !           125: 
        !           126: If  you want to edit an old file, use the ^R command to read it into the buffer
        !           127: (the old contents of the buffer will be deleted).  To insert  (at  the cursor)
        !           128: the  text of a file into the text of the existing buffer, use the ^U^R command.
        !           129: To find a place that you want to change, you can search for text (using the  ^S
        !           130: command)  that precedes  the  place  you want changed.  Then you can use ^D to
        !           131: delete characters, or ^K to kill entire lines, and  insert  the         correct  text.
        !           132: Again, to  save  the  results of your editing, use the ^W command to write the
        !           133: buffer to a file.  If you do not give a file name in this case, the ^W command
        !           134: will  write  out  a  new version of the file.  To append the text of the buffer
        !           135: onto the end of an existing file, use the ^U^W command.
        !           136: 
        !           137: The best way to learn TED is to start a TED up and practice manipulating  text.
        !           138: Experimenting  is  encouraged, since you can see the effects of most characters
        !           139: directly on the screen.         TED has a built-in help command, ^H, which allows  you
        !           140: to view pieces of this file by selecting from a simple menu.
        !           141: **** Introduction ****
        !           142: 
        !           143: **** Characters ****
        !           144: Char:  Effect: (# is a numeric arg (default 1), % is a string arg)
        !           145: 
        !           146: ^@     (#=1: escape to shell, #=0: terminate to shell, else: garbage collect)
        !           147: ^A     go to start of line (#>1: go to start of buffer)
        !           148: ^B     move back # chars
        !           149: ^C     (#=1: escape to shell, #=0: terminate to shell, else: garbage collect)
        !           150: ^D     delete # chars forward
        !           151: ^E     go to end of line (#>1: go to end of buffer)
        !           152: ^F     move forward # chars
        !           153: ^G     quit from numeric/string argument or subcommand option
        !           154: ^H     help command (#<0: toggle buffer saving,
        !           155:                      #=0: flush help buffers,
        !           156:                      #=1: TED help,
        !           157:                      #>1: User-defined help)
        !           158: ^I     (TAB) insert # tabs
        !           159: ^J     (LF) run/continue interactive inferior (#>1: kill inferior)
        !           160: ^K     kill # lines (#=0: kill to end of line, #=-1: kill to start of line)
        !           161: ^L     clear screen & redisplay (#<1: redisplay, #>1: save buffer(s))
        !           162: ^M     (CR) insert # newlines before cursor (terminates %)
        !           163: ^N     move down # lines
        !           164: ^O     insert # newlines after cursor
        !           165: ^P     move up # lines
        !           166: ^Q     insert next char typed # times
        !           167: ^R     read file(s) from % (#<1: insert new file(s),
        !           168:                             #=1: discard current file(s) and read new file(s),
        !           169:                             #>1: insert text of file(s))
        !           170: ^S     search for % # times (#<0: search backwards, #=0: set case mode)
        !           171: ^T     set the mark at current cursor (#>1: swap mark & cursor)
        !           172: ^U     multiply # by number (default 4)
        !           173: ^V     text/cursor mover/saver
        !           174: ^W     write file(s) (#<0: write changed files of current buffer,
        !           175:                       #=0: write current file if changed,
        !           176:                       #=1: write current file to %,
        !           177:                       #>1: append current file onto %)
        !           178: ^X     multiple buffers/windows, move by indent/region/list, pattern search,
        !           179:          macros, mail check, restrict buffer, draw, box, set modes/variables
        !           180: ^Y     ^Y^@c or ^U0^Yc to define macro for char 'c', ^Yc to execute
        !           181: ^Z     replace %1 by %2 in rest of current file (#>1: rest of buffer)
        !           182: ^[     (ESC) escape for VT52 and Heath function and alternate keypad keys
        !           183: ^\     compile, indent, format, mail
        !           184: ^]     adjust lines/marked-text/paragraph/comments
        !           185: ^^     edit/scan/type/list matching files
        !           186: ^_     delete/link/change-mode/rename files
        !           187: ^?     (DEL) delete # chars backwards (usually can't be typed as CTRL-?)
        !           188: other  chars insert themselves # times before cursor (#<0: after cursor)
        !           189: **** Characters ****
        !           190: 
        !           191: **** Short examples ****
        !           192: ('$' stands for carriage-return)
        !           193: 
        !           194: User types:    Effect:
        !           195: 
        !           196: ABC            Insert "ABC" at cursor, move cursor over 3 characters.
        !           197: ^Rfoo.clu$     Read the file foo.clu to the buffer, place cursor at buffer
        !           198:                start, display the current window.
        !           199: ^Wfoo.clu$     Write the buffer to the file foo.clu, no change to the cursor.
        !           200: ^W$            Write buffer to current file.
        !           201: ^U^F           Move cursor 4 characters forward.
        !           202: ^U56^N         Move cursor 56 lines forward.
        !           203: ^U^V3F         Move cursor 12 words forward.
        !           204: ^A             Move cursor to line start.
        !           205: ^U^A           Move cursor to buffer start.
        !           206: ^E             Move cursor to line end.
        !           207: ^U^E           Move cursor to buffer end.
        !           208: ^Siter$                Search forward for "iter" 1 time.  Sets default to "iter".
        !           209: ^U-^S$         Search backward 1 time for the default.
        !           210: **** Short examples ****
        !           211: 
        !           212: **** Keypad and function keys ****
        !           213: On  VT52's, Heath's, and many other terminals the alternate keypad and function
        !           214: keys can be used.  Their corresponding escape  sequences  can  also  by  typed
        !           215: explicitly.  (The keys listed below are for Heath's in shifted keypad mode.)
        !           216: 
        !           217: Key:   Seq:     Meaning:
        !           218: 
        !           219:        esc esc  redefine escape sequence (see below)
        !           220: 7      esc @    move to end of # previous word (^V[)
        !           221: 8,UP   esc A    move backward # pages (^V^P)
        !           222: 2,DOWN esc B    move forward # pages (^V^N)
        !           223: 6,RIGHT esc C   move forward # words (^V^F)
        !           224: 4,LEFT esc D    move backward # words (^V^B)
        !           225: 5,HOME esc H    enter alternate keypad mode
        !           226: ERASE  esc J    pattern search # times for default (^X^P^M)
        !           227: 1      esc L    delete backward to end of # previous word (^V<)
        !           228: 3      esc M    delete forward to start of # next word (^V>)
        !           229: 9      esc N    move to start of # next word (^V])
        !           230: BLUE   esc P    delete # words forward (^V^D)
        !           231: RED    esc Q    delete # words backwards (^V^?)
        !           232: GREY   esc R    string search forward # times for default (^S^M)
        !           233: f1     esc S    string search backward # times for default (^U-^S^M)
        !           234: f2     esc T    set case mode for searches (^U0^S)
        !           235: f3     esc U    scroll window up # lines (^V-^J)
        !           236: f4     esc V    scroll window down # lines (^V^J)
        !           237: f5     esc W    reposition window at cursor (^U0^L)
        !           238:        esc ? ?  print help
        !           239: ENTER  esc ? M  garbage collect address space (^U^C)
        !           240: .      esc ? n  exit to CSH (^C)
        !           241: 0      esc ? p  search backward # times for default (^U-^S^M)
        !           242:        esc ? q  delete backward to end of # previous word (^V<)
        !           243:        esc ? r  move forward # pages (^V^N)
        !           244:        esc ? s  delete forward to start of # next word (^V>)
        !           245:        esc ? t  move backward # words (^V^B)
        !           246: shft 5 esc ? u  exit alternate keypad mode (when in alternate keypad mode)
        !           247:        esc ? v  move forward # words (^V^F)
        !           248:        esc ? w  move to end of # previous word (^V[)
        !           249:        esc ? x  move backward # pages (^V^P)
        !           250:        esc ? y  move to start of # next word (^V])
        !           251: 
        !           252: The  sequences "esc [ char"  and  "esc O char"  are  interpreted  the  same as
        !           253: "esc ? char" when "char" is a lowercase letter, and otherwise  are  interpreted
        !           254: the same as "esc char".
        !           255: 
        !           256: It  is also possible to redefine any escape sequence (and hence any function or
        !           257: keypad key), to execute an arbitrary string.  The string is executed just  like
        !           258: a  macro  definition,  and  has         basically  the same effect as if you typed the
        !           259: characters of the string directly on the keyboard.  An escape sequence can  be
        !           260: "undefined" back to its original meaning by defining it to the empty string.
        !           261: 
        !           262:        esc esc char            to redefine     esc char
        !           263:        esc esc ? char          to redefine     esc ? char
        !           264: 
        !           265: Note  that a function or keypad key can be redefined by typing ESC and then the
        !           266: function or keypad key.
        !           267: 
        !           268: Sequences which are "equivalent" to ^V deletion         commands  are  not  completely
        !           269: equivalent,  in         that  they  do  not save the deleted text in the implicit kill
        !           270: area.  If saving is important, these sequences can be redefined         to  explicitly
        !           271: execute the appropriate ^V command.
        !           272: **** Keypad and function keys ****
        !           273: 
        !           274: **** Moving the cursor ****
        !           275: There  are many commands for moving the cursor around, almost all of which take
        !           276: a numeric argument as a repetition count:
        !           277: 
        !           278: ^U^A   moves to the start of the buffer
        !           279: ^U^E   moves to the end of the buffer
        !           280: ^A     moves to the start of the current line
        !           281: ^B     moves to the previous character, wrapping to end of previous line
        !           282: ^E     moves to the end of the current line
        !           283: ^F     moves to the next character, wrapping to start of next line
        !           284: ^N     moves to the start of the next line
        !           285: ^P     moves to the start of the previous line
        !           286: ^V^B   moves to the start of the previous word
        !           287: ^V^F   moves to the end of the next word
        !           288: ^V]    moves to the start of the next word
        !           289: ^V[    moves to the end of the previous word
        !           290: ^Vspace skips forward over blanks
        !           291: ^V#L   moves to line #
        !           292: ^V^N   moves to the next screenful of text
        !           293: ^V^P   moves to the previous screenful of text
        !           294: ^V!    moves to the next (or current) line which extends off the screen
        !           295: ^X^B^P moves to the previous start of paragraph
        !           296: ^X^E^P moves to the next end of paragraph
        !           297: ^X^F^P moves to the next start of paragraph
        !           298: ^X^B^S moves to the previous start of sentence
        !           299: ^X^E^S moves to the next end of sentence
        !           300: ^X^F^S moves to the next start of sentence
        !           301: 
        !           302: Normally, paragraphs are separated by "formatter" lines.  Formatter  lines  are
        !           303: blank  lines, and any lines starting with a character in the "no_fill_starters"
        !           304: string variable.  This variable contains period and single  quote  by  default,
        !           305: for  R20  text formatter command lines.  It is also often useful to consider a
        !           306: new paragraph to start at every line with leading spaces or tabs.  This can  be
        !           307: obtained  by  setting  the "pindent" number variable to a non-zero value (it is
        !           308: zero by default).
        !           309: 
        !           310: A sentence is terminated by a period,  exclamation  point,  or question  mark,
        !           311: optionally followed by a single quote, double quote, or right "bracket" (round,
        !           312: square, curly, or angle), followed by a newline, a tab, two spaces, a space and
        !           313: a tab, or a space and a newline.  Formatter lines also separate sentences.
        !           314: 
        !           315: A  word         consists  of  letters and digits, plus certain special characters.  By
        !           316: default, the only special character is underscore.  You can  specify  what  the
        !           317: special characters are by changing the "word_chars" string variable.
        !           318: 
        !           319: The  following commands  move  the  cursor based on the indentation (amount of
        !           320: leading space consumed by spaces and tabs) of lines in the buffer.   These  are
        !           321: particularly  useful  in  moving around in (reasonably formatted) CLU and Argus
        !           322: code, but are useful for other languages and documents as well.         Most  move  by
        !           323: comparing  the indentation of previous or following lines with the indentation
        !           324: of the current line, and most take a numeric argument as a repetition count:
        !           325: 
        !           326: ^X^I^B moves back to the next line with a different indentation
        !           327: ^X^I^D moves to the next line with a greater indentation, provided
        !           328:        no line with a lesser indentation intervenes
        !           329: ^X^I^E moves to the next line with a lesser indentation
        !           330: ^X^I^F moves to the next line with a different indentation
        !           331: ^X^I^H moves back to the next line with a greater indentation, provided
        !           332:        no line with a lesser indentation intervenes
        !           333: ^X^I^N moves to the next line with the same indentation, provided
        !           334:        no line with a lesser indentation intervenes
        !           335: ^X^I^P moves back to the next line with the same indentation, provided
        !           336:        no line with a lesser indentation intervenes
        !           337: ^X^I^U moves back to the next line with a lesser indentation
        !           338: ^X^I#^S moves to the next line indented # spaces
        !           339: ^X^I#^^ moves back to the next line indented # spaces
        !           340: 
        !           341: The following commands move the cursor based on nested "list" structure,  i.e.,
        !           342: based  on  nested matching ()'s, []'s, {}'s, and <>'s, ignoring the contents of
        !           343: string and character literals. The string variable "list_chars" should be some
        !           344: subset of the characters (), [], {}, <>, ", and ', and defines the active  list
        !           345: and literal delimiters, with the default being all but <>.
        !           346: 
        !           347: ^X^Z^A moves backward up # list levels
        !           348: ^X^Z^B moves backward over # lists at the current nesting level
        !           349: ^X^Z^D moves (#>0: forward, #<0: backward) down # list levels
        !           350: ^X^Z^E moves forward up # list levels
        !           351: ^X^Z^F moves forward over # lists at the current nesting level
        !           352: ^X^Z^N moves forward up and down (^X^Z^E^X^Z^D) # times
        !           353: ^X^Z^P moves backward up and down (^X^Z^A^X^Z-^D) # times
        !           354: **** Moving the cursor ****
        !           355: 
        !           356: **** Moving and deleting text ****
        !           357: The following commands delete text, and take a numeric argument as a repetition
        !           358: count:
        !           359: 
        !           360: ^D     deletes the next character
        !           361: ^?     (DEL) deletes the previous character
        !           362: ^K     deletes to the start of the next line
        !           363: ^VK    deletes the text between the mark and the cursor
        !           364: ^V^D   deletes to the end of the next word
        !           365: ^V^?   deletes to the start of the previous word
        !           366: ^V^@   deletes blanks from the cursor forward
        !           367: ^V>    deletes to the start of the next word
        !           368: ^V<    deletes to the end of the previous word
        !           369: 
        !           370: ^D and ^? do not save the deleted text, but the others do.  The text deleted by
        !           371: the  last  such command, or by the last sequence of ^K commands, is retained in
        !           372: an invisible kill area, and can be reinserted anywhere by moving the cursor  to
        !           373: the  point  of insertion and typing ^V^R (to insert after the cursor) or ^V-^R
        !           374: (to insert before the cursor). This is a simple way of moving text.
        !           375: 
        !           376: ^V^Z deletes all lines in the buffer.
        !           377: 
        !           378: Moving text from one portion of the buffer to  another can  also  be  done  by
        !           379: copying         the  text  from where it is to an invisible save area using one of the
        !           380: text-saving options of the ^V command, moving  the  cursor  to  the  point  of
        !           381: insertion,  and         typing  ^V^I  (to insert after the cursor) or ^V-^I (to insert
        !           382: before the cursor).  The text-saving commands are:
        !           383: 
        !           384: ^V#C   saves the next # words following the cursor
        !           385: ^V#^S  saves the next # lines following the cursor
        !           386: ^VS    saves the text between the mark and the cursor
        !           387: ^V#^W  saves and deletes the next # lines following the cursor
        !           388: ^VW    saves and deletes the text between the mark and the cursor
        !           389: 
        !           390: The ^T command is used to set an invisible  mark  in  the  buffer,  which  will
        !           391: remain there  until  a  subsequent  ^T  command  moves  it,  or a ^U^T command
        !           392: exchanges it with the cursor.
        !           393: 
        !           394: Note that, as with the kill area, there is only one save area for ^V  commands,
        !           395: so  that  the  second  time a text-saving command is used the text saved by the
        !           396: first command will no longer be in the save area.  The ^V^R and ^V^I  commands,
        !           397: however,  can  be  used         to insert the same text as many times as desired in as
        !           398: many places as desired.
        !           399: 
        !           400: Multiple named save/kill areas can be obtained with multiple buffers commands.
        !           401: **** Moving and deleting text ****
        !           402: 
        !           403: **** Searching ****
        !           404: Simple string  searching  is  performed with the ^S command.  Searching can be
        !           405: done either forwards or backwards, depending on         the  numeric  argument.    For
        !           406: example, ^U5^S will search forward for the fifth occurrence of some string, and
        !           407: ^U-^S  will  search  backwards for  the  first  occurrence.   A newline can be
        !           408: included  in  the  search  string  by  typing  linefeed.     Upper/lower   case
        !           409: distinctions  normally make a difference when searching, but can be ignored by
        !           410: setting a flag with the ^U0^S  command.           This  flag  controls  all  searching
        !           411: commands, not just ^S.
        !           412: 
        !           413: Changing  all (or some) occurrences of some string to another string is done by
        !           414: the ^Z command.         It will ask for the text string to change, and the  string  to
        !           415: change it to.  Then for each occurrence of the search string you can type Y to
        !           416: change it to the default, or N to  avoid  changing  it,         or  U  to  update  all
        !           417: remaining  occurrences to  the default.  There are many other options as well.
        !           418: At the end, you can either install the changes or leave the buffer  as it  was
        !           419: originally.
        !           420: 
        !           421: Various         options  of  the  ^^  command  allow you to peruse or search a list of
        !           422: files. The list is just like that for ^R when making a multi-file buffer.  ^^T
        !           423: simply displays the files one at a time, with commands for  moving  by  pages,
        !           424: searching, editing, and moving to the next or previous file.  ^^S only displays
        !           425: those  files  containing  a  particular         string.  ^^P only displays those files
        !           426: containing a particular pattern.  ^^R reads all of the files into  a  temporary
        !           427: recursive  editing buffer.  ^^L simply lists the names of the files, and allows
        !           428: you to select a particular one at a time for editing by placing the  cursor  on
        !           429: the  name  of a file and typing ^R.  Typing ^R on a directory file will cause a
        !           430: recursive ^^L. ^^I simply inserts the names of  the  files  into  the  current
        !           431: buffer.
        !           432: 
        !           433: There  are  also incremental searching modes and pattern matching search modes,
        !           434: described separately.
        !           435: **** Searching ****
        !           436: 
        !           437: **** Init files ****
        !           438: TED  executes the file ".ted_init" in your login directory when it first starts
        !           439: up.  That is, it executes the characters in ".ted_init" just as         if  you  typed
        !           440: them  at  the  keyboard.  This allows you to set up various options any way you
        !           441: want automatically.
        !           442: 
        !           443: A typical ".ted_init" might be:
        !           444: 
        !           445: ^X^SS^X^KS^V25%^]64W^]64B
        !           446: 
        !           447: This particular example turns on incremental search mode and alternate ^K mode,
        !           448: forces the last screenful of a file  to         display  25%  blank  (it  is  normally
        !           449: displayed 70% blank), sets the paragraph fill width to 64 characters, and turns
        !           450: on auto-break mode by setting the break limit at 64 characters.
        !           451: 
        !           452: For  readability,  your         ".ted_init" can be split into several lines.  Newlines
        !           453: are discarded, except that a blank line is converted to ^J.  Hence, a  ^J  must
        !           454: be represented by two ^J's.
        !           455: 
        !           456: Note  that  these files must contain all of the ^Q's you would normally have to
        !           457: type to get control characters into string arguments such as macro  bodies  and
        !           458: search patterns.  For example, to define ^Y^L to be ^U-^L, a file would have to
        !           459: contain the following:
        !           460: 
        !           461: ^Y^@^L^Q^U-^Q^L^M
        !           462: **** Init files ****
        !           463: 
        !           464: **** Running programs ****
        !           465: The  ^J         command allows the user to run programs interactively from TED without
        !           466: leaving the editor environment, so that TED can be used like a primitive shell.
        !           467: The ^J command asks for a program name, and if there is currently  no  inferior
        !           468: for the program, asks for a command line and then starts the program.  If there
        !           469: is an inferior for the program, the inferior is continued.  The default program
        !           470: name is the most recently stopped inferior.  If there are no stopped inferiors,
        !           471: the  value  of the  string variable "default_fork" is used, with default value
        !           472: "debug".  The ^U^J command  can         be  used  to  kill  an  inferior  that  cannot
        !           473: otherwise be terminated.
        !           474: 
        !           475: If the "pause" number variable is non-zero, TED will not clear the screen after
        !           476: an  inferior  terminates  until         the next command is typed.  This allows you to
        !           477: look over the output of inferiors that you do not actually interact with.
        !           478: 
        !           479: The ^\ command also allows the user to run certain kinds of programs  from  TED
        !           480: without         leaving the editor environment.  The options of this command provide a
        !           481: simple interface to allow the user to do the following:
        !           482: 
        !           483:        I,Q:             Indent current file.
        !           484:        C,H,J,K,O,U:     Compile files.
        !           485:        D,L,P,R,V,X:     Format current file using R20.
        !           486:        E:               Format current file using Scribe.
        !           487:        M:               Makefile.
        !           488:        S:               Send contents of current file as mail.
        !           489:        Y:               Run arbitrary program with the contents of
        !           490:                         the current file as input.
        !           491:        Z:               Run arbitrary program with the name of
        !           492:                         the current file as JCL, or with arbitrary JCL.
        !           493:        A,B:             Type or insert the last report from the above.
        !           494:        W:               Change working directory.
        !           495: 
        !           496: Many of the options run separate programs.  While a separate program is running
        !           497: TED prints the amount of real time that has elapsed.  A ^G  typed  at  TED  can
        !           498: abort a runaway program (the user will be asked for definite confirmation).  In
        !           499: general,  before  running  a  separate program,  if  the current file has been
        !           500: changed since it was last read or  written,  then  the file  is  automatically
        !           501: written         to  a  new  version.    After  executing  an  option,  any results are
        !           502: automatically displayed.    These  results  are         retained  in  a  buffer  named
        !           503: "Result",  and may  be  redisplayed later with the A option or inserted in the
        !           504: current buffer with the B option.  If the results contain errors keyed by  line
        !           505: number, you can move to a particular line with the ^V#L command.
        !           506: 
        !           507: The  CLU/Argus indenter operates either on the whole file (the I option) or on
        !           508: the text starting to the right of the current cursor (the Q option), performing
        !           509: fairly complete syntax checking of programs as well  as         attempting  to  indent
        !           510: code  attractively.    Errors  are  reported as if a separate program were run,
        !           511: although a separate program is not run.         The Q option will indent  a  specified
        !           512: number of textual "units", where a unit is basically a module, routine, equate,
        !           513: statement, expression list, or expression.  The text to the right of the cursor
        !           514: should start such a unit.  The indentation of the current line is assumed to be
        !           515: correct; it is not derived from context.  Indentation is controlled by a number
        !           516: of variables, settable via ^XI.
        !           517: 
        !           518: The  CLU  or  Argus  compiler  can  be run  as  an inferior process to compile
        !           519: programs.  The most common usage (the C         option)  is  to  compile  the  current
        !           520: buffer contents, first writing them out if the buffer has been changed since it
        !           521: was  last  read         or  written.  The O option is like C, but causes an optimizing
        !           522: compilation.  The U option will write out all changed files and         then  run  the
        !           523: compiler  on just those, all files, or all files with out-of-date binary files,
        !           524: or files with out-of-date binaries from a specified list.  There are  a         number
        !           525: of  options  under  the         U  option  to  specify  the  compilation  mode (normal
        !           526: compilation, optimization, type-check, etc.)  Explicit compiler commands can be
        !           527: passed to the compiler via the J option.  Giving a zero         argument  with  the  J
        !           528: option prevents  the  current  file  from  being written out.  For the C and O
        !           529: options, the suffix must be "clu" (or "arg"), "equ",  "xfile", "spc",  or  "";
        !           530: these  cause  COMPILE,  CE,  XFILE,  SPECS,  and  COMPILE  compiler  commands,
        !           531: respectively.  The K option either keeps or kills a compiler.  If the  compiler
        !           532: is  kept, the type-checking will usually be more complete.  The compiler should
        !           533: generally be kept while compiling files from the same program.   When  finding
        !           534: out-of-date binaries, the default suffix "bin", although this can be controlled
        !           535: with  the  "binary_suffix"  variable;  the  default  directory is  the  source
        !           536: directory, but this can be controlled with the "binary_dir" variable, which can
        !           537: specify a directory relative to the source directory.  The N option can be used
        !           538: to change the name of the compiler.
        !           539: 
        !           540: The text formatter "R" can be used to format the current file in six ways.  The
        !           541: D option formats it for the DIABLO, the         L  option  formats  it  for  the  line
        !           542: printer,  the  P  option produces PRESS format, the X option formats it for the
        !           543: XGP, the V options formats it for the Varian, and the R option allows the  user
        !           544: to  give  explicit commands.  Giving a zero argument with the R option prevents
        !           545: the current file from being written out.  The name of the program R is defined
        !           546: by  the         string  variable  "r_name",  default  value "r".  The program name can
        !           547: contain a directory  specification.    In  addition,  "r_name" can  specify  a
        !           548: constant  prefix  to  be  added         to  the command line, by appending the prefix,
        !           549: separated by a space, to the program name.
        !           550: 
        !           551: The E option can be used to run the text formatter "Scribe".  The name of  the
        !           552: program         Scribe  is defined by the string variable "scribe_name", default value
        !           553: "scribe".  The program name can contain a directory specification.
        !           554: 
        !           555: The M option can be used to execute a "make" command.
        !           556: 
        !           557: TED can be used to compose and send mail.  Just type the text  of  the message
        !           558: into  the  buffer, and then use ^\S.  If you want a subject heading, just start
        !           559: the first line of the message with "Subject: ".         You will be prompted  for  the
        !           560: addresses  to  send the message to.  The name of the mail program is defined by
        !           561: the string  variable  "mail_name",  default  value  "/usr/lib/sendmail".    The
        !           562: program         name  can contain a directory specification.  In addition, "mail_name"
        !           563: can specify a constant prefix to be added to the command line, by appending the
        !           564: prefix, separated by a space, to the program name.
        !           565: 
        !           566: An (almost) arbitrary program can be run with the name of the current  file  as
        !           567: JCL  (but with no primary input) via the Z option.  The program can be run with
        !           568: arbitrary JCL via ^\0Z.         The name of the  program  is  defined  by  the  string
        !           569: variable "progz_name". The program name can contain a directory specification.
        !           570: In  addition,  "progz_name"  can  specify  a constant prefix to be added to the
        !           571: command line, by appending the prefix, separated by a  space,  to  the program
        !           572: name.
        !           573: 
        !           574: An (almost) arbitrary program can be run with arbitrary JCL and the contents of
        !           575: the current file as primary input via the Y option.  The name of the program is
        !           576: defined         by  the  string variable "progy_name".  The program name can contain a
        !           577: directory specification.  In addition, "progy_name"  can  specify  a  constant
        !           578: prefix to be added to the command line, by appending the prefix, separated by a
        !           579: space, to  the program name.  Beware that a single process is sending input to
        !           580: the program and collecting output, so it is possible to deadlock.
        !           581: **** Running programs ****
        !           582: 
        !           583: **** Adjusting text ****
        !           584: Text can be adjusted simply in TED using the ^] command.  The user can adjust a
        !           585: marked region of text (M), a region of comments (contiguous lines with the same
        !           586: initial         non-blank  character)  (C), a paragraph (P), or a region of the next N
        !           587: lines (N).  In addition, the width to use when adjusting can be set (by default
        !           588: it is 64) (W). The text is justified "ragged right" by  default,  in  that  no
        !           589: extra  spaces are inserted to align the text on the right margin.  However, the
        !           590: justification mode can be changed to insert extra spaces to produce  even  left
        !           591: and  right margins (J).         Formatter lines (blank lines and lines starting with a
        !           592: character in the "no_fill_starters" string  variable)  will  not  be  adjusted.
        !           593: Paragraph  justification  works only on non-indented paragraphs, i.e., only the
        !           594: first line of the paragraph may contain leading spaces or tabs.
        !           595: 
        !           596: Text (or comments) may also be justified as it is  being  entered.    This  is
        !           597: auto-break mode, and may be set by specifying a width to break at when entering
        !           598: text (B).  A fill prefix may also be specified (A).
        !           599: 
        !           600: The  marked  text  can be left (L), right (R), or center (E) justified within a
        !           601: fixed width field.  The absolute value of the numeric  argument         specifies  the
        !           602: field  width.   When right or center justifying multiple lines, or when center
        !           603: justifying the end of a single line, the field will not be padded  out on  the
        !           604: right with spaces unless a negative argument is specified.
        !           605: 
        !           606: There  is  also an auto-indent mode (I), in which typing carriage return causes
        !           607: blank space, equal in width to the leading blank space of the current line,  to
        !           608: be  inserted at the beginning of the new line. Blank space is also inserted at
        !           609: the beginning of new lines created by auto-break mode. In addition, ^V#^U will
        !           610: change the leading blank space of the current line to be equal in width to  the
        !           611: leading         blank space of the previous line, plus # additional (or fewer, if # is
        !           612: negative) spaces.
        !           613: 
        !           614: The text between the mark and the cursor can be         indented  or  "undented"  with
        !           615: ^V#H,  where # is the number of spaces to add or subtract.  ^V0H has the effect
        !           616: of converting leading spaces to tabs where possible.  The remainder of a  line
        !           617: starting at the cursor can be moved to start at a particular column with ^V^H.
        !           618: **** Adjusting text ****
        !           619: 
        !           620: **** Multi-file buffers ****
        !           621: ^R,  ^U^R,  and         ^U-^R can be used to read several files in to the buffer.  The
        !           622: argument to these commands is basically a list of  file         specifications,  which
        !           623: can  have  *'s in them, where * matches zero or more characters.  A real * in a
        !           624: file name can be represented with ^@.  The specifications can be  separated  by
        !           625: commas,         spaces,  tabs,  or  newlines.    These  separators  can be included in
        !           626: specifications be preceding them with a backslash (\). All files matching  the
        !           627: specifications are read in.  Alternatively, a file name (with no *'s in it) may
        !           628: be preceded by an @, in which case the named file is expected to contain a list
        !           629: of  file  specifications (which can also have @'s in from of them).  For ^R, if
        !           630: there is only one matching file, it replaces the  current  file         (the  one  the
        !           631: cursor is  in)  in  the  buffer;  if there is more than one matching file, the
        !           632: entire buffer is first flushed.         For  ^U-^R,  all  matching  files  are  simply
        !           633: inserted into the buffer.  For ^U^R, the text of each matching file is inserted
        !           634: into  the  current file of the buffer. Note that the default file name applies
        !           635: to all file specifications, including those in @-files.
        !           636: 
        !           637: Each file appears in the buffer with a 3 line heading of the form:
        !           638:        ^L
        !           639:        % <file name>
        !           640:        <blank line>
        !           641: These lines cannot be modified.
        !           642: 
        !           643: Most TED commands work as before, with (at  least)  the         following  exceptions.
        !           644: Text  withdrawal  only works within a given file; that is, one cannot withdraw
        !           645: text containing parts (or all) of different files.   (^U)^R,  (^U)^W,  and  ^\I
        !           646: only affect the current file, i.e., the file containing the cursor.  ^Z acts on
        !           647: the current file, and ^U^Z acts on the entire buffer.
        !           648: 
        !           649: ^U-^W  can be used to write out (only) changed files, with options of using the
        !           650: existing file names or specifying new ones.  There are a number of  ^V options
        !           651: related to multi-file buffers. ^VA moves to the start of the current file, ^VE
        !           652: move  to  the end of the current file, ^VN moves to the start of the next file,
        !           653: ^VP moves to the start of the previous file,  ^V#@  moves  to  line  # of  the
        !           654: buffer,         ^V^K  deletes  the current file from the buffer, and ^VO inserts space
        !           655: for a new file.         ^VV displays the file number and name of the current file, the
        !           656: file and buffer line numbers of the current cursor position, and the column and
        !           657: character numbers of the current cursor position.  There is also  a  ^\         option
        !           658: related         to  multi-file buffers.  ^\G takes the current file, which should be a
        !           659: CLU or Argus file, and splits it into a         several  files,  each  containing  one
        !           660: module.
        !           661: 
        !           662: While  working on a multi-file buffer, all changed files will be written to the
        !           663: ted save file. If the system crashes, simply reading in  your  ted  save  file
        !           664: will  not  get you  back  to  a multi-file buffer.  To separate out individual
        !           665: files, see "~CLU/restore.macro".
        !           666: **** Multi-file buffers ****
        !           667: 
        !           668: **** Multiple buffers ****
        !           669: When you first start up a TED, you are working in a buffer named "Main".  It is
        !           670: possible  to  have  multiple  named buffers around, and to switch between them.
        !           671: Only one buffer is displayed in a window at one time, and any buffer  can  have
        !           672: multiple  files         in  it.    Multiple  buffers  are an alternative to multi-file
        !           673: buffers, and both are useful on occasion.
        !           674: 
        !           675: The multiple buffer commands are under ^X^H.  There are commands  for  creating
        !           676: and  destroying buffers and for switching between them, for moving text between
        !           677: buffers, and for displaying the status of all buffers. All buffers are kept in
        !           678: a ring structure, and several commands work on the basis of ring order.
        !           679: 
        !           680: ^B     asks for a buffer name, and displays that buffer  if  it  exists,  else
        !           681:        creates and displays a new empty buffer of that name.
        !           682: ^D     displays  a  list  of  all  buffers and the files in those buffers, and
        !           683:        indicates if they have been modified since last written.
        !           684: ^F     flips to the buffer previously displayed in the window,  if  any,  else
        !           685:        the previous buffer in the ring.
        !           686: ^H     asks  for  a string and displays the next buffer in the ring whose name
        !           687:        contains that string as a substring.
        !           688: ^K     asks for a buffer name and kills the  specified  buffer  unless  it  is
        !           689:        being  displayed  by another window.  Confirmation must be given if the
        !           690:        buffer has been modified.  If the buffer  is  being  displayed  in  the
        !           691:        current window, a new buffer is chosen for display.
        !           692: ^N     displays the #'th next buffer in the ring
        !           693: ^P     displays the #'th previous buffer in the ring
        !           694: ^R     asks for a list of files, creates (if necessary) a buffer whose name is
        !           695:        derived  from  the  list, reads the files into the buffer, and displays
        !           696:        the buffer.  If the  buffer  already  exists  and  has  been  modified,
        !           697:        confirmation  must  be  given.   For  a  single file specification, the
        !           698:        buffer name is the name.suffix pair of the file specification.   For  a
        !           699:        list  of  file specifications, a new buffer is always created, and will
        !           700:        be "Main" followed by digits.
        !           701: ^S,S   appends text from the current buffer to  the  end  of  a  named  buffer
        !           702:        (default  "Temp").  ^S appends # lines, S appends the marked text.  The
        !           703:        text is not deleted from the current  buffer.    The  named  buffer  is
        !           704:        created if it does not exist.
        !           705: ^W,W   withdraws text from the current buffer and appends it to a named buffer
        !           706:        (default  "Temp").   ^W withdraws # lines, W withdraws the marked text.
        !           707:        The named buffer is created if it does not exist.
        !           708: C      writes out all changed files in all buffers, prompting for a  new  name
        !           709:        for  each file.  Typing ^G for a particular file will not write it out.
        !           710:        If # is zero, existing names for files will be used with no prompting.
        !           711: I      inserts the text of the named buffer  at  the  cursor  of  the  current
        !           712:        buffer.  The text is not removed from the named buffer.
        !           713: **** Multiple buffers ****
        !           714: 
        !           715: **** Multiple windows ****
        !           716: In  addition to multiple buffers, it is also possible to have multiple windows.
        !           717: Each window displays a single buffer, but different  windows  can  display  the
        !           718: same  buffer  if  desired.    Editing can only be done in one window at a time,
        !           719: though other windows can be scrolled.  The "cursor" is a per buffer notion, not
        !           720: a per window notion.
        !           721: 
        !           722: One possible use of multiple windows is during compilation or formatting.   The
        !           723: result of a ^\ command is saved in a buffer named "Result".  When you get error
        !           724: messages,  you can create a second window and display the Result buffer in it.
        !           725: Then you can fix the errors in one window while scrolling to new error messages
        !           726: in the other window.  This  is often  much  more  convenient  than  constantly
        !           727: flipping back and forth with ^\A.
        !           728: 
        !           729: The  multiple window commands are under ^X^W.  There are commands for splitting
        !           730: the current window and killing the current window, for moving to a new window,
        !           731: for  changing the size of existing windows, and for scrolling windows. Windows
        !           732: are kept in a ring structure, and several commands work on the basis  of  ring
        !           733: order.
        !           734: 
        !           735: ^B     moves the bottom boundary of current window down # lines.  A negative #
        !           736:        means move up.  Fails on bottom window.
        !           737: ^K     kills  the  current  window (but not the buffer it displayed).  The new
        !           738:        editing window is the window above, if  any,  else  the  window  below.
        !           739:        Space  from  the killed window is added to the new editing window.  The
        !           740:        cursor will be moved if necessary to reside in the part of  the  buffer
        !           741:        currently displayed in the new editing window.
        !           742: ^N     selects  a  new  editing  window by moving down (and around) # windows.
        !           743:        The cursor will be moved if necessary to reside  in  the  part  of  the
        !           744:        buffer currently displayed in that window.
        !           745: ^P     selects  a new editing window by moving up (and around) # windows.  The
        !           746:        cursor will be moved if necessary to reside in the part of  the  buffer
        !           747:        currently displayed in that window.
        !           748: ^R     asks for a list of files, creates (if necessary) a buffer whose name is
        !           749:        derived  from  the  list,  reads  the files into the buffer, splits the
        !           750:        current window, and displays the new buffer in the new,  lower  window.
        !           751:        The  new  window  contains |#| text lines if # is not 0 or 1, otherwise
        !           752:        the current window is split  in  half.   The  new  window  becomes  the
        !           753:        editing  window.    If the buffer already exists and has been modified,
        !           754:        confirmation must be given.   For  a  single  file  specification,  the
        !           755:        buffer  name  is the name.suffix pair of the file specification.  For a
        !           756:        list of file specifications, a new buffer is always created,  and  will
        !           757:        be "Main" followed by digits.
        !           758: ^S     asks  for a buffer name, creates a new empty buffer of that name if one
        !           759:        does not exist, splits the  current  window,  and  displays  the  named
        !           760:        buffer  in  the  new,  lower  window.  The new window contains |#| text
        !           761:        lines if # is not 0 or 1, otherwise the  current  window  is  split  in
        !           762:        half.  The new window becomes the editing window.
        !           763: ^T     moves  the top boundary of the current window up # lines.  A negative #
        !           764:        means move down.  Fails on the top window.
        !           765: D      selects a new editing window by moving down  (and  around)  #  windows.
        !           766:        The  part  of  the  buffer  displayed in that window will be changed if
        !           767:        necessary to include the cursor.
        !           768: N      scrolls the next window down (and around) by # lines if |#|~=1, or by a
        !           769:        screenful if |#|=1.  Does not move the cursor in any window,  and  does
        !           770:        not change windows.
        !           771: P      scrolls the previous window up (and around) by # lines if |#|~=1, or by
        !           772:        a screenful if |#|=1.  Does not move the cursor in any window, and does
        !           773:        not change windows.
        !           774: U      selects  a new editing window by moving up (and around) # windows.  The
        !           775:        part of the  buffer  displayed  in  that  window  will  be  changed  if
        !           776:        necessary to include the cursor.
        !           777: **** Multiple windows ****
        !           778: 
        !           779: **** Incremental search ****
        !           780: Incremental  search  changes  ^S so that it searches for a match dynamically as
        !           781: you type the search string.  It is also useful for counting  occurrences  of  a
        !           782: string.
        !           783: 
        !           784: ^X^SS  changes the search mode to incremental. ^S starts incremental search in
        !           785: Initial mode.  This displays  a         line  at  the  bottom  announcing  incremental
        !           786: search,         and  showing you the default.  You now have a number of options, based
        !           787: on what character you type:
        !           788: 
        !           789: ^D     asks for a new default search string.
        !           790: ^H     flips the search direction.
        !           791: ^L     clears the screen and redisplays.
        !           792: ^O     asks for a string and counts the number of occurrences of  that  string
        !           793:        in the rest of the buffer in the search direction.
        !           794: ^S     searches forward for the default and enters Search mode.
        !           795: ^U     reads  a  numeric  argument as usual, to be applied to the next command
        !           796:        whether or not it exits incremental search.
        !           797: ^Y     flips sense of whether case is ignored in searches.
        !           798: CR     exits incremental search, leaving the cursor where it is.
        !           799: ?      displays help.
        !           800: 
        !           801: All other control characters (except ^I and ^J)         exit  incremental  search  and
        !           802: execute         normally.    Any  other  character  becomes the first character of the
        !           803: search string and enters Search mode.
        !           804: 
        !           805: Once Search mode is entered, ^D and ^O no longer have  their  special  meaning,
        !           806: and ^H and ^Y additionally initiate a search.  The only new functions are:
        !           807: 
        !           808: ^?     (DEL)  deletes  #  characters  from  the search string and restores the
        !           809:        cursor and search direction to their previous values.
        !           810: ^G     exits incremental search if the search string is empty, else clears the
        !           811:        search string and restores the cursor and  search  direction  to  their
        !           812:        initial values.
        !           813: 
        !           814: As characters are typed in, they are added to the end of the search string, and
        !           815: searching  in the current direction is continued.  If the desired string is not
        !           816: found, the bell is rung, and the character left in the search string,  with  an
        !           817: indication that search failed.
        !           818: 
        !           819: When  incremental  search is exited, the search default is set according to the
        !           820: current search string if it is non-empty.
        !           821: **** Incremental search ****
        !           822: 
        !           823: **** Macros ****
        !           824: TED  has  a  simple  macro facility.  A macro is simply a string of characters;
        !           825: executing a macro has basically the same effect as if you typed the  characters
        !           826: of  the         macro directly on the keyboard.  There are no conditional or iteration
        !           827: constructs.  Commonly used sequences of commands can be turned into macros  and
        !           828: defined in your ".ted_init" file, and special macros can be defined on the fly.
        !           829: 
        !           830: Macros can be given either string or character names.  A character-named macro
        !           831: is defined by typing ^Y^@c (or ^U0^Yc), where 'c' is the character to  be  used
        !           832: as  the         name  of  the  macro, followed by the text of the macro.  The macro is
        !           833: executed by typing ^Yc, where c is the character naming         the  macro.    ^U#^Yc,
        !           834: with  #>0,  will execute the macro # times.  A string-named macro is defined by
        !           835: typing ^X0^Y, followed by the macro name, followed by  the  macro  body.    The
        !           836: macro  is  executed  by typing ^X^Y, followed by the macro name.  Typing ^X#^Y,
        !           837: followed by the macro name, will execute the macro # times.
        !           838: 
        !           839: During macro execution, an error (anything that would display an "Oops:..."  at
        !           840: the  top  of the screen) will cause the rest macro to be ignored.  This is also
        !           841: true of failing searches in incremental search mode.
        !           842: 
        !           843: You can also place a macro body in a file, and execute it via the ^X^X command.
        !           844: The format of such a file is the same as your ".ted_init" file, i.e.,  newlines
        !           845: are  discarded,         except that a blank line is converted to ^J.  Hence, a ^J must
        !           846: be represented by two ^J's.
        !           847: **** Macros ****
        !           848: 
        !           849: **** Pattern matching ****
        !           850: In  addition  to  searching  for  strings,  TED         has  a pattern matching search
        !           851: command, ^X^P. There is also a command, ^^P, for scanning multiple files for a
        !           852: pattern.  Within a pattern,  it         is  possible  to  specify  textual  deletions,
        !           853: substitutions, and insertions. The grammar for a pattern is as follows:
        !           854: 
        !           855: prim   ::=     sequence of "normal" and quoted characters (^Q char)
        !           856:           |    ^A | ^B | ^D  | ^F | ^J | ^L | ^P | ^X | ^Y | ^Z
        !           857:           |    ^E^A | ^E^B | ^E^D | ^E^F | ^E^J | ^E^L | ^E^P | ^E^Y
        !           858:           |    ^R char char  |  ^K char char  |  ^\ char ... char ^\
        !           859:           |    ^V char
        !           860:           |    ^T text [^T]
        !           861:           |    ^U name [^U]
        !           862:           |    ^[ pattern ^]
        !           863: expr   ::=     prim [^@ | ^^ | ^? | ^_]
        !           864: unit   ::=     expr
        !           865:           |    expr ^S text [^S] [^@ | ^^ | ^? | ^_]
        !           866:           |    expr ^W char [^@ | ^^ | ^? | ^_]
        !           867:           |    expr ^G macro-body ^G [^@ | ^^ | ^? | ^_]
        !           868:           |    ^N unit
        !           869: group  ::=     unit [group]
        !           870: pattern ::=    group [^O pattern]
        !           871: 
        !           872: Things in  square  brackets  ([])  are  optional.   All special characters are
        !           873: defined         below.    All  other  characters  are  "normal"  characters.    Normal
        !           874: characters  match  themselves.   In  addition, the case flag for searches also
        !           875: applies to normal characters.
        !           876: 
        !           877: ^A     matches any alphanumeric character (0-9, A-Z, _, a-z).
        !           878: ^B     matches any blank character (space, tab).
        !           879: ^D     matches any digit (0-9).
        !           880: ^E     can be followed by one of (^A, ^B, ^D, ^F, ^J, ^L, ^P, ^Y), and matches
        !           881:        any character not in the  range  specified  by  that  character.    For
        !           882:        example, ^E^Y will match only newline.
        !           883: ^F     matches any formatting characters (space, tab, formfeed, newline).
        !           884: ^G     specifies  arbitrary  actions to be performed on the part of the buffer
        !           885:        matching the previous pattern, in the form of a sequence of  characters
        !           886:        to  be  executed  just  as  if they were typed from the terminal.  A ^G
        !           887:        within the macro-body must be quoted with  a  ^Q,  which  will  not  be
        !           888:        removed.    Note  that  the  macro-body will not be executed unless the
        !           889:        overall pattern matches, and in no way affects the success  or  failure
        !           890:        of  matching.    The  macro-body  is  executed  on  a  separate  buffer
        !           891:        containing the match, with the cursor initially at  the  start  of  the
        !           892:        buffer  and  the  mark  at the end of the buffer.  The contents of this
        !           893:        buffer will be used to replace the match.   Note  that  the  macro-body
        !           894:        need  not  modify the buffer; it could, for example, copy the buffer to
        !           895:        the end of some other buffer.  The macro-body should not  generate  any
        !           896:        errors.   If an error does occur within the macro-body, the rest of the
        !           897:        macro-body will be ignored, and you will be left in a restricted buffer
        !           898:        named Pattern.  You should then type ^^ to continue.
        !           899: ^J     matches itself, the newline  character.    Note  that  newline  is  not
        !           900:        considered  a  text character, and must be quoted inside ^S and ^T text
        !           901:        strings.
        !           902: ^K     matches any character not in  the  range  specified  by  the  next  two
        !           903:        characters.  For example, ^Kab would match any character except 'a' and
        !           904:        'b'.  The range must be specified with the smallest character first.
        !           905: ^L     matches any "letter" (A-Z, _, a-z).
        !           906: ^N     NOT  construct.    This  will  not  actually match anything.  It simply
        !           907:        guarantees that the following pattern will not  match  at  this  point.
        !           908:        Note  that  any  text  deletion  or  insertion  specified  within  this
        !           909:        construct will be ignored.
        !           910: ^O     separates elements of an OR construct.  The elements of an OR construct
        !           911:        are tried in parallel for the "closest" match.   The  possible  matches
        !           912:        for  a  particular  element  are  always  tried in order.  The possible
        !           913:        matches for all elements are shuffled such that a match M from  element
        !           914:        E  is  tried  before  a match M' from element E' if and only if M is at
        !           915:        least as close as M' and E is less than E'.  Closeness is determined by
        !           916:        the starting position of the match.  Thus, if  the  OR  construct  must
        !           917:        match  the immediately following text, the elements are simply tried in
        !           918:        order.
        !           919: ^P     matches any punctuation (non-alphanumeric) character except newline.
        !           920: ^Q     quotes the next character for use as a text character.    For  example,
        !           921:        ^Q^Q  will match the character ^Q.  Quoting can also be done inside ^G,
        !           922:        ^S, ^T, and ^U arguments.
        !           923: ^R     matches  any  character  in  the  range  specified  by  the  next   two
        !           924:        characters.  For example, ^R^@^_ matches any control character.
        !           925: ^S     substitutes  text  for  the  part  of  the buffer matching the previous
        !           926:        pattern.  The text can be explicitly terminated with ^S,  but  will  be
        !           927:        terminated  implicitly  by any other special character except ^Q.  Note
        !           928:        that  no  substitutions  occur  unless  the  overall  pattern  matches.
        !           929:        Substitutions in no way affect the success or failure of matching.
        !           930: ^T     inserts  text  into  the buffer.  The text can be explicitly terminated
        !           931:        with ^T, but  will  be  terminated  implicitly  by  any  other  special
        !           932:        character  except ^Q.  Note that no insertions occur unless the overall
        !           933:        pattern matches.  Insertions in no way affect the success or failure of
        !           934:        matching.
        !           935: ^U     matches the string which is the value of the named  string  environment
        !           936:        variable.   If  no  such  variable exists, or is not a string variable,
        !           937:        then matches the empty string.  The variable  name  can  be  explicitly
        !           938:        terminated  with  ^U,  but  will  be terminated implicitly by any other
        !           939:        special character except ^Q.
        !           940: ^V     inserts the last partial match saved under the  label  defined  by  the
        !           941:        next  character.    If  no match has been saved, the overall pattern is
        !           942:        aborted.
        !           943: ^W     deletes and saves the part of the buffer matching the previous  pattern
        !           944:        under  the  label  defined by the next character.  The text can then be
        !           945:        inserted using ^V with the same character as the label.  Any  character
        !           946:        can  be  used  as  a  label.   Note  that no deletions occur unless the
        !           947:        overall pattern matches.  Deletions in no way  affect  the  success  of
        !           948:        failure of matching.
        !           949: ^X     matches any character.
        !           950: ^Y     matches any character except newline.
        !           951: ^Z     matches the end of the buffer.
        !           952: ^@     P^@  matches smallest possible sequence of the pattern P.  That is, the
        !           953:        patterns <empty>, P, PP, PPP, PPPP, ...  are tried  in  order  for  the
        !           954:        first  match  that  allows  the overall pattern to match.  For example,
        !           955:        ^Y^@ can be used to specify that the remainder of the  overall  pattern
        !           956:        must start matching somewhere on the current line.  ^X^@ can be used to
        !           957:        specify  that  the  remainder of the overall pattern can start matching
        !           958:        arbitrarily far forward in the buffer.
        !           959: ^^     P^^ matches smallest possible non-empty  sequence  of  the  pattern  P.
        !           960:        That is, the patterns P, PP, PPP, PPPP, ...  are tried in order for the
        !           961:        first  match  that  allows  the  overall  pattern  to  match.    P^^ is
        !           962:        equivalent to ^[^[P^]P^@^].
        !           963: ^?     (DEL) P^? matches the largest sequence of the  pattern  P.    P^?  will
        !           964:        match  either  the  longest  sequence  of P's, or the empty string, but
        !           965:        nothing else.  For example, ^Y^? will match the rest of the  line,  and
        !           966:        ^X^?  will match the rest of the buffer.  In situations where ^? and ^@
        !           967:        could both be used, ^? is much more efficient.
        !           968: ^_     P^_ matches the largest non-empty sequence of the pattern P.  P^_  will
        !           969:        match  only  the  longest  sequence  of  P's.    P^_  is  equivalent to
        !           970:        ^[^[P^]P^?^].  In situations where ^_ and ^^ could both be used, ^_  is
        !           971:        much more efficient.
        !           972: ^\ ^\  delimits  a  set  of characters; matches any character in the set.  For
        !           973:        example, ^\+-*/^\ matches '+', '-', '*', or '/'.
        !           974: ^[ ^]  are parentheses used  to  delimit  patterns.    Used  when  the  normal
        !           975:        precedence is not sufficient.
        !           976: 
        !           977: Overall,  pattern  matching retry is performed depth first, right to left.  For
        !           978: example, matching the pattern ^[A^OB^]^[X^OY^] would involve, for each match of
        !           979: ^[A^O^B^], trying all possible matches of ^[X^OY^].
        !           980: 
        !           981: ^X^P with a positive argument will always add a prefix of ^X^@ (i.e., the match
        !           982: can start arbitrarily far forward in the buffer),  and will  search  #  times.
        !           983: ^X^P  with  a  negative         argument  will  always force the match to start at the
        !           984: cursor, and will search |#| times.
        !           985: 
        !           986: ^X0^P can be used to turn on/off buffer change confirmation.  When  turned  on,
        !           987: every change to the buffer made under pattern search will have to be confirmed.
        !           988: 
        !           989: Beware that  it  is  quite  easy  to  specify  patterns  that  will  go either
        !           990: indefinitely or for a very long time  before  failing  or  matching  the  empty
        !           991: string at  the  end  of  the  buffer.    ^G  can be used to abort long pattern
        !           992: searches, but you may have to wait a bit before the ^G will be noticed.
        !           993: 
        !           994: As an example of the use of  pattern  matching,         the  following  pattern,  when
        !           995: searched via ^X^P, will change the buffer to single spacing:
        !           996: 
        !           997: ^[^J^J^_^S^X^@^]^?
        !           998: 
        !           999: The  following pattern,  when  searched  via  ^X-^P, will delete all lines not
        !          1000: containing the string "begin_list" or  the  string  "end_list" (providing  the
        !          1001: first line does not contain either string):
        !          1002: 
        !          1003: ^[^[^X^@^J^]^S^Y^@^[begin_list^Oend_list^]^Y^?^J^]^?^X^?^S
        !          1004: 
        !          1005: The  following pattern, when searched via ^X^P, will change the next occurrence
        !          1006: of
        !          1007:        if <expr1> cor <expr2>
        !          1008: as a complete single line with arbitrary spacing to
        !          1009:        if <expr2> cand <expr1>
        !          1010: with the same spacing:
        !          1011: 
        !          1012: ^B^?if^B^_^Y^^^W1^[^B^_cor^Scand^B^_^]^W2^Y^_^V2^V1
        !          1013: **** Pattern matching ****
        !          1014: 
        !          1015: **** Pattern matching summary ****
        !          1016: ^A     alphanumeric (0-9, A-Z, _, a-z)
        !          1017: ^B     blank (space, tab)
        !          1018: ^D     digit (0-9)
        !          1019: ^E     exclusive of (^A, ^B, ^D, ^F, ^J, ^L, ^P, ^Y)
        !          1020: ^F     format (space, tab, formfeed, newline)
        !          1021: ^G     execute macro-body
        !          1022: ^J     newline
        !          1023: ^K     exclusive of range
        !          1024: ^L     letter (A-Z, _, a-z)
        !          1025: ^N     not
        !          1026: ^O     or
        !          1027: ^P     punctuation (non-alphanumeric/non-newline)
        !          1028: ^Q     quote
        !          1029: ^R     range
        !          1030: ^S     substitute text
        !          1031: ^T     insert text
        !          1032: ^U     variable value
        !          1033: ^V     insert text saved under label
        !          1034: ^W     withdraw and save text under label
        !          1035: ^X     any char
        !          1036: ^Y     non-newline
        !          1037: ^Z     end of buffer
        !          1038: ^@     zero or more
        !          1039: ^^     one or more
        !          1040: ^_     all in a row
        !          1041: ^?     all in a row or none
        !          1042: ^\ ^\  char set
        !          1043: ^[ ^]  parentheses
        !          1044: **** Pattern matching summary ****
        !          1045: 
        !          1046: **** Sorting ****
        !          1047: The  ^XX  command  performs a TECO-like sort of the current file of the buffer.
        !          1048: The file is divided into records of arbitrary length, each of which contains  a
        !          1049: sort  key, again of arbitrary length and positioned anywhere within the record.
        !          1050: The records may be sorted in increasing lexicographic order  with  ^XX,         or  in
        !          1051: decreasing  order  with ^X-X.  Case distinctions are ignored if the search flag
        !          1052: is set to ignore case. The sort is stable (i.e., records with equal keys  will
        !          1053: remain in the same relative order), so multi-key sorting can be accomplished by
        !          1054: sorting a key at a time, least significant key first.
        !          1055: 
        !          1056: Records and keys are determined using three command strings, given as arguments
        !          1057: to  the         sort  command.    The first command string is executed to get from the
        !          1058: start of the current record to the start of its key.  The sort will be aborted
        !          1059: if  this  command  string  generates  any errors.  The second command string is
        !          1060: executed to get from the start of the key to the end  of  the  key  (i.e.,  one
        !          1061: character  beyond  the end of the key).         In a failing string or pattern search,
        !          1062: the end of the key (and the end of the record) is assumed to be the end of  the
        !          1063: file;  any  other  errors  will         abort  the  sort.  The third command string is
        !          1064: executed to get from the end of the key to the start of the next record (and is
        !          1065: only executed if the previous command string did not generate an error).  In  a
        !          1066: failing         string  or  pattern search, the end of the record is assumed to be the
        !          1067: end of the file; any other errors will abort the sort.
        !          1068: 
        !          1069: The start of the first record is assumed to be the start  of  the  file.    The
        !          1070: command         strings are repeatedly executed until the entire file has been divided
        !          1071: into records.  The  command  strings  can  contain  arbitrary  commands.    The
        !          1072: defaults  are  (1) the empty string, meaning the key starts at the beginning of
        !          1073: the record, (2) ^E, meaning the end of the key is the end of the first line  of
        !          1074: the  record,  and  (3) ^F, meaning the start of the next record is the start of
        !          1075: the next line. This gives a line by line sort of the file.
        !          1076: 
        !          1077: Sorting part of a file can be done using the restricted buffer option, ^XR.
        !          1078: **** Sorting ****
        !          1079: 
        !          1080: **** Miscellaneous options ****
        !          1081: String and  file  name  arguments normally appear at the bottom of the current
        !          1082: window.         Setting the "arg_display_mode" number variable  to  a  non-zero  value
        !          1083: will  force  these arguments to always appear at the bottom of the screen.  The
        !          1084: size of the argument window is normally 2 lines.  This can be  controlled  with
        !          1085: the "arg_display_size" number variable.
        !          1086: 
        !          1087: Help displays (from ^H and ?) and ^\ result displays normally occupy the entire
        !          1088: screen.           Setting  the "sub_display_mode" number variable to 1 will cause only
        !          1089: the current window to be used. Setting the variable to 2 will cause the larger
        !          1090: of the two areas above and below the current window to be used, or  the         entire
        !          1091: screen if  there is only one window.  Setting the variable to 3 or higher will
        !          1092: cause that many lines at the bottom of the screen to  be  used.           Setting  the
        !          1093: variable to 0 or a negative value will restore the use of the full screen.
        !          1094: 
        !          1095: You  can  check         the  spelling of a word with ^XW.  The default argument is the
        !          1096: word containing the cursor, or the word to the left of the cursor if the cursor
        !          1097: is between words.  If the word appears to be misspelled, a  list  of  suggested
        !          1098: spellings  will         be  displayed  at  the top of the screen.  Spelling is checked
        !          1099: using ISPELL.  The ISPELL  process  is normally  kept  around  for  subsequent
        !          1100: spelling checks, but may be killed off with the ^X0W command.
        !          1101: 
        !          1102: ^_D  will  delete a list of files with a yes/no confirmation on each file, ^_0D
        !          1103: will delete a list of files without confirmation, ^_L will make         a  link  to  a
        !          1104: file,  ^_S  will  make a symbolic link to a file, ^_M will change the mode of a
        !          1105: list of files, and ^_R will rename a file.
        !          1106: 
        !          1107: ^VT displays the current date and time, and ^V0T inserts the current  date  and
        !          1108: time  into the buffer. ^V^T displays the total CPU time used by TED so far, and
        !          1109: the CPU time used since the last ^V^T command.
        !          1110: 
        !          1111: The restricted buffer option (^XR) gives you the piece of  the current  buffer
        !          1112: between         the  mark and the cursor as a separate buffer to work on.  The changes
        !          1113: get reflected in the original buffer when you exit (via ^^) from this mode.
        !          1114: 
        !          1115: There is an alternate mode for ^K, settable via ^X^K, that will only delete  to
        !          1116: the  end of the line (not through it), unless you are already at the end of the
        !          1117: line or #~=1.  There are alternate modes for ^N and ^P, settable via ^XM,  that
        !          1118: place  the  cursor after leading spaces and tabs in the line, a mode for trying
        !          1119: to stay at a fixed column position, and a mode for trying to stay at the column
        !          1120: you were at before the last sequence of ^N and ^P commands.
        !          1121: 
        !          1122: There is a mode for text type-in (^XO) that will overwrite  characters in  the
        !          1123: buffer,          rather   than   inserting   characters  into  the  buffer.    Type-in
        !          1124: automatically reverts to insertion mode when at the end of a  line.    Newlines
        !          1125: never overwrite characters; they are always inserted.
        !          1126: 
        !          1127: There  is  a  mode  for making simple straight line drawings (^X^D).  To draw a
        !          1128: line, move the cursor (with ^A, ^E, ^F, ^B, ^N, ^P, ^Z) to the starting  point
        !          1129: and  set  the  mark with ^T.  Then move the cursor to the ending point and type
        !          1130: the printing character (octal 40 to 176) you want to draw the line with.   This
        !          1131: will draw a line from the mark to the cursor, and set the mark to be the end of
        !          1132: the  line.  To erase a line, just redraw the line with a blank.         Drawing a line
        !          1133: will overwrite previous         characters  unless  you  type  ^U  before  typing  the
        !          1134: printing character.
        !          1135: 
        !          1136: There  is  a  command for drawing a box around a group of lines (^XB). The box
        !          1137: can be centered or indented a fixed amount from the left.  The shape of the box
        !          1138: is controlled by various "box_*" string and number variables.
        !          1139: 
        !          1140: ^XCU and ^XCL change the case of the marked to text to upper  and  lower  case,
        !          1141: respectively.   ^XCC  capitalizes the first letter of every word in the marked
        !          1142: text.
        !          1143: 
        !          1144: The meanings of the RED and BLUE function keys on  Heaths  and  VT52s  can  be
        !          1145: swapped with ^XE.
        !          1146: 
        !          1147: New mail can be tested for with ^X^M.
        !          1148: 
        !          1149: ^X#^R  will  force  the         #  line  down  (up if negative) from the current (with
        !          1150: respect to where the cursor ought to be, not with respect to  where  it         really
        !          1151: is)  line to be redisplayed, and correctly repositions the cursor.  This can be
        !          1152: used to clean up lines that have been garbled by system         messages  or  a  noisy
        !          1153: terminal line, and is particularly useful over a slow terminal line.
        !          1154: 
        !          1155: When  editing  over  a slow line where the system does not know the line speed,
        !          1156: ^XT#B can be used to inform TED that the line speed  is         #  baud.    This  will
        !          1157: automatically adjust padding appropriately.  This number will only be used when
        !          1158: the  system does not know the line speed.  You can turn padding off with ^XT0P,
        !          1159: and you can prevent TED from using full screen scrolling and insert/delete line
        !          1160: with ^XT0S, although you should never have to do either of these.  You can tell
        !          1161: TED your terminal has a meta key with ^XTM, or doesn't have  a meta  key  with
        !          1162: ^XT0M; this controls whether the high bit of each character typed gets masked.
        !          1163: Again, you should never have to do either of these, as the termcap entry should
        !          1164: define this.
        !          1165: 
        !          1166: The default position of the cursor on redisplay is 75% up from the  bottom  of
        !          1167: the  window.   This  percentage  can  be  set  with the ^V#^ command, with #<0
        !          1168: restoring the default. When displaying the end of the buffer, the  default  is
        !          1169: to  keep  the  window  70%  blank.    This  percentage can be set with the ^V#%
        !          1170: command, with #<0 restoring the default.  When the  cursor  moves  outside  the
        !          1171: current         window,  the default is to choose a new window around the cursor based
        !          1172: on the above percentages.  However, the ^V#= command can be used to alter this,
        !          1173: so that the window will instead be scrolled until the cursor  comes  into  view
        !          1174: (at  the  top  or  bottom), provided that # percent of the original window will
        !          1175: remain on the screen.  ^V#= with #<0 restores the default (100%).
        !          1176: 
        !          1177: You can create your own help file, to be displayed with the ^U^H command.   The
        !          1178: string variable  "help_file"  defines the name of this file, the default being
        !          1179: "~/.ted_hlp".  The file can be either a simple text file or a menu-driven file.
        !          1180: For a menu-driven file, the first line must start with "**** Menu for ".    The
        !          1181: following  lines,  up  to the next line starting with "**** Menu for ", make up
        !          1182: the menu.  Each line of the menu consists of one or more menu items,  separated
        !          1183: by  tabs.    Each  menu         item  consists of an upper-case letter (for selection)
        !          1184: followed by a colon and a space, followed by the name of the  selection         (e.g.,
        !          1185: "Multiple buffers").  The body of the selection is placed anywhere in the file,
        !          1186: beginning and ending with a line of the form "**** N ****", where N is the name
        !          1187: of the selection.
        !          1188: 
        !          1189: The  ^X#Z  command can be used to control the frequency of garbage collections,
        !          1190: setting a GC to go off every 2**(#-4) megabytes.
        !          1191: **** Miscellaneous options ****
        !          1192: 
        !          1193: **** TED variables ****
        !          1194: The following list names the TED variables, their types, and what they are used
        !          1195: for.  Number and string variables can be set by ^XN and ^XS, respectively.
        !          1196: 
        !          1197: Name             Type   Usage
        !          1198: 
        !          1199: adjust_width     N      width to use in adjusting text (^]W).
        !          1200: arg_display_mode  N     N=0: string arguments at bottom of current window.
        !          1201:                         N~=0: string arguments at bottom of screen.
        !          1202: arg_display_size  N     string argument window size.
        !          1203: backup_name      S      directory and extension for backup file names (^W).
        !          1204: binary_suffix    S      default suffix for compiled binaries (^\U*M,L).
        !          1205: binary_dir       S      default directory for compiled binaries (^\U*M,L).
        !          1206: box_hspace       N      space between sides and text of box (^XB).
        !          1207: box_hwidth       N      N<0: fill field if centered box (^XB).
        !          1208:                         N>=0: width of sides of box (^XB).
        !          1209: box_indent       N      N<0: center box in field of -N (^XB).
        !          1210:                         N>=0: indent box N from left (^XB).
        !          1211: box_string       S      string to draw box with (^XB).
        !          1212: box_vspace       N      lines between top/bottom and text of box (^XB).
        !          1213: box_vwidth       N      width of top/bottom of box (^XB).
        !          1214: careful                  N      N~=0: confirm if buffers modified (^C).
        !          1215: change_limit     N      # of changes to buffer between saves.
        !          1216: comment_sep      S      placed between comment symbol and comment (^]C).
        !          1217: compiler_name    S      name of compiler (^\).
        !          1218: default                  S      default for string/filename arguments.
        !          1219: default_fork     S      default program name (^J).
        !          1220: esc-*            S      escape sequence redefinitions (ESC ESC).
        !          1221: exit_msg         N      N~=0: clear screen & type message when exiting (^C).
        !          1222:                         N=0: leave as much text on screen as possible (^C).
        !          1223: fill_prefix      S      fill prefix to use in auto-break mode (^]A).
        !          1224: help_file        S      user-defined help file (^U^H).
        !          1225: help_query       N      N~=0: confirm help request (^H,^U^H).
        !          1226: host             S      host name.
        !          1227: ignore_case      N      N=0: upper/lower case matters in searches (^U0^S).
        !          1228: justify                  N      N~=0: justify right margin (^]J).
        !          1229: keep_count       N      # of old versions to keep, #<0: includes oldest (^W).
        !          1230: keypad           N      N~=0: should be in alternate keypad mode (^[H).
        !          1231: last_arg         S      last string/filename arg (^VG).
        !          1232: last_result      S      name of last result buffer from ^\ command.
        !          1233: list_chars       S      list and literal delimiters (^X^Z).
        !          1234: mail_box         S      name of spooled mail file (^X^M).
        !          1235: mail_name        S      name of mail program (^\S).
        !          1236: max_width        N      maximum width of non-long lines (^V!).
        !          1237: no_fill_starters  S     initial chars on line that inhibit adjusting (^]).
        !          1238: pause            N      N~=0: pause at inferior termination (^J).
        !          1239: pconfirm         N      N~=0: confirm pattern search buffer changes (^X0^P).
        !          1240: pindent                  N      N~=0: indented lines start new paragraphs (^]).
        !          1241: progy_name       S      name of program to run under ^\Y.
        !          1242: progz_name       S      name of program to run under ^\Z.
        !          1243: psearch                  S      last pattern search string (^X^P).
        !          1244: r_name           S      name to use for R (^\).
        !          1245: save_file        S      save file name.
        !          1246: save_mode        N      octal mode bits for save file (^U^L).
        !          1247: scribe_name      S      name to use for Scribe (^\).
        !          1248: search           S      default search object (^S).
        !          1249: sub_display_mode  N     N<=0: help and ^\ results use entire screen.
        !          1250:                         N=1: use current window.
        !          1251:                         N=2: use largest area above or below current window.
        !          1252:                         N>2: use bottom N lines of screen.
        !          1253: terminal         S      terminal name.
        !          1254: umask            N      octal umask for inferior processes (^\,^J).
        !          1255: word_chars       S      special chars included in words.
        !          1256: write_check      N      check when using long file names (^W).
        !          1257: write_mode       N      octal mode bits for new files (^W).
        !          1258: write_style      N      backup-on-write mode (^W,^X^C).
        !          1259: ^X^Y-*           S      macro definitions (^X^Y).
        !          1260: ^Y-*             S      macro definitions (^Y).
        !          1261: **** TED variables ****
        !          1262: 
        !          1263: **** Indenter variables ****
        !          1264: Indenter  variables  can  be  set via ^XI.  All variables can be reset to their
        !          1265: default values via ^XI*.  The CLU variables are:
        !          1266: 
        !          1267: Name           Value           Indents when starting line (unless noted)
        !          1268: 
        !          1269: begin_body     4               BEGIN-END body
        !          1270: bracket                4               (,{,[ if starts line but does not start expr
        !          1271:                                elts of () {} [] if first element starts line
        !          1272:                                right side of :=
        !          1273: close_bracket  1               ),},] if starts line
        !          1274: cluster_body   4               CLUSTER body
        !          1275:                                Argus: GUARDIAN
        !          1276: do             2               DO
        !          1277: elseif         1               ELSEIF
        !          1278: end            0               END (0: indent END, ~0: don't indent END)
        !          1279: except         3               EXCEPT
        !          1280: for_body       4               FOR body
        !          1281: head           2               RETURNS, SIGNALS, YIELDS
        !          1282: is             8               IS
        !          1283:                                Argus: HANDLES
        !          1284: op             2               infix operators
        !          1285: routine_body   4               PROC, ITER body
        !          1286:                                Argus: CREATOR, HANDLER, BACKGROUND, RECOVER
        !          1287: tag            3               TAG
        !          1288:                                Argus: WTAG
        !          1289: tag_body       4               TAG body
        !          1290:                                Argus: WTAG
        !          1291: then           3               THEN
        !          1292: then_body      5               THEN body (if THEN also starts line)
        !          1293:                                ELSE body
        !          1294: thenx_body     3               THEN body (if THEN does not start line)
        !          1295: when           3               WHEN
        !          1296: when_body      5               WHEN body
        !          1297: where          8               WHERE
        !          1298: while_body     4               WHILE body
        !          1299: 
        !          1300: The additional variables for Argus are:
        !          1301: 
        !          1302: Name           Value           Indents when starting line (unless noted)
        !          1303: 
        !          1304: argus          0               indenter mode (0: CLU, ~0: Argus)
        !          1305: coenter_body   4               coarm body (if first coarm key starts line)
        !          1306: coenter_key    4               ACTION, TOPACTION, PROCESS
        !          1307: coenterx_body  4               coarm body
        !          1308:                                (if first coenter_key does not start line)
        !          1309: enter_body     4               ENTER body (if enter key starts line)
        !          1310: enter_key      4               ACTION, TOPACTION
        !          1311: enterx_body    4               ENTER body (if enter_key does not start line)
        !          1312: foreach                7               FOREACH
        !          1313: seize_body     4               SEIZE body
        !          1314: 
        !          1315: A negative indentation step value means "go to next tab stop".
        !          1316: **** Indenter variables ****
        !          1317: 
        !          1318: **** File names/backup/protection ****
        !          1319: TED  accepts  ~-form  directory         specifications  and does *-matching.  However,
        !          1320: *-matching is a little different than the way the shell does it,  in  that  "."
        !          1321: and  ".."  are always  ignored but other entries beginning with period are not
        !          1322: ignored.
        !          1323: 
        !          1324: You can define path name abbreviations with string variables.  In file name and
        !          1325: directory arguments, a prefix ending with two slashes (//) is taken to be  the
        !          1326: name  of  a string variable, and is replaced by the value of the variable.  For
        !          1327: example, if the string variable "man1//" is  defined  to  be  "/usr/man/man1/",
        !          1328: then  the  file name "man1//csh.1" becomes "/usr/man/man1/csh.1".  In ^\J, ^\M,
        !          1329: ^\R, ^\Y, ^\Z, and ^J command lines, words ending with two  slashes  are  also
        !          1330: expanded this way.
        !          1331: 
        !          1332: Since  Unix  does  not support version numbers, there are a number of different
        !          1333: ways of creating backup files when files are written.  The particular method is
        !          1334: set by the ^X^C command.  The options are (N)  do  not create  a  backup,  and
        !          1335: (over)write  directly  to  the file, (T) do not create a backup, but write to a
        !          1336: temporary file and then rename it (R) always rename the current version of  the
        !          1337: file,  (^R)  rename the current version of the file if a backup does not exist,
        !          1338: otherwise (over)write directly, (^T) rename the current version of the file  if
        !          1339: a  backup  does         not exist, otherwise write to a temporary file and then rename
        !          1340: it, (C) always copy the         current  version  of  the  file  before  (over)writing
        !          1341: directly,  (^C) copy the current version of the file if a backup does not exist
        !          1342: before (over)writing directly, (X) rename  the current  version  of  the  file
        !          1343: unless there are links to it, in which case copy the current version, and then
        !          1344: (over)write directly, and (^X) if a backup does not exist, rename  the current
        !          1345: version         of  the  file  unless  there  are  links to it, in which case copy the
        !          1346: current version, and then (over)write directly.         The initial mode is  N.    The
        !          1347: name  of  the  backup  file generally is obtained by appending the value of the
        !          1348: "backup_name" string variable to the current file name, with the default  being
        !          1349: ".old".           However,  the  current  file  name  may  have to be truncated before
        !          1350: appending if the new name exceeds 255  characters.    Also,  "backup_name"  may
        !          1351: contain a (possibly relative) directory where the backup file should be placed.
        !          1352: So "backup_name" should have one of the forms "str", "dir/str", or "dir/".
        !          1353: 
        !          1354: If  the         backup file extension is ".^V", then version numbered backup files are
        !          1355: maintained.  When version numbering, the backup-on-write modes ^R, ^T, ^C,  and
        !          1356: ^X  are         equivalent  to  R,  T, C, and X respectively.  The "keep_count" number
        !          1357: variable specifies how many backup versions to maintain, with default value  1.
        !          1358: If  "keep_count" is N, the N highest versions are kept.         If "keep_count" is -N,
        !          1359: then the oldest version and the N-1 highest versions are kept.
        !          1360: 
        !          1361: When writing to a file, if you specify a name longer than 255  characters,  the
        !          1362: number variable "write_check" controls what happens.  If the variable is 0 (the
        !          1363: default), the name is truncated in the usual way.  If the variable is negative,
        !          1364: the  file is not written and an error message is generated.  If the variable is
        !          1365: positive, the part before the first dot is truncated, unless the part after the
        !          1366: first dot is longer than 254 characters, in which case the file is not written
        !          1367: and an error message is generated.
        !          1368: 
        !          1369: The  mode  bits         for  new  files  are  given  by  the "write_mode" octal number
        !          1370: variable, the default being 666 masked by the initial umask.  The umask is then
        !          1371: cleared, but its value is saved in the "umask" octal number variable,  for  use
        !          1372: when  running  inferiors.    The  mode bits for ted save files is given by the
        !          1373: "save_mode" octal number variable, with the default being 600.
        !          1374: **** File names/backup/protection ****
        !          1375: 
        !          1376: **** XTED features ****
        !          1377: This section is for those using the version of TED that runs under the X window
        !          1378: system.
        !          1379: 
        !          1380: The following are options that can be specified at the beginning of the command
        !          1381: line when starting an XTED:
        !          1382:        -fn=FONT
        !          1383:        [-HOST]:DISPLAY
        !          1384:        =[WIDTH][xHEIGHT][{+-}XOFF[{+-}YOFF]]
        !          1385:        -rv       (reverse video)
        !          1386:        -i        (miniature icon)
        !          1387:        -fg=COLOR     (text color)
        !          1388:        -bg=COLOR     (background color)
        !          1389:        -cr=COLOR     (text cursor color)
        !          1390:        -hl=COLOR     (highlight color)
        !          1391:        -ms=COLOR     (mouse cursor color)
        !          1392: 
        !          1393: The  []'s  denote  optional stuff, the {}'s surround alternatives.  The default
        !          1394: font is 8x13, the default display is  controlled  by  the  DISPLAY  environment
        !          1395: variable.    WIDTH and HEIGHT are in number of characters, XOFF and YOFF are in
        !          1396: pixels.         WIDTH defaults to 80, HEIGHT to 24, XOFF and YOFF to 1.  If you  don't
        !          1397: give  XOFF  and/or  YOFF,  then         you  must  use the mouse to create the window.
        !          1398: Pressing left button will give you a WIDTHxHEIGHT window that you can then move
        !          1399: around to place until you release the button.  Pressing the right button  gives
        !          1400: you  a window WIDTH wide and to the bottom of the screen.  Pressing the middle
        !          1401: button defines one corner of the  window,  releasing  the  button  defines  the
        !          1402: opposite corner.  If you give XOFF and/or YOFF, then a WIDTHxHEIGHT window will
        !          1403: automatically  be  creating without intervention.  XOFF and YOFF specify deltas
        !          1404: from a corner of the screen to the  corresponding  corner  of  the  window,  as
        !          1405: follows:
        !          1406:        +XOFF+YOFF       upper left to upper left
        !          1407:        -XOFF+YOFF       upper right to upper right
        !          1408:        +XOFF-YOFF       lower left to lower left
        !          1409:        -XOFF-YOFF       lower right to lower right
        !          1410: 
        !          1411: The  following options  are  also  read  from  the  .Xdefaults file: BodyFont,
        !          1412: BorderWidth,  ReverseVideo,  Foreground,  Background,  Cursor, Highlight,  and
        !          1413: Mouse.
        !          1414: 
        !          1415: The  ^C         command  does not suspend XTED, as suspending is useless.  Instead, ^C
        !          1416: should be typed after resizing the window, to  reconfigure  things.    (Someday
        !          1417: maybe this will be automatic.)
        !          1418: 
        !          1419: The  ^J         command  for  interactive programs does not exist: run them in another
        !          1420: window!
        !          1421: 
        !          1422: The command ^XT0C will change the window to white text on a  black  background.
        !          1423: The command ^XTC restores the window to black text on a white background.
        !          1424: 
        !          1425: The escape sequences generated by mouse button events are as follows:
        !          1426: 
        !          1427: &l     left-down
        !          1428: &L     left-up
        !          1429: &a     CONTROL-left-down
        !          1430: &A     CONTROL-left-up
        !          1431: &b     SHIFT-left-down
        !          1432: &B     SHIFT-left-up
        !          1433: &d     META-left-down
        !          1434: &D     META-left-up
        !          1435: &e     CONTROL-SHIFT-left-down
        !          1436: &E     CONTROL-SHIFT-left-up
        !          1437: &f     META-SHIFT-left-down
        !          1438: &F     META-SHIFT-left-up
        !          1439: &g     CONTROL-META-left-down
        !          1440: &G     CONTROL-META-left-up
        !          1441: 
        !          1442: &m     middle-down
        !          1443: &M     middle-up
        !          1444: &h     CONTROL-middle-down
        !          1445: &H     CONTROL-middle-up
        !          1446: &i     SHIFT-middle-down
        !          1447: &I     SHIFT-middle-up
        !          1448: &j     META-middle-down
        !          1449: &J     META-middle-up
        !          1450: &k     CONTROL-SHIFT-middle-down
        !          1451: &K     CONTROL-SHIFT-middle-up
        !          1452: &n     META-SHIFT-middle-down
        !          1453: &N     META-SHIFT-middle-up
        !          1454: &o     CONTROL-META-middle-down
        !          1455: &O     CONTROL-META-middle-up
        !          1456: 
        !          1457: &r     right-down
        !          1458: &R     right-up
        !          1459: &p     CONTROL-right-down
        !          1460: &P     CONTROL-right-up
        !          1461: &q     SHIFT-right-down
        !          1462: &Q     SHIFT-right-up
        !          1463: &s     META-right-down
        !          1464: &S     META-right-up
        !          1465: &u     CONTROL-SHIFT-right-down
        !          1466: &U     CONTROL-SHIFT-right-up
        !          1467: &v     META-SHIFT-right-down
        !          1468: &V     META-SHIFT-right-up
        !          1469: &x     CONTROL-META-right-down
        !          1470: &X     CONTROL-META-right-up
        !          1471: 
        !          1472: Note  that META-L is shown as &L, etc. (On a VS100 keyboard, the Symbol key is
        !          1473: the META key, so for example you type META-l by holding down the Symbol key and
        !          1474: pressing the L key, and META-L by holding down the Shift key and the Symbol key
        !          1475: and pressing the L key.)
        !          1476: 
        !          1477: The default action for these escape sequences is to do nothing,  but  you  can
        !          1478: define them as any sequence of characters in the same way you would (re)define
        !          1479: any escape sequence.  Additional escape sequences are  available  for  defining
        !          1480: the buttons:
        !          1481: &c     scrolls  the  window so that the cursor ends up on the same line as the
        !          1482:        last/current button event.  This line must be within the same window as
        !          1483:        the cursor or an error will result.
        !          1484: &C     sets the cursor to the position of the last/current button event.  This
        !          1485:        position must be within the same window as the cursor or an error  will
        !          1486:        result.
        !          1487: &t     turns on tracking of the mouse and highlighting of the text between the
        !          1488:        cursor  and  the  mouse  if  #>0,  and  turns  tracking  off  if  #<=0.
        !          1489:        Highlighting is performed by underlining if #=1, and by  inverse  video
        !          1490:        if #>1.
        !          1491: &T     sets  the  mark to the position of the last/current button event.  This
        !          1492:        position must be within the same window as the cursor or an error  will
        !          1493:        result.
        !          1494: &w     is  equivalent  to  doing  a  ^X^W#D  into  the  window  containing the
        !          1495:        last/current button event position.  This position must be within  some
        !          1496:        window or an error will result.
        !          1497: &W     is  equivalent  to  doing  a  ^X^W#^N  into  the  window containing the
        !          1498:        last/current button event position.  This position must be within  some
        !          1499:        window or an error will result.
        !          1500: &Y     inserts  the  window  system  global cut buffer |#| times at the cursor
        !          1501:        (#<0 inserts before the cursor
        !          1502: &z     stores the current saved text in the window system global cut buffer.
        !          1503: &Z     stores the current deleted text in the window system global cut buffer.
        !          1504: 
        !          1505: For example, with the following lines in  your .ted_init,  you  can  delete  a
        !          1506: highlighted  region  of text by placing the mouse on the first character of the
        !          1507: text, pressing the left button down, moving to just after the last character of
        !          1508: the text, and raising the button:
        !          1509: 
        !          1510: ^[^[&l^Q^[^Q&W^Q^[^Q&C^Q^[^Q&t^M
        !          1511: ^[^[&L^Q^U0^Q^[^Q&t^Q^[^Q&T^Q^VW^M
        !          1512: 
        !          1513: 
        !          1514: By default, the         various  function  and  keypad  keys  transmit  the  following
        !          1515: characters.    Note that the character META-c as a command gets interpreted the
        !          1516: same as the sequence "ESC c".
        !          1517: 
        !          1518: F1     &X
        !          1519: F2     &T
        !          1520: F3     &U
        !          1521: F4     &V
        !          1522: F5     &W
        !          1523: F6     &a
        !          1524: F7     &b
        !          1525: F8     &c
        !          1526: F9     &d
        !          1527: F10    &e
        !          1528: F11    esc
        !          1529: F12    ^H
        !          1530: F13    ^J
        !          1531: F17    &f
        !          1532: F18    &g
        !          1533: F19    &h
        !          1534: F20    &i
        !          1535: E1     &1
        !          1536: E2     &2
        !          1537: E3     &3
        !          1538: E4     &4
        !          1539: E5     &5
        !          1540: E6     &6
        !          1541: ,      &l
        !          1542: -      &m
        !          1543: .      &n
        !          1544: 0      &p
        !          1545: 1      &q
        !          1546: 2      &r
        !          1547: 3      &s
        !          1548: 4      &t
        !          1549: 5      &u
        !          1550: 6      &v
        !          1551: 7      &w
        !          1552: 8      &x
        !          1553: 9      &y
        !          1554: UP     &A
        !          1555: DOWN   &B
        !          1556: RIGHT  &C
        !          1557: LEFT   &D
        !          1558: ENTER  &M
        !          1559: PF1    &P
        !          1560: PF2    &Q
        !          1561: PF3    &R
        !          1562: PF4    &S
        !          1563: **** XTED features ****
        !          1564: 

This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.