 27 37
 2 2 2 2 2 2 2 2
 2 2 2 2 2 2 2 2
 4 2 2 2 2 2 3 2
 2 2 3 2 2 2 2 2
 2 2 2 2 8 ( 0 ) 0 < 0 > 0 | 0 = 0 ! 0
 0 25 1 28 2 15 3 25 4 15 5 23 6 21 7 25
 8 45 9 25 A 26 B 4 C 22 D 10 E 20 F 18
 G 2 H 20 I 17 J 35 K 15 L 27 M 14 N 13
 O 2 P 28 Q 31 R 32 S 17 T 13 U 18 V 18
 W 13 X 47 Y 2 Z 5 ? 22 + 10 - 11 , 4
 : 9 ; 9 $ 13 ^ 10 . 15 * 9 / 12 \ 12
 & 6 ' 11 " 10 # 8 [ 11 ] 5 ~ 14 % 15
 @ 3
 _
// The above is a directory for this file. Its format is:
// d k
// e1, e2, ... ek
// c1 m1 ... cz mz _
// where d is the position of the first error message
//       k is the number of error messages
//       ei is the size of the i-th error message
//       mi is the size of the help message associated with
//          the character ci.
// Last modified 1988-01-25  RDE:chef   J6,66
.
Attention interrupt.
.
The control line or control character is invalid.
.
The work space is empty.
.
End of file.
.
Nesting of the XC and XF commands is not allowed.
.
A negative line number has been given.
.
The operators E H N Q U and X are not allowed after X.
.
There should be no location before the operators E H L N Q U W XF and ?.
.
The location should be one line only.
.
The file cannot be accessed.
.
The line is out of range.
.
The second line is out of range.
.
The tag is missing.
.
The file name is missing.
.
The closing delimiter has been omitted from a pattern or replacement.
.
The pattern or tag cannot be found.
.
The  work  space  is  full  up.   If you have done a lot of editing, try
writing your file out, leaving CHEF, then calling the editor again.   If
this does not work, then the file being edited must be split up.
.
The regions overlap.
.
There is an error in the class, i.e., after [ .
.
Unless you want to save the work, repeat the command.
.
The line range must be forwards.
.
The command is unknown or the command syntax is incorrect.
.
The operators F I J M T V and X may not have a control as
their location.
.
You have already had the error explained to you!
.
The pattern is too long.
.
A hexadecimal digit, or N, was expected following the escape symbol(H#).
.
The operators E, K, N, Q, U and X, and changes to controls,
cannot be undone (HU).
.
Macro expansion has exceeded the maximum depth of five.
.
Nothing to undo.
.
The command line is too long.
.
The resulting text line is too long.
.
The new piece of text is too long.
.
The last input line was too long.
.
The operator or modifier is not available in this version of CHEF.
.
A control may not contain newline characters.
.
The new combination of margins, verges and threshold is unreasonable.
.
There  was  an error while writing to the output file.  Perhaps you have
exceeded your disk quota (run out of disk space).  BEWARE; CHEF may have
written a file  of  zero  or  reduced  length  before  encountering  the
error. Using  PURGE to reclaim space may delete all complete versions of
your  file;  use  a   selective   PURGE   instead,   or   delete   files
individually. You  can  use QS DIRECTORY to see what files exist, and QS
DELETE to delete them.
.
           EF stands for Edit a File.
           I stands for Insert lines.
           P stands for Print lines.
           D stands for Delete lines.
           WF stands for Write to a File.
           ? will tell you what you did wrong.

       For example:  EF X will bring the file X into the workspace
     ready  for  editing.   7I will insert lines after line 7 from
     the console until a dot-stop-line  is  encountered,  i.e.,  a
     line with a dot only.
           3,7P will print lines 3 to 7.
           4,8D will delete lines 4 to 8.
           WF X will write all lines to the file X.
       The syntax of a command is thus:
         <location><operator><modifier><operand>

       In  most  cases,  several  commands  may  appear on a line,
     separated by semicolons.  Try I  followed  by  ten  lines  of
     text, followed by a dot-stop-line.
       When the prompt character (>) reappears, try the commands
                3,7P; 5D; 1,9P; WF X .

       Good luck!  Try H1 or HH for further help.
.
       Patterns  are  useful for specifying a line when you do not
     know the line number.  They are usually enclosed in  /  or  \
     characters.
       Within    patterns,   certain   characters   have   special
     significance (which may be disabled by  preceding  them  with
     the 'escape' character #).

          .  matches any character.  (type H. to learn more)
          ^  matches the left margin.  (H^)
          $  matches the right margin.  (H$)
          *  means a repetition of the item preceding it (H*).

       For example, /^...$/ matches any line that contains exactly
     three  characters,  /A*/  matches (the longest) string of A's
     and /(.*)/ matches any parenthesized string of characters.
       /ABC/ is an example of a forward-searching-pattern.  It may
     stand anywhere in place of a line number.
       For example, /ABC/D will delete the next line forward  from
     the  current  line that matches the pattern /ABC/, i.e., that
     contains the consecutive characters ABC.
       \ABC\ is an example of a backward-searching-pattern.
       Both forward and backward searches  will  wrap  around,  if
     necessary, returning to the current line.
       Try /ABC/P or just /ABC/, since P is the default operator.
       Other special characters which need to be escaped are:
           #  [  ~  and of course / or \
       Try H2 or HP.
.
       The  current  line is represented by a dot (.) and the last
     line by a dollar ($).
       For example, .,$P (or just .,$) will print from the current
     line to the last line.
       The commands ,P; 1,P; ,$P;  1,$P  are  all  equivalent  and
     illustrate  that  the default lower line is 1 and the default
     upper line is $.
       An input line with no command at all prints the next  line,
     so  you  may  step  through  your file by simply pressing the
     enter or return key. If you step past the end of  your  file,
     the  printing  continues  with  the  first line - that is, it
     'wraps round'.
       Try 3,7P; ,7P; 3,P; ,P; ,; and then a null command.
       For further help try H3 or HP.
.
       The  command  R/pattern/new  text/  replaces   each   first
     occurrence of 'pattern' by 'new text' in each of the lines of
     the given location (default - the current line) (HR).
       To replace all occurrences on each line use RA/---/---/.
       If  the  new  text  contains  an  ampersand  (&) it must be
     escaped (H&).

       C stands for Change lines.
       For  example: 3,7C  is  equivalent  to  3,7D;  2I  ,  which
     replaces lines 3 to 7 by those entered from the console until
     a dot-stop-line is encountered.

       The  operators  I (insert (HI)) or C (change (HC)) may also
     take a source location on the right, possibly preceded by the
     modifier D (for delete).
       For example: I3,7 inserts (copies) lines 3 to 7 beyond  the
     current line.    2,4C6,9  changes  (replaces) lines 2 to 4 by
     (copies of) lines 6 to 9.
       The modifier F means input from a file; for example, $IF  X
     inserts all the lines from the file X after the last line.
       ID$ inserts and deletes (moves) the last line to beyond the
     current line.
       Try 1C$; ,P; $CD1; ,P
       Try H4.
.
       A  location  specifies  the  line  or lines over which some
     action is to occur.
       The default location is always the current line.
       A location may be a clue (H9) or a region, e.g., 7 ,  or
     3,7 .
       In  general,  a  region  is  a  sequence  of  finders  (H8)
     separated by commas (H,).
       If there is only one finder then its  value  specifies  one
     line.
       If  there  is  a  comma  in  a range, then an elided finder
     defaults to 1 for the lower bound and  to  $  for  the  upper
     bound,  e.g.,  the  command  ,P means 1,$P and the command ,7
     means 1,7P .
       Try H5.
.
          A more precise representation of the command syntax is:

            <location><operator><modifier><source>
               |(H4)       |       |          |
               |         A C D E   |          |
           +---+-+       F H I J   |     +----+------+
           |     |       K L M N   |     |           |
        <clue> <region>  P Q R S   | <location>  others, depending
          (H9)     |(H4) T U V W   |       (H4)    on the operator
                   |       X ?     |
                   |               |
           sequence of <finders>   a single character
                          |(H6)    depending on the operator
                          |
         arithmetic combination of <terms>  (H6)
                                     |
         +---------+---------+-------+--+-----------+
         |         |         |          |           |
       <integer>  <dot>   <dollar>   <pattern>   <tagger>
                   (H.)     (H$)        (H8)    (HT H' H")

       Try H6.
.
       A finder specifies a line.
       A  simple  example  of  a  finder  is 7 which specifies the
     seventh line.
       In general, a finder is an arithmetic combination of one or
     more terms (using + and/or -, but without parentheses).
       A term is either an integer or a dot (H.) or a dollar  (H$)
     or  a  pattern  or a negated pattern or a tagger or a negated
     tagger (H/ HT H' H").
       If a pattern or tagger is negated (preceded by ~), then  it
     matches a line not containing that pattern or not tagged with
     that tagger.
       The value of a dot is the current line, that of a dollar is
     the  last line, that of a pattern is a line which matches it,
     and that of a tagger is a line so tagged (HT).
       A term may be elided.
       If a term before the first + or - is elided, then an elided
     dot is assumed, e.g., +1 means .+1 .
       If a term after a + or a - is elided, then an elided  1  is
     assumed, e.g., -- means .-1-1 or .-2 .
       Try H7.
.
        Some other operators are:

       S, which stands for Segment and Save (or Store) parts of  a
     matched  line.  For example, if line 7 contains HEAD-TO-TAIL,
     then 7S/TO/UVW saves HEAD- in control line U, TO  in  control
     line V and -TAIL in control line W.  (HS H9)

       T,  which stands for Tag lines.  For example 7,9TK tags the
     lines 7 to 9 with the letter K (any character  will  do).   A
     tagged  line may be found later by using a "tagger", e.g., 'K
     is a tagger for the line tagged with K.

       A, which alters a line using a template,

       F, which 'folds' a line into two lines (HF).

       M, which merges two or more lines into one (HM).

       L, which stands for Load a parameter.  For example:
       L^5 sets the left margin to column 5.
       L$60 sets the right margin to column 60.
       Thereafter pattern matches will occur only from  columns  5
     to 60. (H^ H$ HL HS HT HA HF HM)
       Try H8.
.
       A pattern specifies a string of characters to be matched, a
     simple example being /ABC/, which matches a  line  containing
     ABC .
       A  pattern  may consist of one or more elements enclosed by
     delimiters. A delimiter is either / which  specifies  forward
     searching   for   a  match  or  \  which  specifies  backward
     searching.
       The  pattern  //  or  \\  specifies  the most recently used
     pattern.
       An element in a pattern may be a single (normal)  character
     or a special symbol or a character class.
       The special symbols in a pattern are: ^ $ . ~ * [

             ^ will match only the left margin,
             $ will match only the right margin,
             . will match any character,
             ~ indicates that the pattern element following it
               matches by exclusion rather than by inclusion.
             * indicates a repetitious match (longest possible)
               of the preceding element. e.g., / *$/ matches all
               trailing blanks.

       The characters [ and ] specify  an  element  of  a  pattern
     which is a character class, the characters of the class being
     enclosed in these brackets. A class specifies a match of  any
     one  of  the  characters  of  the class e.g., /[AEIOU] / will
     match any vowel which precedes a blank.
       The special symbols in a class are - and ], and a span  may
     be  specified  by  placing  the  special symbol - between two
     other characters, e.g., [A-Z0-9] will  match  any  letter  or
     digit, and so will [Z-A9-0].
       The  effect  of  any  special  symbol  may  be nullified by
     preceding it with an escape (H#).
       A # followed by two hexadecimal digits specifies an element
     of a pattern which could be an unprintable  character,  e.g.,
     the pattern /#00/ will match the ASCII null character (H#).
     #N or #n is a shorthand for #0A (the newline character).
       Normally,  upper  and  lower case characters are considered
     different  for  the  purposes  of  pattern  matching. The   L
     operator  may  be  used  to  make  the  editor  treat them as
     equivalent. This is done using the C modifier;  each  use  of
     the  command LC will reverse the treatment of upper and lower
     case letters in patterns (HL).
       Try H9.
.
       For each letter there is a control line.
       For example: @A (or @a) specifies control A.
       Controls may be used for temporary storage  of  text  or of
     commands or parts of commands.
       A  "clue",  e.g., @A, may appear in any reasonable place as
     a  location,  on  the left of an operator, or as a source, on
     the right of an operator (@AI is unreasonable,  but  7I@A  is
     reasonable). There  is  also  a  control  +  whose content is
     automatically executed  after  every  one-line  command  that
     alters the work- space.
       For example:
         @AP prints the content of control A.
         @BC changes the content of control B to that entered from
     the console.
         @+D  deletes  (empties)  control  + (but it may be filled
     again).
         9C@E changes line 9 to the content of control E.
         @FCD@G moves control line G to control line F.
       Control lines may be inserted (as macros) in command  lines
     by prefixing the letter with %.
       For example: if control line V contains -10,+10P; -10; PN ,
     then ;%V is a rather useful macro.  Try it!
       Now you have real power (including recursion).
       Try H@, H% and HK.
.
       The operator A stands for Alter a line using a template.
       The default location is the current line.
       The modifier may be A (all).
       If the modifier is A, then the operand may be a finder.
       The  specified  line  is  displayed,  preceded  by a margin
     symbol, and the user may  enter  B  (blank),  D  (delete),  I
     (insert), O (overlay), U (undo), % (control), a dot (stop) or
     an empty template.
       Characters  above a B are changed to a blank; those above a
     D are deleted; characters after and I  in  the  template  are
     inserted  at  the  position  of  the  I; those after O in the
     template are overlaid.  If a U  is  in  column  1,  then  the
     previous  state  is  restored.   After  a % there is a letter
     (control) or another % and the text from the position of  the
     (first)  % is replaced with the content of the control or the
     entry from the console.
       If the template is a dot in column 1, then the  command  is
     terminated.
       If  the template is empty, then the next line of the range,
     if any, is displayed for template editing.
       If the modifier is A, then the template may come  from  the
     console,  a  workspace  line  or a control.  This template is
     then used for all lines of the range.
       E.G., 3,7AA@B edits lines 3,7 with template from control B.
       A may also be a modifier for P, R, S or X (HP HR HS HX).
.
       B  is not a CHEF operator, except that it will be displayed
     by the undo command (HU) to show that some Back  substitution
     or Back insertion occurs.
.
       The operator C stands for Change.
       The default location is the current line.
       The modifiers allowed are F (file) or D (delete).
       The source on the right may be a location,  a  filename  or
     null.
       The lines given by the location are changed to those of the
     source.
       If the modifier is F then a file name follows.
       If  the source is a location then the text of the new lines
     comes from that location
       If the modifier is D (delete), then the lines of the source
     are deleted.
       If the source is null, then the text of the new lines comes
     from the console.
       The current line is set to the last line changed.
       Example:  1,$C  will  replace  all lines by what is entered
     from the console, 3,4C7,8 will change lines 3 to 4 to  copies
     of  lines  7  to 8, 3,4CD7,8 will do the same and then delete
     the source lines.
       C is also used as a modifier to the L operator (HL), the  F
     operator  (HF),  the M operator (HM) and the X operator (HX).
.
       The operator D stands for Delete.
       The default location is the current line.
       There should be no source and no modifier.
       Lines of the specified location are deleted.
       The  current  line  is  set to the line after the last line
     deleted, if it exists, otherwise to the last line.
       Example: $,$-1D will delete the last two lines, and set the
     current line to the new last line.
       D may also be a modifier for the C and I operators (HC HI).
.
       The operator E stands for Edit.
       There should be no location.
       If  there  is no modifier, the workspace is cleared and the
     currently remembered filename is cleared.
       If the modifier is F, a filename must follow; the workspace
     is cleared, the current filename  is  set  to  the  specified
     name,  and  that file is read into the workspace for editing.
     The number of characters in the file is displayed.
       A  dot  is  used  to  represent  the  currently  remembered
     filename.
       If  the  current work space has been saved, then it will be
     abandoned, otherwise a question mark is displayed  after  the
     name   of   the  file  that  should  be  saved. An  immediate
     repetition of the same command will abandon  the  work  space
     anyway (the ? operator, with no modifier, may intervene).
       The current line is set  to  the  last  line  of  the  work
     space.
       See also Write (HW).
       Example; EF. re-edits the current file.
.
       The operator F stands for Fold a line into two.
       The location is one line - default the current line.
       The modifier may be C.
       The operand is null, or a string within delimiters.
       The line is displayed and  the  user  enters  a  @  at  the
     position where the second line is to begin.
       The  two  new  lines  then replace the original one and the
     current line is set to the second of the two.
       If the modifier is C (clear),  then the leading blanks from
     the second new line are removed.
       If the operand is a string, then that string is prefixed to
     the second new line.
       Only  the  first  new line inherits any tag on the original
     line.
       The current line is set to the second new line.
       F is also a modifier to many commands; it indicates that  a
     file name is involved (HC HE HI HL HN HP HW HX H?).
.
       G is not a CHEF operator.
.
       Help is available as follows:
          0, ... ,9                 Tutorial
          A, ..., Z                 Operators
          ?+-,:;$^.*/\&'*#[]~%"@    Special symbols

     For example, type H0 for the first tutorial lesson.
       A brief summary of legal operators is:

A - alter line(s)                    N - start new workspace
C - change line(s)                   P - print line(s)
D - delete line(s)                   Q - quit, perhaps to system
E - edit a file                      R - replace string in line(s)
F - fold a line into two             S - segment line about string
H - print help messages              T - tag line(s)
I - insert line(s)                   U - undo command
J - justify line(s)                  V - view line(s) of workspace
K - conditionally kill command       W - write to file
L - load internal parameter          X - execute commands/file
M - merge line(s) of workspace       ? - query kind of error/parameter
.
       The operator I stands for Insert.
       The location is at most one finder whose default  value  is
     the  current  line.   It  may  be the pseudo line number 0 to
     insert material before line 1.
       The default source is the console.
       The modifiers F (file) or D (delete) are allowed.
       The command inserts the lines of the source AFTER the given
     location.
       If the modifier is F, then a file name must follow.
       If the modifier is  D  (delete),  then  the  lines  of  the
     source, which must be a region, are deleted.
       The current line is set to the last line inserted.
       E.g., 7IFABC inserts file ABC after line 7, and 3ID7,8 will
     insert  lines  7  to  8  after line 3 and then delete the old
     lines 7 to 8.
       I may also be a modifier to the R operator (HR).
.
       The operator J stands for Justify.
       The default location is the current line.
       The operand, on the right, is zero, one or two integers.
       If there are two integers, then they are the left and right
     "verges" respectively.  If there is only one integer, then it
     is the right verge,  and  the  left  verge  defaults  to  its
     previous  value  (initially  1).  If there are none then both
     default to their previous values (initially 1,65).
       There are no modifiers.
       Text  is  picked  up  from the first non-blank character of
     each line, (or from the left margin, whichever comes  first),
     to the right margin.
       The action is that the lines  of  the  location  are  right
     justified according to the following rules:
       - a blank line remains blank,
       -  a  sentence  end  (. ? ! :) followed by a new line or at
     least two or more spaces is recognized as such  and  gives  a
     two space separator.
       -  a  line  indented  beyond  the threshold, and having the
     centring symbol  (initially  ':')  in  column  1  is  centred
     (deleting the ':'),
       - an indented line remains indented,
       - a line indented beyond the threshold (initially column 6)
     is frozen,
       - otherwise;  a non indented line results in justified text
     from  the  left  verge  (initially  1)  to  the  right  verge
     (initially 65).
        Example:  /Dear  Friend/,/Yours sincerely/J50 will justify
     text from columns 1 to 50.
       All  tags  are  lost,  except for any on the first and last
     lines of the region; these will tag the first and last  lines
     of the new (justified) version of the region.
        The indentation threshold (T), the left verge (L), and the
     right verge (R) may be loaded (HL) or queried (H?).
.
       The operator K stands for Kill (conditionally).
       The default location is the current line.
     The right operand may be null, or a single  line  or  control
     which is treated as a command sequence.
       There are no modifiers.
       If  the  location  refers to a line that is not empty, then
     the command is equivalent to the null command.
       If the location refers to a line that is  empty,  then  all
     subsequent  concatenated  commands  will be abandoned and the
     commands of the right operand of K will be executed instead.
       For  example,  ,x/ABC/;p;@Ac;@Ak;r//%%/  prints  each  line
     containing ABC  for  inspection.    If the response is empty,
     then no replacement occurs; otherwise, ABC is replaced by the
     characters entered from the console.
.
       The operator L stands for Load a parameter.
       There should be no location.
       The  right  operand  is  a  string   or   an   integer   as
     appropriate.
       The  modifiers  allowed  are  C F L P R T V ^ $ : with  the
     following meaning.

          C the case search mode (H8),
          F the file name to remember,
          L the left verge (HJ),
          R the right verge (HJ),
          T the indentation threshold (HJ),
          V the verification mode (reversed on each LV) (H+),
          P the command prompt (on/off, reversed on each LP) (HP),
          ^ the left margin (H^),
          $ the right margin (H$),
          : the centring symbol (H:).

       Unreasonable combinations of margins  and  verges  are  not
     allowed.
       E.g.,  L^10;L$40;LF  ABC sets the left and right margins to
     10 and 40 respectively and makes ABC the currently remembered
     filename.
       The  current settings of parameters may be queried by using
     the ? operator (H?).
       L is also used as a modifier to the R operator (HR).
.
       The operator M stands for Merge.
       The default location is the current line.
       The  right  operand,  if present, should be a string within
     arbitrary delimiters..
       The modifier C is allowed.
       Lines   of   the  specified  location  are  merged  (joined
     together) into a single line. The current line is set to this
     line.
       If the modifier is 'C', any spaces and tabs adjacent  to  a
     join  are  removed  (Cleared).   If a pattern is given as the
     right operand, a copy of it is inserted at each join.
       Tags on all merged lines are removed.
       M may also be a modifier to the P operator (HP).
.
       The operator N stands for New work space.
       There should be no location (H5).
       The modifier F followed by a file name is allowed.
       The  current work space is remembered including the current
     line, the current pattern, the  current  file  name  and  its
     'altered' status.
       A fresh empty work space is provided, and if the source was
     not elided, then that file is read into it.
       The contents of the control lines are unaltered, and may be
     used to pass information between workspaces.
       N  is  also  used as a modifier to the V operator, where it
     causes the Next few lines to be printed.
.
       O is not a CHEF operator.
.
       The operator P stands for Print.
       The default location is the current line.
       The modifiers allowed are A C F L M or N.
       If the modifier is null, then the lines of the location are
     printed at the console.
       If  the  modifier is A (all) then the text of the lines and
     the line numbers are printed.
       If the modifier is C (count), then only the byte  count  of
     the location is printed.
       If  the modifier is F (file), then a file name follows, and
     the lines of the location are printed to that file.
       If the modifier is L (lucid), then  the  lines  are  listed
     Lucidly,  i.e.,  with  each unprintable character rendered in
     hexadecimal and preceded by a # and each # represented by ##.
       If the modifier is M (match positions) then a string should
     follow,  within  arbitrary  delimiters.  For each line in the
     region where there is a match  with  this  string,  the  line
     number is printed, followed by the position of each match.
       If the modifier is N (number), then the line number or line
     number(s) is (are) printed.
       The current line is set to the last line printed.
       Example: 1,$P (or ,P or ,) will print (display)  the  whole
     work space.
       P is also used as a modifier to the L  operator,  where  it
     controls  whether or not the command prompt '>' is displayed,
     and to the V operator, where it causes the Previous few lines
     to be displayed.
.
       The operator Q stands for Quit.
       There should be no location.
       There should be no source.
       The modifiers Q (quickly) and S (system) are allowed.

       Work  on  the  current  work  space  is abandoned. If the N
     operator has been used, the previously remembered work  space
     is restored, otherwise the editor exits.
       If  the modifier is null and the work space has been saved,
     then it will be  abandoned,  otherwise  a  question  mark  is
     displayed  after  the  name of the file that should be saved.
     An immediate repetition of the same command will  abandon  it
     anyway.  (the ? operator, with no modifier, may intervene).
       If the  modifier  is  Q,  then  all  work  spaces  will  be
     abandoned unless one of them has been altered and not saved.
       If  the  modifier  is S, then if there is no right operand,
     then a temporary exit to the operating system  will  be made;
     otherwise,  the  right  operand  will be executed as a system
     command.
       Examples: Q will abandon the  current  work  space.
                 QS FILES will list the names of your files.
       On  VMS,  QS may be used to call any DCL command.  If there
     is no right operand, a new copy of  the  DCL  interpreter  is
     invoked  to  process  commands; on logout from this, the edit
     continues where it left off.
       On UNIX, QS may be used to call any command normally called
     by  the  shell.  If there is no right operand, a new shell is
     invoked to process commands; when this  shell  is  left  (via
     control-D) the edit continues where it left off.
       On CP/M, QS is not yet available.
.
       The operator R stands for Replace.
       The default location is the current line.
       The  modifiers  A  (all),  I  (interactive),  L  (lower), U
     (upper) or a  decimal  digit  between  1  and  9  (occurrence
     number) are allowed.  The occurrence number defaults to 1.
       If  the modifier is L or U, the right operand is a pattern,
     e.g. /ABC/.  The first occurrence of this  pattern,  in  each
     line  of  the  location,  is converted to Lower case or Upper
     case respectively.
       In all other cases the right operand is a pattern  followed
     by a sequence of characters, the replacement, followed by the
     same delimiter as used for the pattern (e.g. /ABC/XY/).
       For  each  line  of  the  given  location,  the replacement
     replaces the specified occurrence of a  string  that  matches
     the pattern.
       If  the  modifier  is  A (all) or I (interactive), then all
     matched strings of each line are replaced.  In the case of I,
     a line is read from the console for each occurrence  starting
     at  the  given  occurrence  number;  if  its  first non-space
     character is not 'Y' or 'y', the replacement  does  not  take
     place.
       The  current  line  is  set  to  the  last  line in which a
     potential or actual replacement occurred.
       Example:   1,$R/$/-/  will add a hyphen to the end of every
     line.
       If  the  replacement  text  contains any newline characters
     (specified with #N), the line will be split into two or  more
     lines  as  required.  Only the first line inherits any tag on
     the original line.
       R is also a modifier to L or ? specifying the  right  verge
     (HJ).
.
       The operator S stands for Segment and Store (or Save).
       The location is one line whose default is the current line.
       The modifier may be A.
       The  right  operand  is  a pattern followed by zero or more
     characters which may specify controls.
       If there is no modifier, the head, match and tail  segments
     of the line are saved in the given controls, in order.
       If  the  modifier  is A, then the segments are defined with
     respect to all occurrences of the match, not just the first.
       Operand characters which do not specify controls  cause the
     corresponding segment to be not saved.
       For  example,  if the current line is 'axbcxdefxghij', then
     the command S/x/ABC  will  save  'a'  in  A,  'x'  in  B  and
     'bcxdefxghi' in C, but the command S/x/A-B-C will save 'a' in
     A, 'bc' in B and 'def' in C.
       In both cases the given line is not altered.
.
       The operator T stands for Tag.
       The default location is the current line.
       The  right operand is any character, except ';' or newline,
     which act as command terminators and  cause  removal  of  any
     tags on the lines of the location.
       All lines of the given location are tagged with  the  given
     character.
       These lines can be found later by using a tagger (H' H").
       The current line is set to the last line so tagged.
       Example: 1,3TA will tag the first three lines with an A.
       T is also a modifier to L or ? specifying  the  indentation
     threshold.
.
       The operator U stands for Undo.
       There should be no location.
       There should be no source.
       The  effect  is to undo a previous command that altered the
     work space.
       Operators are classified, with respect to undo, as:

             willing:   A C D F I J M R T
             neutral:   H L P QS S V W ?
             unwilling: E K N Q QQ U X

       A  willing  operator  can  be undone, an unwilling operator
     cannot be.
       Between a willing operator and  the  undo  operator  U  any
     number  of neutral operators may be used, e.g., 1,10D;1,20P;U
     will undo the deletion.
       U is also used as a modifier to the R operator (HR).
.
       The operator V stands for View.
       The default location is the current line.
       The right operand (if present) is an integer, the  "spread"
     (default is the last spread, initially 10).
       The modifiers permitted are N and P.
       There is no source.
       If the modifier is null, lines from the current line  minus
     the  spread  to the current line plus the spread are printed.
     The current line is not altered.
       If the modifier is P, the previous "2*spread" lines and the
     current line are printed. The current line is not altered.
       If the modifier is  N,  the  next  "2*spread+1"  lines  are
     printed,  and  the  current  line  is  set  to  the  last  of
     these. This is useful for stepping through a file a chunk  at
     a time.
       All lines are printed with line numbers, and any  tags  are
     also displayed.  An asterisk identifies the current line.
.
       The operator W stands for Write.
       There must be no location and no source.
       The modifier must be F and a file name follows.
       A  dot  is  used to represent the currently remembered file
     name.
       All the lines of the work space  are  written  out  to  the
     file.
       In  response,  the  number of characters written (including
     newlines) is displayed.
       The current line is not altered.
       Example: WF. will write the work  space  to  the  currently
     remembered file.
.
       The operator X stands for eXecute.
       The default location is the current line.
       The modifiers permitted are A, C, F or ~.

       If there is no modifier, or if the modifier is  ~,  then  X
     may be followed by a pattern or a tagger or by nothing (which
     is equivalent to the pattern /^/).  In this case the location
     must be a region, whose default is the current line.
       The  command is then usually followed, on the same line, by
     other commands (separated by semicolons)  all  of  which  are
     said to be in the scope of the eXecute.
       The action is as follows:
       -- first, all lines in the location which match the pattern
     or  tagger  are  flagged, unless the modifier is ~ , in which
     case all such lines which do not match are flagged,
       -- then, each line that was flagged is, in turn, considered
     as the current line and all the commands in the scope of  the
     eXecute are obeyed.
       The lines are considered forwards from the lower  bound  of
     the region if the tagger begins with an apostrophe (') or the
     pattern   begins   with  a  slash  (/);  otherwise  they  are
     considered backwards from the upper bound of the range.

       If the modifier is A, then the  previous  command  line  is
     displayed  for  template  editing as for the A operator (HA).
     If the template is empty, then the corrected command line  is
     executed  again.   If  the  template  is  a dot only then the
     corrected command is not executed.

       If the modifier is C, then the  previous  command  line  is
     executed  again,  where  H,  L,  U  and ? are not regarded as
     previous.  XC commands may not be nested.

       If the F modifier is used, then it must be  followed  by  a
     file  name  and  the  location  may not be present.  The file
     following F is then used as a source of editor commands until
     an end of file is reached.

       The current line is set by the last command executed.
       The operators E X N Q U may not be in the scope of X.
       Example:  ,X/PROC/;P will print all the lines that  contain
     PROC.

       If there are too many commands in the scope of X to fit  on
     one line, they may be placed in control lines and called from
     there (H8 H%).
.
       Y is not a CHEF operator.
.
       The  operator  Z may be used to check information about the
     implementation.
       The user should not need it.
       Try the ? operator (H?).
.
       The operator ? stands for:   What is it?.
       There should be no location.
       There should be no source.
       The modifiers C F L R T V ^ $ : / \ are allowed.
       If  there is no modifier, then the current error message is
     displayed; othewise, the value of the system  parameters  are
     displayed as follows:

          C the current case search mode (HC),
          F the currently remembered file name,
          L the current left verge (HJ),
          R the current right verge (HJ),
          T the current indentation threshold (HJ),
          V the current verification mode (H+),
          ^ the current left margin (H^),
          $ the current right margin (H$),
          : the current centring symbol (H:),
          / the current pattern (H8),
          \ same as /.

       The current line is not changed.
.
       The symbol + when used within a finder stands for addition,
     e.g., .+3 means the current line plus 3.
         If  a term is elided before the first + of a finder, then
     an elided dot is assumed, e.g., +1 means .+1 .
         If a term is elided after a plus, then  an  elided  1  is
     assumed, e.g., + means .+1 .
       The  symbol  +  also  stands  for  a  special control whose
     content is executed after every one-line command that  alters
     the work-space, if the verification mode is 'On'.
.
       The  symbol - when used in a finder stands for subtraction,
     e.g., $-1 means the penultimate line.
       If a term is elided before the first - of a finder, then an
     elided dot is assumed, e.g., -1 means .-1 .
       If a term is elided after a -, then an elided 1 is assumed,
     e.g., -- means .-1-1 .

       As a special symbol in a class it specifies a  span,  e.g.,
     /[A-Z][A-Z0-9]*/ matches an identifier.
       To specify an actual - in a class use the escape (H#).
.
       The symbol , is used between two finders to make a range.
       The default finder before a comma is 1 and after a comma is
     $, so a lone , is equivalent to 1,$.
.
       The symbol : may be used for two purposes. It is used after
     a  finder  to signify that the value of that finder should be
     used to set the current line.
       It is also used as the initial value for the line centring
     symbol, and as a parameter to set and query that symbol  (HL,
     H?).
       Example: 1:/BEGIN/,/END/ will find the first ALGOL 60 block
     of the work space.
.
       The  symbol  ;  may  be used to separate commands when more
     than one command is entered on the same line.
       Commands  in  the  scope  of  an  execute  (X)  are  always
     separated by a semicolon (HX).
       Note  that  the default operator is null (not P) when there
     is more than one command on the input line.
       E.g., 10; serves  to  make  10  the  current  line  without
     displaying it.
.
       The symbol $ may be used for two purposes.
       As  a  term in a finder it specifies the number of the last
     line of the work space.
       As the last character of a pattern it  specifies  that  the
     pattern must  match  at  the  right  margin.    In  any other
     position in a pattern it has no  special  significance.    To
     specify  an  actual $ at the end of a pattern, use the escape
     symbol e.g., /ABC#$/.
       Example: R/$/./ places a dot at  the  end  of  the  current
     line.
       It  may  also  be  used  as a modifier to L or ? (HL H?) to
     specify the right margin.
.
       The symbol ^ when  used  as  the  first symbol of a pattern
     specifies  that  the pattern must match from the left margin.
     In any  other  position  in  a  pattern  it  has  no  special
     significance.    To specify an actual ^ at the beginning of a
     pattern use the escape symbol, e.g., /#^ABC/ .
       Example: R/^/  /  shifts  the  current  line  right  by two
     positions.
       It  may  also  be  used  as a modifier to L or ? (HL H?) to
     specify the left margin.
.
       The symbol . may be used for four purposes.
       As an element of a pattern it signifies a match against any
     character.
       To  specify  an  actual  .  in  a  pattern, use the escape,
     e.g., /ABC#./ .
       Example: /(.)/  will  find  a  line  containing  a   single
     character within parentheses.
       As a term in a finder, it specifies the current line.
       A dot before the first + or - of a finder may be elided (H+
     H-).
       As the only character of an input line from the console, it
     signifies a dot stop line (HA HC HI).
       As the right operand of C, E, I, N, P or W it signifies the
     name of the currently remembered file (HC HE HI HN HP HW).
.
          The  symbol  *  ,  when  used  in a pattern, specifies a
     repetition, zero or more  times,  of  the  preceding  pattern
     element.   For  example,  /a*/ will match (the first longest)
     sequence of a's and /[A-Z][A-Z0-9]*/ will match an identifier
     of many programming languages.  To specify an actual asterisk
     in a pattern, use #*. An asterisk in  a  replacement  has  no
     special  meaning,  nor  does it have a special meaning as the
     first character of a pattern.
.
       The symbol / may be the delimiter of a pattern.
       It  signifies that the pattern should be used for a forward
     search for a match beyond the current line.
       The pattern // stands for the most recent pattern used.
       The search will wrap around back to  the  current  line  if
     necessary  and  the  current  line  is  reset if the match is
     successful.
       Example: /ABC/ will match the next line  forward  from  the
     current line containing ABC.
       /  may  be  used  as  a  modifier to ?, to display the most
     recent pattern.
.
       The symbol \ may be the delimiter of a pattern.
       It  signifies that the pattern is to be used for a backward
     search.
       The pattern \\ stands for the most recent pattern used.
       The search will wrap around back to  the  current  line  if
     necessary  and  the  current  line  is  reset if the match is
     successful.
       Example: \ABC\ matches the next line before the current one
     that contains ABC.
       \  may  be  used  as  a  modifier to ?, to display the most
     recent pattern.
.
       The symbol & is used in a replacement to specify the string
     that was matched.
       If an actual & is to be specified in  a  replacement,  then
     the escape symbol should be used, e.g., /ABC#&DEF/.
       Example, R/BC/(&)/ will change the line ABC to A(BC).
.
       The symbol ' is used in a tagger preceding a character.
       It specifies that a forward search should be made from  the
     current  line  for  the  first  line  tagged  (HT)  with that
     character.
       This search will wrap around and return to the current line
     if necessary, and the current line is reset if  the  line  is
     found.
       Example:  'A  will  match the first line beyond the current
     line that was tagged with A.
       A tagger, e.g., 'A may also be used after X.
.
       The symbol " is used in a tagger preceding a character.
       It specifies that a backward search should be made from the
     current  line  for the first line tagged with that character.
       This search will wrap around  and  return  to  the  current
     line, if necessary, and the current line is reset if the line
     is found.
       Example:  ,X~"A;D  will  delete lines that were not flagged
     with an A.
       A tagger, e.g., "A may also be used after X.
.
       The symbol # is  used  as  the  general  escape  symbol  to
     nullify  the  meaning  of  some  special  symbol, or before a
     hexadecimal character value.
       In   a   pattern  or  replacement,  a  #  followed  by  two
     hexadecimal digits represents a  character  in  ASCII,  e.g.,
     #00 is the null ASCII character.   Additionally, #N or #n
     represents the newline character.
.
       The  symbol  [  specifies  the beginning of an element in a
     pattern which is a class of characters.  The  class  is  then
     closed by the symbol ].
       This  pattern  element  specifies  a  match  with  any  one
     character of the class.
       Example:  /[0123456789]/  will match any character that  is
     a decimal digit.
       To specify an actual [ in a pattern, or an actual - or ] in
     a class use the escape (H#) but within a class a  [  need not
     be escaped nor need a - or ] be escaped outside a class.
.
       The symbol ] specifies the end of a class.
       To specify an actual ] within a class, use an escape (H#)
       Example:  /[()[#]]/  will  match  any  one  of  two sets of
     parentheses.
.
       The symbol  ~  has special significance within a pattern
     or before a pattern or tagger or as a modifier to X.
       Within a pattern it  signifies  that  the  pattern  element
     which follows matches by exclusion rather than by inclusion.
       For example, /~&/ matches any character  which  is  not  an
     ampersand.
       Before  a  pattern  it indicates that the pattern matches a
     line by  exclusion  rather  than  by  inclusion,  e.g.,  ~/&/
     matches the next line not containing an ampersand.
       Before a tagger it indicates a match of the next  line  not
     tagged with that tagger.
       As a modifier to X it specifies that all lines not  matched
     will be flagged (HX).
.
       The symbol % if followed by a letter which corresponds to a
     control  line  will  result  in the '%' and that letter being
     replaced by the contents of that control line.
       For example, if control line R contains  334,789  then  the
     command ;%RP will print lines 334 to 789.
       The  symbol  %  when followed by a % will result in the two
     characters %% being replaced by input from the console.
       The  following  may  be  a useful macro to store in control
     lines D and E,  and is invoked with ;%D.
         @EP;,X/%%/;P;R//%%/;P
         Enter pattern -
      It will search for each occurrence of the given pattern  and
     then wait for its replacement as input from the console  (but
     see H@).
.
       The symbol @, when  used before a letter in the position of
     a finder, makes a clue (H9) which is the name of a  control.
.
