/* DESCRIBE_EMACS, EMACSSRC>EMACS*>INFO, EMACS DEVELOPMENT, 12/09/86
/* EMACS on-line documentation file, accessed by DESCRIBE command
/* Copyright (c) 1984, Prime Computer Inc., Natick, MA 01760
--*-- # Command and Function

           The # command or function tells whether line-numbering mode is  on.

           Command Format:  {ESC} X #

           Function Format:  (#)

           Argument:  A numeric argument, if specified, is ignored.

           Action:  EMACS  displays  either  "line  numbers  are off" or "line
           numbers are on" in the minibuffer.

           The # command returns the value NIL.


--*-- #off Command

           The #off command turns off line-numbering mode.

           Format:  (#off)

           Argument:  A numeric argument, if specified, is ignored.

           Action:  EMACS turns off automatic line-numbering  mode,  and  does
           not show line numbers at the left of the window.

           The #off function returns the value NIL.


--*-- #on Command

           The #on extended command turns on line-numbering mode.

           Format:  (#on)

           Argument:  A numeric argument, if specified, is ignored.

           Action:  EMACS turns on automatic line-numbering mode, so that line
           numbers are displayed to the left of the window.

           The #on function returns the value NIL.


--*-- & Function

           The & function is an abbreviation for the "and" function.


--*-- &args Keyword

           The &args keyword is an abbreviation of the &arguments keyword.


--*-- &arguments Keyword

           The &arguments  keyword starts the argument definition section of a
           defcom.  (See defcom for the complete syntax.)


--*-- &char_arg Keyword

           The  &char_arg    keyword    is    an    abbreviation    for    the
           &character_argument keyword.


--*-- &character_argument Keyword

           The &character_argument keyword is used with the defcom function to
           allow the  passing of the keystroke that invoked the command.  (See
           the description of defcom for the syntax.)   This  keyword  is  not
           particularly useful,  because  the  character_argument function can
           obtain and  return   this   information   regardless   of   whether
           &character_argument has been specified.


--*-- &doc Keyword

           The &doc  keyword is an abbreviation of the &documentation keyword.


--*-- &documentation Keyword

           The &documentation keyword is used in the defcom command  to  allow
           you to  specify a string description of the command.  It is used in
           help facilities, such as apropros and explain_key.   (See  defcom.)


--*-- &eval Keyword

           The &eval  keyword  reverses  the effect of the &quote keyword in a
           defun function definition, and specifies  that  all  the  following
           arguments are to be evaluated.  (See defun.)


--*-- &ignore Keyword

           The &ignore  keyword  is  used  in a defcom to specify that numeric
           arguments to the command being defined are to be ignored.


--*-- &integer Keyword

           The &integer keyword is used in a defcom with &args to specify that
           an argument has  the  integer  data  type.   (See  defcom  for  the
           complete syntax.)


--*-- &local Keyword

           The &local  keyword  is  used in a defun definition to specify that
           there are no further arguments in the function header, and that the
           remaining entries are local variables used only within the function
           being defined.


--*-- &macro Keyword

           The &macro keyword is used in a defun definition  to  specify  that
           the function returns a list that should be evaluated in the calling
           context.  (See defun for details.)


--*-- &na Keyword

           The &na keyword is an abbreviation of &numeric_argument.


--*-- &numeric_arg Keyword

           The &numeric_arg  keyword  is  used  in  a  defcom to specify how a
           numeric argument to the command is to be handled.


--*-- &optional Keyword

           The &optional keyword is used in a defun function header to specify
           that all  the  following  arguments  are  not  required.   Optional
           arguments   not  specified  when  the  function  is   invoked   are
           initialized to NIL.


--*-- &pass Keyword

           The &pass keyword is used in a defcom to  specify  the  name  of  a
           local variable  to which the value of the numeric argument is to be
           assigned.


--*-- &prefix Keyword

           The &prefix keyword is used in a defcom to indicate that  the  last
           invocation character  is  to  be inserted into the buffer as a side
           effect of the command.


--*-- &prompt Keyword

           The &prompt keyword is used in a defcom to cause a  local  variable
           (defined with  &args) to be prompted for, if it is not specified in
           the command's invocation.


--*-- &quote Keyword

           The &quote keyword is used in the  argument  list  of  a  defun  to
           specify that  EMACS should simply bind all the following arguments,
           without attempting to evaluate them, when the function is  invoked.
           The &eval keyword reverses the effect of a previous &quote keyword.


--*-- &repeat Keyword

           The &repeat  keyword  is  used  with  &numeric_arg  in  a defcom to
           specify that the numeric argument  to  the  command  indicates  the
           number of  times  that  the  body  of  the  defcom  code  should be
           executed.  (See defcom.)

           Format:  &na (&repeat)


--*-- &rest Keyword

           The &rest keyword is used in the argument list of a defun  to  tell
           EMACS to  take  the rest of the arguments and put them into a list.

           Format:  &rest (v list)

           Argument:  The argument v is any PEEL variable name.  As  shown  in
           the format, it must be given the list data type.

           Example:  &rest (r list)

           When the  function  is invoked, all the following arguments will be
           placed into a list assigned to the local variable r.


--*-- &returns Keyword

           The &returns keyword is used in a defun to specify  the  data  type
           returned by  the  function being defined.  This is the data type of
           the effect  of  the  function,  not  any  side-effect.   The  value
           returned by the function is specified by the return function.


--*-- &string Keyword

           The &string  keyword is used in a defcom with &args to specify that
           an argument has the string data type.


--*-- &symbol Keyword

           The &symbol keyword is used with &args in a defcom to specify  that
           the data type of the argument is a symbol.


--*-- * Function

           The * arithmetic function returns the product of its arguments.

           Format:  (* x1 [x2 ...  x8])

           Arguments:  * takes one through eight integer arguments.

           Action:  The  *  function returns an integer value representing the
           product of its arguments.  If there is only one argument, the value
           of that argument is returned.

           Example:  The function

                (* 3)

           returns the integer value 3, while

                (* 3 4 5)

           returns the integer value 60, obtained by multiplying  together  3,
           4, and 5.


--*-- *_list Function

           *_list is  a LISP function that constructs a list of its arguments,
           much like the list function.  The last argument becomes the cdr  of
           the last  cons  used  in  constructing the list.  It is an extended
           version of cons, and is thus useful  for  adding  elements  to  the
           front of a list.

           Format:  (*_list arg1 arg2 [arg3...arg8] )

           Arguments:  *_list  takes  two to eight arguments of any data type.

           Examples:  The following expression

                (*_list 'a 'b 'c 'd)

           is equivalent to

                (cons 'a (cons 'b (cons 'c 'd)))

           Both construct the following value:

                (a b c .  d)

           If d is a list (i j k), then the expression becomes:

                (*_list 'a 'b 'c '( i j k))

           This adds three elements  to  the  front  of  the  list  (i  j  k),
           constructing:

                (a b c i j k)


--*-- *catch Function

           The *catch function, derived from MACLISP, corresponds roughly to a
           non-local-goto   or  an  on-unit  definition  in  other  high-level
           languages.

           Format:  (*catch t s1)

           Arguments:  The argument t is an atom  (called  a  "tag"),  usually
           quoted.

           The argument s1 is a PEEL statement.

           Action:  The  *catch  function  returns  a  value  whose  data type
           depends upon execution of the argument.

           If multiple PEEL statements are required at s1, use a progn at  s1,
           and place the multiple statements within it.  The value returned by
           a progn is the value of the last statement in the progn.

           EMACS executes  the argument s1, stopping if a function of the form

                (*throw t v)

           is executed.

           If no such *throw function is executed,  then  *catch  returns  the
           value of the function s1.

           If a  *throw  function  in  the format just shown is executed, then
           execution of s1 is terminated immediately, and *catch  returns  the
           value v.

           Note:  The  *catch  function is like the catch function except that
           the argument order is different.  The order of arguments in  *catch
           is much easier to use.

           Examples:  Consider the following:

                 (*catch 'hello
                        ...
                     (if (> a 0)  (*throw 'hello "error"))
                        ...
                      a)

           If the value of a is positive at the time the if statement is
           executed, then execution of *catch will terminate, returning the
           value "error".  Otherwise, execution will continue, and unless
           stopped for some other reason, will continue to the form a, and
           *catch will return that value.

           The following example shows multiple *catches and *throws, and the
           use of progn.

               (print (*catch 'foo
                  (progn (setq a (prompt "hello"))
                         (if (= a "a") (*throw 'foo 20))
                         (print (*catch 'bar
                            (progn (setq b (prompt "goodbye"))
                                   (if (= b "b") (*throw 'foo 30))
                                   (if (= b "c") (*throw 'bar 100))
                                   ))))))

           Note that  you  can nest catches and throws.  For example, an outer
           *catch might catch "quit" throws, and  an  inner  one  might  catch
           argument errors.


--*-- *throw Function

           The *throw  function  is  a  standard LISP function that provides a
           function similar to invocation of an on-unit in other languages.

           Format:  (*throw t v)

           Arguments:  The argument t must be an atom,  usually  quoted.   The
           argument v can have any data type.

           Action:  The  function  is  legal  only within the argument list of
           *catch with the tag t.  (See the description of *catch for  further
           details.)

           Note:  The  *throw  function is like the throw function except that
           the argument order is different.


--*-- + Function

           The + arithmetic function adds together its arguments.

           Format:  (+ x1 [x2 ...x8])

           Arguments:  The + function takes at least one argument and no  more
           than eight  arguments.   All  arguments  must have the integer data
           type.

           Action:  The + function returns an integer value.  If there is only
           one argument, the value of that argument is returned.  If there  is
           more than  one argument, then + adds together all the arguments and
           returns their sum.

           Example:  The function

                (+ 3)

           returns the value 3, while the function

                (+ 3 4 5)

           returns the value 12, equal to the sum of 3, 4, and 5.


--*-- - Function

           The - arithmetic function either subtracts two arguments or negates
           a single argument.

           Format:  (- x [y])

           Arguments:  The argument x, and the argument y if  specified,  must
           be integer values.

           Action:  The  -  function  returns  an  integer value.  If y is not
           specified, - returns the value of -x.  If y is specified, - returns
           the value of (x-y).

           Examples:  The function (- 2)  returns  the  value  -2,  while  the
           function (- 10 5) returns the value 5.


--*-- / Function

           The / arithmetic function performs integer division.

           Format:  (/ x y)

           Arguments:  Both x and y must be integer values.

           Action:  The  /  function  returns  an  integer  value.   The value
           returned is (x/y), truncating if necessary.

           Note:  Truncation is always in the direction toward 0.   Therefore,
           for example, (/ 24 5) and (/ -24 -5) each return the value 4, while
           (/ -24 5) and (/ 24 -5) each return the value -4.


--*-- 1+ Function

           The 1+ arithmetic function returns the value obtained by adding one
           to its argument.

           Format:  (1+ x)

           Argument:  The argument x must be an integer.

           Action:  The 1+ function returns the integer value (x+1).

           Note:  The following two expressions are equivalent:

                (1+ x)
                (+ x 1)


--*-- 1- Function

           The   1-  arithmetic  function  returns  the  value   obtained   by
           subtracting one from its argument.

           Format:  (1- x)

           Argument:  The argument x must be an integer.

           Action:  The 1- function returns  the  integer  value  obtained  by
           computing (x-1).

           Note:  The following two expressions are equivalent:

                (1- x)
                (- x 1)


--*-- 2d Command and Function

           The 2d  extended  command or function tells whether two-dimensional
           mode is on.  (See 2don.)

           Command Format:  {ESC} X 2d

           Function Format:  (2d)

           Argument:  A numeric argument, if specified, is ignored.

           Action:  EMACS displays either "2d is off" or "2d  is  on"  in  the
           minibuffer.


--*-- 2doff Command and Function

           The 2doff  extended  command  or function turns off two-dimensional
           mode (see 2don).

           Command Format:  {ESC} X 2doff

           Function Format:  (2doff)

           Argument:  A numeric argument, if specified, is ignored.

           Action:  EMACS turns off two-dimensional mode.


--*-- 2don Command and Function

           The 2don extended command  or  function  turns  on  two-dimensional
           mode.

           Command Format:  {ESC} X 2don

           Function Format:  (2don)

           Arguments:  A numeric argument, if specified, is ignored.

           Action:  EMACS  turns  on  two-dimensional mode.  In this mode, you
           may use the cursor commands to move your  cursor  anywhere  on  the
           screen, even  where  there are no characters in the buffer.  If you
           insert a character on the  screen  at  a  point  on  a  line  where
           characters to  the  left  of the point have not previously existed,
           then EMACS automatically inserts blanks on  the  line  up  to  that
           point.


--*-- <, <=, =, ^=, >, >= Functions

           These relational  operators  test  the  relationship  between their
           arguments.

           Format:  (op arg1 arg2), where the op is one of the following:   <,
           <=, =, ^=, >, or >=.

           Arguments:  Each  of  the relational operators takes two arguments.
           Both arguments must have the same data type, and  the  common  data
           can be any.

           Action:  Each  of the relational operators returns a Boolean value,
           depending upon the  result  of  the  comparison.   The  <  function
           returns true  if  the  first  argument is less than the second, and
           false otherwise.  Similarly, the other functions compare  and  test
           as follows:   <=  is  the  less than or equal comparison;  = is the
           equal comparison;  ^= is  the  not  equal  comparison;   >  is  the
           greater than  comparison;   and  >=  is  the  greater than or equal
           comparison.

           If the  two  arguments  are  integers,  then  an  ordinary  integer
           comparison is performed.

           If the  arguments  are  strings, they are compared according to the
           rules to the ASCII collating sequence, after padding the string  to
           the length of the longer one with blanks, if necessary.

           If the  arguments  are  Boolean, then true is considered to be less
           than false.

           If the arguments are cursor values, then they must be in  the  same
           buffer, and  one  cursor  value  is  considered  to be smaller than
           another cursor value if it precedes the second one in  the  buffer.


--*-- <=, =, ^=, >, >=, < Functions

           These relational  operators  test  the  relationship  between their
           arguments.

           Format:  (op arg1 arg2), where the op is one of the following:   <,
           <=, =, ^=, >, or >=.

           Arguments:  Each  of  the relational operators takes two arguments.
           Both arguments must have the same data type, and  the  common  data
           can be any.

           Action:  Each  of the relational operators returns a Boolean value,
           depending upon the  result  of  the  comparison.   The  <  function
           returns true  if  the  first  argument is less than the second, and
           false otherwise.  Similarly, the other functions compare  and  test
           as follows:   <=  is  the  less than or equal comparison;  = is the
           equal comparison;  ^= is  the  not  equal  comparison;   >  is  the
           greater than  comparison;   and  >=  is  the  greater than or equal
           comparison.

           If the  two  arguments  are  integers,  then  an  ordinary  integer
           comparison is performed.

           If the  arguments  are  strings, they are compared according to the
           rules to the ASCII collating sequence, after padding the string  to
           the length of the longer one with blanks, if necessary.

           If the  arguments  are  Boolean, then true is considered to be less
           than false.

           If the arguments are cursor values, then they must be in  the  same
           buffer, and  one  cursor  value  is  considered  to be smaller than
           another cursor value if it precedes the second one in  the  buffer.


--*-- =, ^=, >, >=, <, <= Functions

           These relational  operators  test  the  relationship  between their
           arguments.

           Format:  (op arg1 arg2), where the op is one of the following:   <,
           <=, =, ^=, >, or >=.

           Arguments:  Each  of  the relational operators takes two arguments.
           Both arguments must have the same data type, and  the  common  data
           can be any.

           Action:  Each  of the relational operators returns a Boolean value,
           depending upon the  result  of  the  comparison.   The  <  function
           returns true  if  the  first  argument is less than the second, and
           false otherwise.  Similarly, the other functions compare  and  test
           as follows:   <=  is  the  less than or equal comparison;  = is the
           equal comparison;  ^= is  the  not  equal  comparison;   >  is  the
           greater than  comparison;   and  >=  is  the  greater than or equal
           comparison.

           If the  two  arguments  are  integers,  then  an  ordinary  integer
           comparison is performed.

           If the  arguments  are  strings, they are compared according to the
           rules to the ASCII collating sequence, after padding the string  to
           the length of the longer one with blanks, if necessary.

           If the  arguments  are  Boolean, then true is considered to be less
           than false.

           If the arguments are cursor values, then they must be in  the  same
           buffer, and  one  cursor  value  is  considered  to be smaller than
           another cursor value if it precedes the second one in  the  buffer.


--*-- ^=, >, >=, <, <=, = Functions

           These relational  operators  test  the  relationship  between their
           arguments.

           Format:  (op arg1 arg2), where the op is one of the following:   <,
           <=, =, ^=, >, or >=.

           Arguments:  Each  of  the relational operators takes two arguments.
           Both arguments must have the same data type, and  the  common  data
           can be any.

           Action:  Each  of the relational operators returns a Boolean value,
           depending upon the  result  of  the  comparison.   The  <  function
           returns true  if  the  first  argument is less than the second, and
           false otherwise.  Similarly, the other functions compare  and  test
           as follows:   <=  is  the  less than or equal comparison;  = is the
           equal comparison;  ^= is  the  not  equal  comparison;   >  is  the
           greater than  comparison;   and  >=  is  the  greater than or equal
           comparison.

           If the  two  arguments  are  integers,  then  an  ordinary  integer
           comparison is performed.

           If the  arguments  are  strings, they are compared according to the
           rules to the ASCII collating sequence, after padding the string  to
           the length of the longer one with blanks, if necessary.

           If the  arguments  are  Boolean, then true is considered to be less
           than false.

           If the arguments are cursor values, then they must be in  the  same
           buffer, and  one  cursor  value  is  considered  to be smaller than
           another cursor value if it precedes the second one in  the  buffer.


--*-- >, >=, <, <=, =, ^= Functions

           These relational  operators  test  the  relationship  between their
           arguments.

           Format:  (op arg1 arg2), where the op is one of the following:   <,
           <=, =, ^=, >, or >=.

           Arguments:  Each  of  the relational operators takes two arguments.
           Both arguments must have the same data type, and  the  common  data
           can be any.

           Action:  Each  of the relational operators returns a Boolean value,
           depending upon the  result  of  the  comparison.   The  <  function
           returns true  if  the  first  argument is less than the second, and
           false otherwise.  Similarly, the other functions compare  and  test
           as follows:   <=  is  the  less than or equal comparison;  = is the
           equal comparison;  ^= is  the  not  equal  comparison;   >  is  the
           greater than  comparison;   and  >=  is  the  greater than or equal
           comparison.

           If the  two  arguments  are  integers,  then  an  ordinary  integer
           comparison is performed.

           If the  arguments  are  strings, they are compared according to the
           rules to the ASCII collating sequence, after padding the string  to
           the length of the longer one with blanks, if necessary.

           If the  arguments  are  Boolean, then true is considered to be less
           than false.

           If the arguments are cursor values, then they must be in  the  same
           buffer, and  one  cursor  value  is  considered  to be smaller than
           another cursor value if it precedes the second one in  the  buffer.


--*-- >=, <, <=, =, ^=, > Functions

           These relational  operators  test  the  relationship  between their
           arguments.

           Format:  (op arg1 arg2), where the op is one of the following:   <,
           <=, =, ^=, >, or >=.

           Arguments:  Each  of  the relational operators takes two arguments.
           Both arguments must have the same data type, and  the  common  data
           can be any.

           Action:  Each  of the relational operators returns a Boolean value,
           depending upon the  result  of  the  comparison.   The  <  function
           returns true  if  the  first  argument is less than the second, and
           false otherwise.  Similarly, the other functions compare  and  test
           as follows:   <=  is  the  less than or equal comparison;  = is the
           equal comparison;  ^= is  the  not  equal  comparison;   >  is  the
           greater than  comparison;   and  >=  is  the  greater than or equal
           comparison.

           If the  two  arguments  are  integers,  then  an  ordinary  integer
           comparison is performed.

           If the  arguments  are  strings, they are compared according to the
           rules to the ASCII collating sequence, after padding the string  to
           the length of the longer one with blanks, if necessary.

           If the  arguments  are  Boolean, then true is considered to be less
           than false.

           If the arguments are cursor values, then they must be in  the  same
           buffer, and  one  cursor  value  is  considered  to be smaller than
           another cursor value if it precedes the second one in  the  buffer.


--*-- CtoI Function

           The CtoI  conversion  function  converts  a character to an integer
           value.

           Format:  (CtoI c)

           Argument:  The argument c must have the character  or  string  data
           type.

           Action:  The  CtoI function returns an integer value.  The value is
           greater than or equal to 0 and less than  or  equal  to  255.   The
           value returned is equal to the position of the character argument c
           in the ASCII collating sequence.

           If the  argument  c is a string, then the value for first character
           of c is returned.


--*-- ItoC Function

           The ItoC function converts an integer between  0  and  255  into  a
           character.

           Format:  (ItoC x)

           Argument:  The argument x must have the integer data type.

           Action:    The  ItoC  function  returns  a  character  value.   The
           character returned is equal to the character in position  x  modulo
           256 of the ASCII collating sequence.


--*-- ItoP Function

           The ItoP  conversion function converts an integer between 0 and 127
           into a Prime character with the high-order bit on.

           Format:  (ItoP x)

           Argument:  The argument x must be an integer.

           Action:  The ItoP function returns a  character  value.   Given  an
           argument x,

                (ItoP x)

           returns the same value as

                (ItoC (+ (modulo x 128) 128)


--*-- NL Global Variable

           NL is  a global variable having the character data type.  The value
           of NL is the new-line character.  You may imbed the value of NL  in
           strings.


--*-- PtoI Function

           The PtoI conversion function converts a Prime character, having the
           high bit on, into an integer between 0 and 127.

           Format:  (PtoI c)

           Argument:  The  argument  c must be a character value, usually with
           the high bit on.

           Action:  The PtoI function returns an integer value between  0  and
           127.  Given an argument c, the value of

                (PtoI c)

           is c with the high bit off, given by

                (modulo c 128)

           If the  argument  c is a string, then the value for first character
           of c is returned.


--*-- ^ Function

           The ^ function is an abbreviation for the not function.


--*-- ^= Function

           (See the = function listed under '<'.)


--*-- ^p_prev_line_command Command

           (See prev_line_command.)


--*-- ^q_quote_command Command

           (See quote_command.)


--*-- ^s_forward_search_command Command

           (See forward_search_command.)


--*-- | Function

           The | function is an abbreviation for the or function.  (See the or
           function for further information.)


--*-- abort_command Command

           The abort_command command and function aborts a command.

           Function Format:  (abort_command)

           Command Format:  {ESC} X abort_command or {CTRL-G}

           Argument:  A numeric argument, if specified, is ignored.

           Action:  The abort_command command permits the current  command  to
           be aborted.   For  example,  you  may use (abort_command) in a PEEL
           program at any point to terminate execution at that  point.   EMACS
           causes the terminal to beep and returns you to command level.

           The (abort_command) function does not return any value.


--*-- abort_minibuffer Command

           (See abort_command.)


--*-- abort_or_exit Command

           (See abort_command.)


--*-- af Function

           The af  function  inserts  the  results of an active PRIMOS command
           function invocation into the buffer at the current cursor position.

           Format:  (af s)

           Argument:  The argument s must have the string data type.

           Action:  The af function inserts the result  of  an  active  PRIMOS
           function invocation  into  your  text  buffer at the current cursor
           position.  The function returns NIL as its value.

           Example:  The function

                (af "[calc 4+5]")

           inserts the string "9" into your text buffer.


--*-- all_modes_off Command

           The all_modes_off command turns  all  modes  off  for  the  current
           buffer.

           Format:  {ESC} X all_modes_off

           Argument:  A numeric argument, if specified, is ignored.

           Action:  EMACS  turns  all  modes  off in the current buffer.  Note
           that any side-effects of turning a mode on (such as 2don in overlay
           mode) will not be cancelled.


--*-- and Function

           The and function is a Boolean operator  that  returns  the  logical
           "and" of its arguments.

           Format:  (and b1 b2 [b3 ...  b8] )

           Arguments:  The  and  function  takes at least two and no more than
           eight arguments.  All arguments must have the Boolean data type.

           Action:  The and function  returns  a  Boolean  value  computed  by
           taking the logical "and" of all of its arguments.  That is, the and
           function returns  the  value true if the value of all its arguments
           is true;  otherwise it returns the value false.

           Note that all arguments are evaluated, regardless  of  whether  any
           one is false, and the order of evaluation is unspecified.


--*-- any Data Type

           A variable with the any data type can take on any value of any data
           type supported  by PEEL.  Note that all undeclared global variables
           have by default the any data type.


--*-- append Function

           The append function is a standard LISP function  that  appends  all
           the items of one list to the end of another list.

           Format:  (append lst1 lst2)

           Arguments:  Both lst1 and lst2 must be lists.

           Action:  The  append  function  returns  a value with the list data
           type.  The value is computed by appending all the items in lst2  to
           the end of the items in lst1.

           Example:  The function

                (append '(a b c) '(d e f))

           returns the list (a b c d e f).

           Note:  The append function does not change the value of either list
           lst1 or lst2.


--*-- append_to_buf Command and Function

           The append_to_buf command or function appends the current region to
           a buffer.

           Command Format:  [{ESC}n] {ESC} X append_to_buf
                            or
                            [{ESC}n] {CTRL-X} A

           Function Format:  (append_to_buf [n [b]])

           Argument:  The  argument n, if specified, must be an integer value.
           The argument b, if specified, must be a string value.

           Action:  If the argument b is not specified, then EMACS prompts you
           with "buffer name:".  The string that you type is assigned  to  the
           variable b.

           The string  variable  b  is  interpreted  as  a buffer name.  EMACS
           appends the current region to that buffer.   This  means  that  the
           text in  the  current region is inserted at the end of that buffer.

           If n is not specified, then the  text  in  the  current  region  is
           deleted, meaning that the append operation is in effect a move.  If
           n is  specified,  then the text is copied, and the marked region is
           not deleted.


--*-- append_to_file Command

           The append_to_file command appends the current region to a file.

           Format:  [{ESC}n] {ESC} X append_to_file
                    or
                    [{ESC}n] {CTRL-X} {CTRL-Z} A

           Argument:  The argument n, if specified, must be an integer  value.

           Action:  The  append_to_file  command  prompts you for a file name,
           and then appends the current region to that file.  This means  that
           the text in the current region is inserted at the end of that file.

           If the  argument n is not specified, then EMACS deletes the text in
           the current region.  This means that the append  operation  is,  in
           effect, a move.

           If the  argument n is specified, then EMACS copies the text without
           deleting the marked region.


--*-- apply Function

           The apply function is a  standard  LISP  function  that  applies  a
           function to a list of arguments.

           Format:  (apply f lst)

           Arguments:  The  value  of  f must be a function.  The value of lst
           must be a list.

           Action:  EMACS applies the function f to the list of  arguments  in
           lst.

           Example:

                (setq add_elements (fsymeval '+))
                (setq scores '(1 2 5))
                (apply add_elements scores)

           The apply  function  returns the value 8, obtained by computing the
           value of (+ 1 2 5).  (See fsymeval.)

--*-- apropos Command and Function

           The apropos command or function provides an extended help  facility
           that retrieves a list of commands that match a string.

           Command Format:  {ESC} X apropos

           Function Format:  (apropos [s])

           Argument:  A numeric argument, if specified, is ignored.

           The argument s, if specified, must be a string value.

           Action:  If  s  is  not specified, then EMACS prompts you, with the
           prompt "Apropos:"  in the minibuffer, for a string s.

           EMACS goes through all its handlers (defcoms or built-in  handlers)
           that have  been  loaded  and looks for a match between s and either
           the name of the handler or its documentation string.

           EMACS also looks for key bindings for any functions  bound  by  the
           previous search.

           All this information is displayed on your screen.

           The apropos function returns NIL.

           Note:  When you use defcom to define a new command, you may use the
           &doc operation  to  specify  a  documentation  string  for  the new
           command.  The   apropos   command   or   function   displays   that
           documentation string for an appropriate argument string s.


--*-- aref Function

           The aref function returns the value of an array element.

           Format:  (aref a x)

           Argument:  The  argument  a  must  be  an  array,  and is usually a
           variable name to which an array has been bound by means of setq and
           make_array.  The value of x must be a nonnegative integer less than
           the number of elements in the array (arrays are indexed from 0).

           Action:  If the value of x  is  0,  then  aref  returns  the  first
           element of  the  array a.  In general, aref returns that element of
           the array a with index x, that is, the (x+1)st element of the array
           a.


--*-- array Data Type

           A value with the array  data  type  is  created  by  means  of  the
           make_array function.


--*-- array_dimension Function

           The array_dimension  function  returns the number of elements in an
           array.

           Format:  (array_dimension a)

           Argument:  The argument a  must  be  an  array.   Usually  a  is  a
           variable to  which  an  array  has  been bound by means of setq and
           make_array.

           Action:  The array_dimension  function  returns  an  integer  value
           equal to the number of elements in the array.

           Example:  The function

                (array_dimension (make_array 'integer 20))

           returns the value 20.


--*-- array_type Function

           The array_type function returns the data type of an array.

           Format:  (array_type a)

           Argument:  The  argument a must be an array.  Usually a is a symbol
           to which an array value  has  been  bound  by  means  of  setq  and
           make_array.

           Action:  The  array_type  function  returns  an atom specifying the
           data type of the array.  The data type is the same as was specified
           in the make_array function that created the array.


--*-- aset Function

           The aset function stores a value into an array element.

           Format:  (aset v a n)

           Argument:  The argument a must be an array value.  Usually a  is  a
           variable to  which  an  array  value has been bound by means of the
           setq and make_array functions.

           The argument v must have a value whose data type is the same as the
           data type of the array a, as specified in the  make_array  function
           that created the array.

           The argument n must have a non-negative integer value less than the
           number of elements in the array.

           Action:  If  the  value of n is 0, then aset sets the first element
           of the array a to the value v.  In general, aset sets the value  of
           the (n+1)st element of the array a to the value v.

           The aset function returns the value v.


--*-- assoc Function

           The assoc function looks up an item in a LISP association list.

           Format:  (assoc k lst)

           Argument:  The  argument  lst  must  be  an  association  list,  as
           described below.  The argument k may have any data type.

           Action:  An association list is really a list of lists.  The car of
           each sublist is called the "key", and the cdr of  each  sublist  is
           the value  associated with the key.  The assoc function returns the
           sublist associated with the key k in the association list lst.   If
           key k is not found in the association list, assoc returns NIL.

           Example:  The  following  example  illustrates  various uses of the
           assoc function:

                (setq joe '((name "Joe Smith") (age 27)
                                      (phone "234-1234")))
                (assoc 'phone joe)       -> (phone "234-1234")
                (assoc 'age joe)         -> (age 27)
                (assoc 'quux joe)        -> ()


--*-- assure_character Function

           The assure_character function returns the next  keyboard  character
           typed without removing it from the input buffer.

           Format:  (assure_character [raw])

           Argument:  The argument raw, if specified, must be the atom raw.

           Action:  The assure_character function waits until there is a typed
           character in  the  input buffer.  It then returns the value of that
           character, without removing that character from the  input  buffer.

           If the  argument  raw is specified, then a "raw read" is performed,
           and no special handling, such as "help on tap", is supported.

           Example:  The function

                (assure_character raw)

           does a raw read to input  the  next  character  from  the  terminal
           without removing it from the input buffer.


--*-- at_white_char Function

            The at_white_char  function  returns  a  Boolean  value indicating
            whether the cursor is at a whitespace character.

            Format:  (at_white_char)

            Arguments:  None.

            Action:  The at_white_char function returns a Boolean value.   The
            value is  true  if  the character to the right of the cursor is in
            the string bound to the atom whitespace;  otherwise, it is  false.


--*-- atom Function

           The atom  function  is  a  standard  LISP  function  that indicates
           whether or not the argument is an atom.

           Format:  (atom v)

           Argument:  The argument v may have any data type.

           Action:  The atom function returns a Boolean value.  The  value  is
           true if  the argument v is not a list structure, that is, neither a
           cons nor NIL.


--*-- autoload_lib Function

           The autoload_lib function fasloads a file and  executes  the  given
           command.

           Format:  (autoload_lib c s)

           Arguments:  The argument c must be an atom representing the name of
           a command.  The argument s must be a string.

           Action:  The  string  specified  by the argument s must be a PRIMOS
           pathname for a  package  containing  a  redefinition  of  the  atom
           specified by  the  argument  c.  EMACS opens for input the filename
           obtained by adding the suffix .EFASL to  the  string  s,  and  then
           loads and  executes  that file as a fasload file, thereby executing

           the command given by the atom c.  If EMACS cannot find  the  .EFASL
           file, it looks for the corresponding .EM file instead, and compiles
           it with the pl command.

           The autoload_lib function returns the value NIL.

           Note:  This  function  is  useful when you have an external command
           for which you wish to defer the loading until it is actually  used.


--*-- back_char Command and Function

           The back_char  command  or  function  moves  the  cursor  back by a
           specified number of characters.

           Command Format:  [{ESC}n] {ESC} X back_char
                            or
                            [{ESC}n] {CTRL-B}

           Function Format:  (back_char [n])

           Argument:  The argument n, if specified, must be an integer.

           Action:  If n is not specified, then let n equal 1.

           If the value of n is 0, then no action takes place.

           If the value of n is positive, then the  cursor  is  moved  back  n
           characters, stopping if the beginning of the buffer is reached.

           If the  value  of  n  is negative, then the cursor is moved forward
           (-n) characters, stopping if the end of the buffer is reached.

           The back_char function returns the value NIL.


--*-- back_page Command and Function

           The back_page command or function moves the window back a group  of
           lines, usually 18.

           Command Format:  [{ESC}n] {ESC} X back_page
                            or
                            [{ESC}n] {ESC} V

           Function Format:  (back_page [n])

           Argument:  The argument n, if specified, must be an integer.

           Action:  If n is not specified, let n equal 1.

           If the value of n is 0, no action takes place.

           If the  value  of  n is positive, the window is moved back n pages,
           stopping if the beginning of the buffer is reached.  The cursor  is
           left at approximately the middle of the window.

           If the  value  of  n  is negative, the window is moved forward (-n)
           pages, stopping if the beginning of the  buffer  is  reached.   The
           cursor is left at approximately the middle of the window.

           The back_page function returns the value NIL.


--*-- back_tab Command and Function

           The back_tab  command  or  function  moves  the  cursor  back  by a
           specified number of tab stops.

           Command Format:  [{ESC}n] {ESC} X back_tab

           Function Format:  (back_tab [n])

           Argument:  The argument n, if specified, must be an  integer  whose
           value may be positive, 0, or negative.

           Action:  If n is not specified, let n equal 1.

           If the value of n is 0, no action takes place.

           If the  value of n is positive, the cursor is moved back n tab stop
           positions, stopping if the beginning of the line is reached.

           If the value of n is negative, the cursor is moved forward (-n) tab
           stop positions.   If  the  end  of  the  line  is  reached,   EMACS
           automatically fills  the  end of the line with blank characters, up
           to the desired tab stop position.

           The back_tab function returns the value NIL.


--*-- back_to_nonwhite Command and Function

           The back_to_nonwhite command or function puts the cursor  onto  the
           first nonwhite  character  on a line.  (A nonwhite character is any
           character not bound to the atom whitespace.)

           Command Format:  [{ESC}n] {ESC} X back_to_nonwhite
                            or
                            [{ESC}n] {ESC} M

           Function Format:  (back_to_nonwhite [n])

           Argument:  The argument n, if specified, must be an  integer  whose
           value may be positive, 0, or negative.

           Action:  If n is not specified, let n equal 1.

           If n does not equal 0 or 1, do the following:

               o  If n is greater than 1, execute

                       (next_line (1- n))

               o  If n is less than 0, execute

                       (next_line n)

                EMACS then moves the cursor  back  or  forward  to  the  first
                nonwhite character  on  the  current  line.   If  there are no
                nonwhite characters on the line, EMACS moves the cursor to the
                end of the line.

                The back_to_nonwhite function returns the value NIL.


--*-- back_word Command and Function

           The back_word command or  function  moves  the  cursor  back  by  a
           specified number of words.

           Command Format:  [{ESC}n] {ESC} X back_word
                            or
                            [{ESC}n] {ESC} B

           Function Format:  (back_word [n])

           Argument:  The  argument  n, if specified, must be an integer whose
           value may be positive, 0, or negative.

           Action:  If n is not specified, let n equal 1.

           If the value of n is 0, no action takes place.

           If the value of n is position, EMACS moves the cursor back  to  the
           nth occurrence  of  a character that begins a word, as specified by
           the list of characters in the whitespace string.  (That  is,  EMACS
           moves the cursor back n words, and leaves it at the first character
           on that  word.)   Cursor  movement  stops  if  the beginning of the
           buffer is reached.

           If the value of n is negative, then EMACS moves the cursor  forward
           to the  nth  occurrence  of  a character that immediately follows a
           word.  (That is, EMACS moves the cursor ahead n words, leaving  the
           cursor on the whitespace character immediately following the end of
           the word.)   Cursor  movement  stops  if  the  end of the buffer is
           reached.

           The back_word command returns the value NIL.

           Note:  The token_chars atom contains the list  of  characters  that
           define a word or token.


--*-- backward_clause Command and Function

           The backward_clause  command or function moves the cursor back by a
           specified number of clauses.

           Command Format:  [{ESC}n] {ESC} X backward_clause
                            or
                            [{ESC}n] {CTRL-X} {CTRL-Z} {CTRL-A}

           Function Format:  (backward_clause [n])

           Argument:  The argument n, if specified, must be an  integer  whose
           value may be positive, 0, or negative.

           Action:  If n is not specified, let n equal 1.

           If the value of n is 0, no action takes place.

           If the  value  of n is positive, EMACS moves the cursor back to the
           character preceding the nth occurrence of a character that delimits
           a clause.  (That is, EMACS moves the cursor  back  n  clauses,  and
           leaves it  at  the  character preceding the last clause delimiter.)
           Cursor movement stops if the beginning of the buffer is reached.

           If the value of n is negative, EMACS moves the  cursor  forward  to
           the nth  occurrence  of  a character that delimits a clause.  (That
           is, EMACS moves the cursor ahead n clauses, leaving the  cursor  on
           the character  immediately  following  the  last clause delimiter.)
           Cursor movement stops if the end of the buffer is reached.

           The backward_clause command returns the value NIL.

           Note:  The characters delimiting a  clause  are  contained  in  the
           global string variable clause_scan_table$.


--*-- backward_clausef Function

           The backward_clausef  function moves the cursor back by a specified
           number of clauses, and returns a Boolean value  indicating  whether
           the operation was successful.

           Format:  (backward_clausef [n])

           Argument:  The  argument  n, if specified, must be an integer whose
           value may be positive, 0, or negative.

           The backward_clausef function returns a Boolean value.

           Action:  If n is not specified, let n equal 1.

           If the value of n  is  0,  no  cursor  movement  takes  place,  and
           backward_clausef returns the value true.

           If the  value  of n is positive, EMACS moves the cursor back to the
           character preceding the nth occurrence of a character that delimits
           a clause.  (That is, EMACS moves the cursor  back  n  clauses,  and
           leaves it  at  the  character preceding the last clause delimiter.)
           Cursor movement stops if the beginning of the  buffer  is  reached.
           If the beginning of the buffer is reached, backward_clausef returns
           the value  false;   otherwise,  backward_clausef  returns the value
           true.

           If the value of n is negative, EMACS moves the  cursor  forward  to
           the nth  occurrence  of  a character that delimits a clause.  (That
           is, EMACS moves the cursor ahead n clauses, leaving the  cursor  on
           the   character  following  the  last  clause  delimiter.)   Cursor
           movement stops if the end of the buffer is reached.  If the end  of
           the buffer  is  reached,  backward_clausef returns the value false;
           otherwise, backward_clausef returns the value true.

           Note:  The list of characters delimiting a clause may be  found  in
           the global string variable clause_scan_table$.


--*-- backward_kill_clause Command and Function

           The backward_kill_clause  command  or  function kills text from the
           current cursor position to the beginning of the  specified  clause.

           Command Format:  [{ESC}n] {ESC} X backward_kill_clause
                            or
                            [{ESC}n] {CTRL-X} {CTRL-Z} {CTRL-H}

           Function Format:  (backward_kill_clause [n])

           Argument:  The  argument  n, if specified, must be an integer whose
           value may be positive, 0, or negative.

           Action:  If the value of n is 0, no action takes place.

           If the  value  of  n  is  not  0,  EMACS  performs  the   following
           operations:

               (mark)
               (backward_clause n)
               (forward_char 2)
               (kill_region)

           Notice that  when  n  is  positive,  backward_kill_clause kills all
           characters back  to  the  character  following  the   last   clause
           delimiter found by the backward_clause operation.

                                         Caution

               If n  is  negative, backward_clausef deletes all characters
               up to and including the last clause delimiter  found,  plus
               two additional characters of the following clause.

           The backward_kill_clause function returns the value NIL.


--*-- backward_kill_line Command and Function

           The backward_kill_line  command or function kills all text from the
           current cursor position back to the beginning of the line.

           Command Format:  [{ESC}n] {ESC} X backward_kill_line
                            or
                            [{ESC}n] {CTRL-X} {CTRL-K}

           Function Format:  (backward_kill_line [n])

           Argument:  The argument n, if specified, must be an  integer  whose
           value may be positive, 0, or negative.

           Action:  If n is not specified, let n equal 0.

           EMACS deletes  all characters from the current cursor position back
           to the beginning of the line.  In addition, if the value  of  n  is
           not 0,  EMACS deletes the newline character preceding the beginning
           of the line.

           The backward_kill_line function returns the value NIL.


--*-- backward_kill_sentence Command and Function

           The backward_kill_sentence command or function kills text from  the
           current cursor position to the beginning of the specified sentence.

           Command Format:  [{ESC}n] {ESC} X backward_kill_sentence
                            or
                            [{ESC}n] {CTRL-X} {CTRL-H}

           Function Format:  (backward_kill_sentence [n])

           Argument:  The  argument  n, if specified, must be an integer whose
           value may be positive, 0, or negative.

           Action:  If n is not specified, let n equal 1.

           If the value of n is 0, no action takes place.

           If the value of n is not 0, EMACS performs the  following  actions:

               (mark)
               (back_sentence n)
               (kill_region)

           The backward_kill_sentence function returns the value NIL.


--*-- backward_para Command and Function

           The backward_para  command  or  function moves the cursor back by a
           specified number of paragraphs.

           Command Format:  [{ESC}n] {ESC} X backward_para
                            or
                            [{ESC}n] {CTRL-X} [

           Function Format:  (backward_para [n])

           Argument:  The argument n, if specified, must be an  integer  whose
           value may be positive, 0, or negative.

           Action:  If n is not specified, let n equal 1.

           If the value of n is 0, no action takes place.

           If the  value  of n is positive, EMACS moves the cursor back to the
           character preceding the nth occurrence of a character that delimits
           a paragraph.  (That is, EMACS moves the cursor back  n  paragraphs,
           and leaves  it  at  the  character  preceding  the  last  paragraph
           delimiter.)  Cursor movement stops if the beginning of  the  buffer
           is reached.

           If the  value  of  n is negative, EMACS moves the cursor forward to
           the (-n)th occurrence of a character  that  delimits  a  paragraph.
           (That is, EMACS moves the cursor ahead (-n) paragraphs, leaving the
           cursor on  the  character  immediately following the last paragraph
           delimiter.)  Cursor movement stops if the  end  of  the  buffer  is
           reached.

           The backward_para command returns the value NIL.

           Note:  Paragraphs  are  defined as lines beginning with a period, a
           blank line, or a space.


--*-- backward_sentence Command and Function

           The backward_sentence command or function moves the cursor back  by
           a specified number of sentences.

           Command Format:  [{ESC}n] {ESC} X backward_sentence
                            or
                            [{ESC}n] {ESC} A

           Function Format:  (backward_sentence [n])

           Argument:  The  argument  n, if specified, must be an integer whose
           value may be positive, 0, or negative.

           Action:  If n is not specified, let n equal 1.

           If the value of n is 0, no action takes place.

           If the value of n is positive, EMACS moves the cursor back  to  the
           character preceding the nth occurrence of a character that delimits
           a sentence.  (That is, EMACS moves the cursor back n sentences, and
           leaves it  at the character preceding the last sentence delimiter.)
           Cursor movement stops if the beginning of the buffer is reached.

           If the value of n is negative, EMACS moves the  cursor  forward  to
           the (-n)th  occurrence  of  a  character  that delimits a sentence.
           (That is, EMACS moves the cursor ahead (-n) sentences, leaving  the
           cursor on  the  character  immediately  following the last sentence
           delimiter.)  Cursor movement stops if the  end  of  the  buffer  is
           reached.

           The backward_sentence command returns the value NIL.

           Note:  The  characters  delimiting  a  sentence  are  in the global
           string variable sentence_scan_table$.


--*-- backward_sentencef Function

           The backward_sentencef  function  moves  the  cursor  back   by   a
           specified   number  of  sentences,  and  returns  a  Boolean  value
           indicating whether the operation was successful.

           Format:  (backward_sentencef [n])

           Argument:  The argument n, if specified, must be an  integer  whose
           value may be positive, 0, or negative.

           The backward_sentencef function returns a Boolean value.

           Action:  If n is not specified, let n equal 1.

           If the  value  of  n  is  0,  no  cursor  movement takes place, and
           backward_sentencef returns the value true.

           If the value of n is positive, EMACS moves the cursor back  to  the
           character preceding  the  (-n)th  occurrence  of  a  character that
           delimits a sentence.  (That is, EMACS moves the  cursor  back  (-n)
           sentences, and  leaves  it  at  the  character  preceding  the last

           sentence delimited.)  Cursor movement stops if the beginning of the
           buffer is reached.  If the beginning of the buffer is reached, then
           backward_sentencef  returns   the    value    false;     otherwise,
           backward_sentencef returns the value true.

           Note:  The  characters  delimiting  a  sentence  are  in the global
           string variable sentencef_scan_table$.


--*-- balbak Command and Function

           The balbak command or function moves  the  cursor  to  the  opening
           parenthesis of the current level.

           Command Format:  [{ESC}n] {ESC} X balbak
                            or
                            [{ESC}n] {ESC} {CTRL-B} (LISP mode only)

           Function Format:  (balbak [n])

           Argument:  The  argument n, if specified, must be an integer value.

           Action:  If the argument n is not specified, let n equal 1.

           If n is greater than or equal to 0, EMACS proceeds as follows:

               o  If point is at a closing parenthesis, EMACS moves  point  to
                  the corresponding opening parenthesis.

               o  If point is on text, EMACS moves  point  back  to  the  last
                  closing   parenthesis,  and  then  back   again   to     the
                  corresponding opening parenthesis.  This means that if point
                  is between statements or forms, EMACS skips  back  over  the
                  last form or statements.

           If the value of n is negative, EMACS executes:

                (balfor)


--*-- balfor Command and Function

           The balfor  command  or  function  moves  the cursor to the closing
           parenthesis of the current level.

           Command Format:  [{ESC}n] {ESC} X balfor
                            or
                            [{ESC}n] {ESC} {CTRL-F} (LISP mode only)

           Function Format:  (balfor arg)

           Argument:  The argument n, if specified, must be an integer  value.


           Action:  If n is not specified, let n equal 1.

           If the  value of n is greater than or equal to 0, EMACS proceeds as
           follows:

               o  If point is at an opening parenthesis, EMACS moves point  to
                  the corresponding closing parenthesis.

               o  If point is on text, EMACS moves point forward to  the  next
                  opening   parenthesis,  and  then  forward  again   to   the
                  corresponding closing parenthesis.  This means that if point
                  is between statements or forms, EMACS  skips  point  forward
                  over the next form or statement.

           If the value of n is negative, EMACS executes:

                (balbak)


--*-- begin_line Command and Function

           The begin_line  command  or  function  moves the cursor back to the
           start of the line.

           Command Format:  {ESC} X begin_line
                            or
                            {CTRL-A}

           Function Format:  (begin_line [arg])

           Argument:  The optional argument, if specified, is ignored.

           Action:  EMACS moves the cursor to the beginning of the line.

           The begin_line function returns the value NIL.


--*-- beginning_of_buffer_p Function

           The beginning_of_buffer_p function tests whether the current cursor
           is at the beginning of the buffer.

           Format:  (beginning_of_buffer_p)

           Argument:  None.

           Action:  The  beginning_of_buffer_p  function  returns  a   Boolean
           value.  The  value  is true if and only if the current cursor is at
           the beginning of the buffer.


--*-- beginning_of_line_p Function

           The beginning_of_line_p function tests whether the  current  cursor
           is at the beginning of the line.

           Format:  (beginning_of_line_p)

           Argument:  None.

           Action:  The  beginning_of_line_p function returns a Boolean value.
           The value is true if and only if  the  current  cursor  is  at  the
           beginning of the line.


--*-- bolp Function

           The bolp function is an abbreviation of beginning_of_line_p.


--*-- Boolean Data Type

           A variable with the Boolean data type can have only the values true
           and false.


--*-- buffer_info Function

           The buffer_info  function either gets or sets information about the
           current buffer.

           Format:  (buffer_info p [v])

           Arguments:  The argument p must have as a value the atom or  symbol
           representing the  property  to  be accessed or changed.  A complete
           list of the valid property names is given below, under action.

           The argument v, if  specified,  must  have  a  data  type  that  is
           compatible with the property p.

           Action:  EMACS  sets  or accesses a specified buffer value.  When a
           value is changed, the function returns  the  previous  value.   The
           argument p is the name of the value to be accessed or changed.  The
           second argument,  if  specified, is the value to be assigned to the
           property p.

           The legal values for the property p are as follows:


           Property           Data Type    Meaning

           name               string       Name of buffer.  This property  may
                                           not be modified.

           default_file       string       The pathname of  the  default  file
                                           associated with the buffer.

           modified           Boolean      True if   the   buffer   has   been
                                           modified.  This is indicated by a *
                                           on the status line.

           modes              list         The list of  the  modes  associated
                                           with this buffer.

           read_only          Boolean      True if  the   buffer   cannot   be
                                           modified.

           changed_ok         Boolean      If true, the  user  is  allowed  to
                                           quit   the  editor  with   {CTRL-X}
                                           {CTRL-C} even if  this  buffer  has
                                           been changed.

           dont_show          Boolean      If true,   the   buffer   name   is
                                           suppressed in the {CTRL-X} {CTRL-B}
                                           listing.

           two_dimensional    Boolean      If true, specifies 2don mode is on.

           fill_column        integer      Fill column for word wrapping.

           mark               cursor       The current marked position in  the
                                           buffer.

           top_cursor         cursor       Pointer to  the  beginning  of  the
                                           buffer.

           bottom_cursor      cursor       Pointer to the end of  the  buffer.

           user                            (See below.)

           The "user" option is used for extended values as in:

                (buffer_info (user frob) 17)

           This indicates a user variable.  It is actually the car of  a  cons
           whose cdr  is  a user-defined per buffer value.  The cdr may be the
           same as the name of a request value, in which case it is  identical
           to using the name directly without "user".

           The following  example returns or sets the list of modes associated
           with the current buffer.  Note that in  the  example,  mode  is  an
           unquoted atom as in:

                (buffer_info modes (list (find_mode "quux")))

           So to add a new mode:

                (buffer_info modes (append (buffer_info modes)
                                   (find_mode newmode)))

           or to remove a mode:

                (buffer_info modes (remove (find_mode newmode)
                                   (buffer_info modes)))

           Note that the order of the modes in the list is significant!


--*-- buffer_name Function

           The buffer_name function returns the name of the associated buffer.

           Format:  (buffer_name c)

           Argument:  The argument c must have the data type of cursor.

           Action:  The  buffer_name  function  returns  a  string value.  The
           string contains the name of the buffer in which the cursor c  lies.


--*-- capinitial Command and Function

           The capinitial command or function changes the first character of a
           word, if it is a letter, to uppercase.

           Command Format:  [{ESC}n] capinitial
                            or
                            [{ESC}n] {ESC} C

           Function Format:  (capinitial [n])

           Argument:  The  argument  n, if specified, must be an integer whose
           value may be positive, 0, or negative.

           Action:  If n is not specified, let n equal 1.

           If the value of n is 0, no action takes place.

           If the value of n is negative, EMACS sets n=-n,  moves  the  cursor
           back n words, and proceeds as in the following paragraph.

           If the  value  of n is positive, EMACS starts with the current word
           (or the next word, if the cursor is on whitespace) and converts the
           first character of that word to uppercase, if  it  is  a  lowercase
           letter.

           The capinitial function returns the value NIL.


--*-- car Function

           The car LISP function returns the first item in a list.

           Format:  (car lst)

           Argument:  The argument lst must be a list.

           Action:  If lst is a null list, car returns a null list.

           If lst  is not a null list, car returns the first item of the list.
           The data type of the value returned by car equals the data type  of
           the first item in the list.


--*-- case?  Command and Function

           The case? command  and  function displays a message telling whether
           uppercase and lowercase letters are distinguished in searching.

           Command Format:  {ESC} X case?

           Function Format:  (case?)

           Argument:  A numeric argument, if specified, is ignored.

           Action:  If cases are being distinguished, the message  "Cases  are
           looked at  when  searching"  is  displayed.  Otherwise, the message
           "Cases are ignored when searching" is displayed.

           The case? function returns the value NIL.


--*-- case_off Command and Function

           The case_off command causes uppercase and lowercase letters  to  be
           treated identically during searches.

           Command Format:  {ESC} X case_off

           Function Format:  (case_off)

           Argument:  A numeric argument, if specified, is ignored.

           Action:    In  subsequent  search  operations,  EMACS  ignores  the
           distinction between corresponding uppercase and lowercase  letters.

           The case_off function returns the value NIL.


--*-- case_on Command and Function

           The case_on  command  causes  uppercase and lowercase letters to be
           distinguished during searches.

           Command Format:  {ESC} X case_on

           Function Format:  (case_on)

           Argument:  A numeric argument, if specified, is ignored.

           Action:  In  subsequent  search  operations,  EMACS  observes   the
           distinction between uppercase and lowercase letters.

           The case_on function returns the value NIL.


--*-- case_replace?  Command and Function

           The case_replace? command  and  function displays a message telling
           whether uppercase  and  lowercase  letters  are  distinguished   in
           replacing.

           Command Format:  {ESC} X case_replace?

           Function Format:  (case_replace?)

           Argument:  A numeric argument, if specified, is ignored.

           Action:  If  cases  are being distinguished, the message "Cases are
           looked at in replace" is displayed.  Otherwise, the message  "Cases
           are ignored in replace" is displayed.

           The case_replace? function returns the value NIL.


--*-- case_replace_off Command and Function

           The case_replace_off command causes uppercase and lowercase letters
           to be treated identically during replace operations.

           Command Format:  {ESC} X case_replace_off

           Function Format:  (case_replace_off)

           Argument:  A numeric argument, if specified, is ignored.

           Action:   In  subsequent  replace  operations,  EMACS  ignores  the
           distinction between corresponding uppercase and lowercase  letters.

           The case_replace_off function returns the value NIL.


--*-- case_replace_on Command and Function

           The case_replace_on  command causes uppercase and lowercase letters
           to be distinguished during replace operations.

           Command Format:  {ESC} X case_replace_on

           Function Format:  (case_replace_on)

           Argument:  A numeric argument, if specified, is ignored.

           Action:  In  subsequent  replace  operations,  EMACS  observes  the
           distinction between uppercase and lowercase letters.

           The case_replace_on function returns the value NIL.


--*-- catch Function

           The catch  function is the same as the *catch function, except that
           the argument order is different.

           Format:  (catch body tag)

           This is like *catch, except that the body  and  tag  arguments  are
           evaluated.  Because  catch's argument order makes programming quite
           difficult, the use of *catch is recommended instead.   (See  *catch
           for further information.)


--*-- catenate Special Form

           The catenate special form concatenates its string arguments.

           Format:  (catenate s1 [s2 ...  s8])

           Arguments:  The  catenate  special form takes at least one argument
           and no more than eight arguments.   All  arguments  must  have  the
           string or character data type.

           Action:  The catenate function returns a string value.

           If there is only one argument, s1, the value of s1 is returned.

           If there  is more than one argument, catenate concatenates together
           all the argument string values and returns the combined string.

           Example:  The function

                (catenate "hi" "there")

           returns the string value "hithere".


--*-- cdr Function

           The cdr LISP function returns the value of the list  argument  with
           the first item removed.

           Format:  (cdr lst)


           Argument:  The argument lst must be a list.

           Action:  The cdr function returns a list value.

           If lst  is  a  null  list  or a list containing only one value, cdr
           returns a null list.

           If lst is a list containing more than one item, cdr returns a  list
           containing all items in lst except the first.


--*-- center_line Command and Function

           The center_line  command  or  function centers one or more lines of
           text.

           Command Format:  [{ESC}n] {ESC} X center_line
                            or
                            [{ESC}n] {CTRL-X} {CTRL-Z} S

           Function Format:  (center_line [n])

           Argument:  The argument n, if specified, must be an  integer  whose
           value may be positive, 0, or negative.

           Action:  If n is not specified, let n equal 1.

           If the value of n is 0, no action takes place.

           If the value of n is positive, then n lines of text, beginning with
           the current one and continuing forward, are centered.

           If the  value  of  n  is negative, then -n lines of text, beginning
           with the current one and proceeding backward, are centered.

           To center a line of text, EMACS proceeds as follows:

               o  If the line is null  (contains  no  characters),  no  action
                  takes place.  Otherwise:

               o  EMACS removes all leading whitespace from the  beginning  of
                  the line.   Then,  let  k  equal the number of characters of
                  text remaining on the line.

               o  Let f equal the value returned by

                       (buffer_info fill_column)

                  If that value is 0 or undefined, let f equal 70.

               o  EMACS inserts (f-k)/2 spaces at the beginning of  the  line.

           The center_line function returns the value NIL.


--*-- char_to_string Function

           The   char_to_string  conversion  function  converts  a   character
           argument into a string of length one.

           Format:  (char_to_string c)

           Argument:  The argument c must have the character data type.

           Action:  The char_to_string function  returns  a  string  value  of
           length one.   The  string is computed by converting the character c
           to a string.


--*-- character Data Type

           A variable with the character data type can have  as  a  value  any
           character.


--*-- character_argument Function

           The character_argument  function  returns the character argument to
           the current command.

           Format:  (character_argument)

           Argument:  None.

           Action:  The character_argument function returns  a  value  with  a
           character data  type.   The  value is the character argument to the
           current command;  that is, the last character of the  keypath  used
           to invoke the command.


--*-- charp Function

           The charp  function  tests its argument to determine whether it has
           the character data type.

           Format:  (charp arg)

           Argument:  The argument arg may be any data type.

           Action:  The charp function returns a Boolean value.  The value  is
           true if  the argument arg has the character data type;  it is false
           if the argument has a different data type.


--*-- clear_and_say Function

           The clear_and_say function is the same as  the  init_local_displays
           function.


--*-- close_paren Command and Function

           The close_paren command or function moves the cursor briefly to the
           opening parenthesis  that  corresponds  to  the closing parenthesis
           just typed.

           Command Format:  {ESC} X close_paren
                            or
                            )  (LISP mode only)

           Function Format:  (close_paren)

           Argument:  A numeric argument, if specified, is ignored.

           Action:  EMACS takes the following action:

               o  Inserts a closing parenthesis at the current point.

               o  Moves the cursor to the opening parenthesis that corresponds
                  to the closing parenthesis just typed.

               o  After a  pause,  returns  the   cursor   to   the   position
                  immediately following the closing parenthesis just typed.

           This command  aids  you  in typing LISP or PEEL programs by helping
           you match parentheses in LISP mode.

           Note:  The variable LISP.paren_time controls the  duration  of  the
           pause at the opening parenthesis.  It is normally 750 milliseconds,
           but can be changed to another value if desired.  A value of 0 turns
           off close_paren.


--*-- collect_macro Command

           The collect_macro command starts collecting keystrokes typed at the
           terminal, in order to define a macro.

           Command Format:  {ESC} X collect_macro
                            or
                            {CTRL-X} (

           Argument:  A numeric argument, if specified, is ignored.

           Action:  EMACS  begins to collect keystrokes typed at the terminal.

           Note:  Collection of keystrokes is terminated by  the  finish_macro
           command, which  is  bound as {CTRL-X}).  The resulting macro may be
           executed by  the  execute_macro  command,   which   is   bound   as
           {CTRL-X} E.

           Be aware  that  you should not expect this command to work too well
           when imbedded in a function!


--*-- command_abort_handler Atom

           The command_abort_handler atom is  used  in  conjunction  with  the
           with_command_abort_handler function,  which  executes its arguments
           up to the command_abort_handler atom.  If an error is  encountered,
           the error  flags  (and  throws)  are reset, and execution continues
           after the command_abort_handler token.

           (See the  description  of  with_command_abort_handler  for  further
           information.)


--*-- cons Function

           The cons  function  is  a LISP function that adds a new item to the
           front of a list.

           Format:  (cons i lst)

           Argument:  The argument i is an  item  with  any  data  type.   The
           argument lst is almost always a list, but may have any data type if
           you wish to produce a "dotted list".

           Action:  The data type of the value returned by cons is a list.

           If the  argument  lst  is  a  list, cons returns the list formed by
           adding the item i to the front of the list lst.

           If the argument lst is not a list, cons returns a dotted  list  (or
           cons) whose car is the item i and whose cdr is the item lst.


--*-- convert_tabs Function

           The convert_tabs function takes a list of numbers and converts them
           to tab stops.

           Format:  (convert_tabs s)

           Argument:  The argument s must be a string.

           Action:  The string s must contain a series of numbers separated by
           spaces, and  the last number must end in a space.  The numbers must
           be positive and in increasing order.

           EMACS sets the tab stops at positions specified by numbers  in  the
           string.

           The convert_tabs function returns the value NIL.


--*-- convert_to_base Function

           The convert_to_base  function  converts  an  integer to a specified
           numeric base and returns the result as a string.

           Format:  (convert_to_base n bv [ln])

           Argument:  The argument n must be an integer.  The argument bv must
           be either a string or a positive  integer.   The  argument  ln,  if
           specified, must be an integer.

           Action:  The convert_to_base function returns a string value.

           EMACS proceeds as follows:

               o  If bv is an integer value, let b equal bv;  otherwise, let b
                  equal the length of string bv.

               o  If bv is a string value, let s equal bv;  otherwise,  let  s
                  equal   the  first  b   characters   of     the       string
                  "0123456789abcdefghijklmnopqrstuvwxyz"

               o  EMACS converts the integer n to a string of base b, using as
                  digits the characters  of  the  string  s.   Let  t  be  the
                  resulting string of digits.

               o  Let czero equal the first character of the string s.   (This
                  is usually the character "0".)

               o  If the argument ln is specified, and if the value of  ln  is
                  longer than  the  string  t,  EMACS inserts additional czero
                  characters to the front of the string t, but after a  -,  if
                  any, so  that the length of the string t equals the value of
                  ln.

               o  If the argument ln is specified  and  is  smaller  than  the
                  length of  the  string  t, EMACS sets t equal to a string of
                  length ln containing only *'s.

           EMACS returns the string t.

           Examples:

                (convert_to_base 255 16)

                (convert_to_base 32 8 3)

           These return the string values "ff" and "040", respectively.


--*-- copy_array Function

           The copy_array function copies one array to another.

           Format:  (copy_array a1 a2 [idx1 [n [idx2]]])

           Arguments:  The arguments a1 and a2 must be array values.  Usually,
           a1 and a2 are assigned array values by setq in conjunction with the
           make_array function.

           The arguments idx1, n, and idx2, if specified, must all be  integer
           values.

           Action:  The  copy_array  function  returns  an  array value.  This
           array value is computed as follows:

               o  Let m1 and m2 equal the number of elements in the arrays  a1
                  and a2, respectively.  m1 and m2 are the values specified as
                  the last  argument  to  the  make_array  function calls that
                  created the arrays a1 and a2.

               o  If the argument idx1 is not specified, let idx1 equal 0.

               o  It is an error if idx1 is <0 or >=m1.

               o  If the argument n is not specified, let n = m1.

               o  It is an error if either n<0 or idx1 + n >= m1.

               o  If the argument idx2 is not specified, let idx2 = 0.

               o  It is an error if idx2 + n >= m2.

               o  EMACS copies n consecutive elements from the array a2 to the
                  array a1.  The n consecutive elements  are  taken  from  the
                  array a2, starting at index position idx2, and are copied to
                  the array a1, starting at index position idx1.

           The copy_array function returns the array a1.


--*-- copy_cursor Function

           The copy_cursor function returns a copy of the specified cursor.

           Format:  (copy_cursor cur)

           Argument:  The argument cur must be a cursor value.

           Action:  The copy_cursor function returns a cursor value.

           EMACS makes  a  copy  of the cursor value specified by the argument
           cur, and returns that copy.

           Example:

                (setq old (copy_cursor current_cursor)
                (forward_word) ...
                (go_to_cursor old)

           The first line makes a copy of the  current  cursor  position,  and
           assigns that to the variable old.  The last line returns the cursor
           to the original cursor position.

           Note:  Replacing the first line in the preceding example with

                (setq old current_cursor)

           would not  have  worked,  because  any  cursor  movement would have
           changed the values of both current_cursor and old.


--*-- copy_region Command and Function

           The copy_region command or function copies the current region  into
           the kill ring.

           Command Format:  {ESC} X copy_region
                            or
                            {ESC} W

           Function Format:  (copy_region)

           Argument:  A numeric argument, if specified, is ignored.

           Action:  EMACS copies the characters between the current cursor and
           the last  marked  position in the current buffer into the kill ring
           without deleting them from the buffer.

           The copy_region function returns the value NIL.


--*-- cpu_time Function

           The cpu_time function returns the current cpu time in milliseconds.

           Format:  (cpu_time)

           Argument:  None.

           Action:  The cpu_time  function  returns  an  integer  value.   The
           integer value is the cpu time used since login.


--*-- cr Command and Function

           The cr  command or function inserts a newline into the text buffer.

           Command Format:  [{ESC}n] cr
                            or
                            [{ESC}n] {CTRL-M} (carriage return key)

           Function Format:  (cr [n])

           Argument:  If the argument n is specified, it must be  an  integer.

           Action:  If the argument n is not specified, let n equal 1.

           If n is less than or equal to 0, no action takes place.

           If n is greater than 0, EMACS inserts n newline characters into the
           text buffer  at  the  current  cursor  position.   The  cr function
           returns the value NIL.


--*-- create_text_save_buffer$ Function

           The create_text_save_buffer$ function goes to or creates  the  next
           buffer in a circular list of ten buffers.

           {Format:  (create_text_save_buffer$ s)

           Argument:  The argument s must be a string value.

           Action:  EMACS  goes  to  or  creates the next buffer in a circular
           list of ten buffers.  EMACS deletes the contents  of  that  buffer,
           and inserts the string s into that buffer.

           The create_text_save_buffer$ function returns the value NIL.


--*-- cret_indent_relative Command and Function

           The cret_indent_relative  command  or  function  inserts a new-line
           character into the text buffer at the current cursor position,  and
           then indents  the next line to the first nonwhitespace character of
           the previous line.

           Command Format:  [{ESC}n] {ESC} X cret_indent_relative
                            or
                            [{ESC}n] {CTRL-X} {RETURN}

           Function Format:  (cret_indent_relative [n])

           Argument:  The argument n, if specified, must be an integer  value.

           Action:  If n is not specified, let n=0.

           Let k equal the number of whitespace characters at the beginning of
           the current line.  If the line is blank, k=0.

           EMACS inserts  a  newline  and k spaces into the text buffer at the
           current cursor position

           The cret_indent_relative function returns the value NIL.


--*-- cur_hpos Function

           The cur_hpos function  returns  an  integer  value  indicating  the
           current horizontal position of the cursor.

           Format:  (cur_hpos)

           Arguments:  None.

           Action:  The cur_hpos function returns an integer value.  The value
           returned equals  one  plus  the number of characters on the current
           line to the left of the current cursor position.


--*-- current_character Function

           The current_character function returns the character at the cursor.

           Format:  (current_character [cur])

           Argument:  The argument cur, if specified, must be a cursor  value.

           Action:  The  current_character function returns a character value.

           If the argument cur is not specified, let  cur  equal  the  current
           cursor.

           The   current_character  function  returns  the  character  at  the
           specified cursor position.


--*-- current_cursor Variable

           The current_cursor variable has the data type cursor and equals the
           value of the current cursor position.

           Note:  The  current_cursor  variable  is  not  normally  used  with
           parentheses, because  it is not a function.  If you bind a variable
           to current_cursor, the new variable also changes value whenever the
           current cursor changes.  For example,

                (setq cur current_cursor)

           binds the variable cur to the current cursor, with the result  that
           any   cursor  movement  command  changes  the  value  of  cur   and

           current_cursor.  To make a copy of a cursor that will not change in
           this manner, use the copy_cursor function.

                                         Caution

               You should never set current_cursor.  EMACS may become very
               confused.


--*-- current_handler Function

           The current_handler function returns a  string  value  representing
           the current handler.

           Format:  (current_handler [chase_atom])

           Argument:  If  an  argument  is  specified,  it  must  be  the atom
           chase_atom.

           Action:  The current_handler function returns a string value.

           This is the object for the current command handler and is used with
           handler_info.  If chase_atom is specified, the function cell of the
           atom is returned if the object is an atom.  This is  normal  usage.

           (See handler_info for more information.)


--*-- current_line Function

           The current_line  function  returns  a  string value containing the
           current line without the line-ending newline.

           Format:  (current_line [cur])

           Argument:  The argument cur,  if  specified,  must  have  a  cursor
           value.

           Action:  The current_line function returns a string value.

           If the  argument  cur is not specified, let the value of cur be the
           current cursor.

           EMACS forms a string containing all  the  characters  on  the  line
           pointed to  by  the cursor cur, except the line-ending newline, and
           returns that string value.


--*-- current_major_window Function

           The current_major_window function returns the current major window.

           Format:  (current_major_window)

           Arguments:  None.

           Action:  The current_major_window returns a value with  the  window
           data type.  The value returned is the current major window.

           Note:  This  is  the  window  in  which  the current_cursor will be
           redisplayed.    You    can    use    the    value    returned    by
           current_major_window in  the  go_to_window function.  Incidentally,
           the minibuffer is not a major window.


--*-- cursor Data Type

           Cursor is a data type.  Cursors are pointers to  text  in  buffers.
           When you assign a cursor value to a variable, such as by using setq
           with the  copy_cursor  function, EMACS attempts to make that cursor
           continue to point to the same text in the buffer,  no  matter  what
           other changes  in  text  are  made  to  the  buffer.   A  number of
           operations may be performed on cursors, but most operations operate
           on the current cursor,  which  is  also  the  user's  cursor.   For
           example, forward_char  advances  the  current cursor forward by one
           character.  It is rather easy to save the current  cursor  position
           (using copy_cursor and setq), execute a series of commands that may
           alter it, and then use go_to_cursor to return the cursor to its old
           value.


--*-- cursor_info Function

           The cursor_info  function  returns  information  about  the current
           cursor position.

           Format:  (cursor_info p)

           Arguments:  The argument p must be an atom, as described below.

           Action:  EMACS returns a value whose data  type  depends  upon  the
           atom p.

           EMACS returns  information  about  the current cursor position that
           depends upon the property specified by the atom p.  The atom p  may
           have any of the following values:

               p               Data Type       Property

               buffer_name     string          Name of the buffer
               line_num        integer         Line number
               char_pos        integer         Character position on line
               sticky          Boolean         Cursor moves with text

           Note:  You  cannot  set  any of these properties using cursor_info.
           Use the make_cursor function to create a new cursor value.


--*-- cursor_on_current_line_p Function

           The cursor_on_current_line_p  function  returns  a  Boolean   value
           indicating whether  the  current  cursor is on the same line as the
           argument cursor.

           Format:  (cursor_on_current_line_p cur)

           Argument:  The argument cur must be a cursor value.

           Action:  The cursor_on_current_line_p function  returns  a  Boolean
           value.  The value is true if the current cursor is on the same line
           as the  argument  cur,  and  is false if the current cursor is on a
           different line.


--*-- cursor_same_line_p Function

           The cursor_same_line_p function returns a Boolean value  indicating
           whether two cursors point to the same line.

           Format:  (cursor_same_line_p cur1 cur2)

           Arguments:  The arguments cur1 and cur2 must be cursor values.

           Action:  The  cursor_same_line_p  function  returns Boolean values.
           The value is true if cur1 and cur2 refer  to  the  same  line,  and
           false if they refer to different lines.


       Data Types

           The PEEL data types are:

                1 any                2 Boolean            3 character
                4 integer            5 string             6 atom
                7 function           8 list               9 cursor
               10 buffer            11 dispatch_table    12 handler
               13 buffer structure  14 window            15 array
               16 PL/I subroutine


--*-- date Command and Function

           The date  command  or function inserts a date into your text buffer
           at the current cursor position.

           Command Format:  {ESC} X date

           Function Format:  (date)

           Argument:  A numeric argument, if specified, is ignored.

           Action:  EMACS inserts the current date into your  text  buffer  at
           the current cursor position.  The date format is illustrated by the
           following:

                TUE, 19 MAY 1981

           The date function returns the value NIL.


--*-- decimal_rep Function

           The decimal_rep  function  is  the  same  as  the integer_to_string
           function.


--*-- decompose Special Form

           The decompose special form is a special LISP function for arranging
           the contents of one list into a pattern specified by another  list.

           Format:  (decompose v f s1 else s2)

           Arguments:  The  arguments  v  and  f  must  be  list  values.  The
           arguments s1 and s2 are any PEEL code strings.

           Action:  EMACS evaluates the argument v, but not the argument f.

           EMACS then matches the elements of the list  f  with  corresponding
           elements in the list v, proceeding as follows:

               o  If the item in list f is NIL, the item in list v  must  also
                  be NIL.

               o  If the item in f is an atom, EMACS binds it locally  to  the
                  corresponding item in the list v.

               o  If the item is a list, EMACS binds the car of this  item  to
                  the car  of  the corresponding item in v, and the cdr of the
                  item to the cdr of the corresponding item in v.

           If these local assignments are made without error,  EMACS  executes
           the code  sequence  s1.   If  an  error occurs during the matching,
           EMACS executes the sequence s2.

               (decompose '(a b c) (x . y)
                           (print x)
                           (print y)
                      else
                           (print "DECOMPOSITION ERROR"))

           This prints: a
                        (b c)

               (decompose '((a b) (c d)) (x (y z))
                           (print (list x y z))
                       else
                           (print "DECOMPOSITION ERROR"))

           This prints: ((a b) c d)

           Note:  This function is particularly  useful  for  writing  macros.
           (See the &macro option of defun.)


--*-- def_auto Function

           The def_auto function makes another function (defined in a separate
           file) available for automatic loading when it is invoked.

           Format:  (def_auto f h s)

           Arguments:  The  argument f must be an atom.  The arguments h and s
           must be string values.

           Action:  EMACS defines the function f without actually loading  the
           function.  The  function  is  thus  available for use, but the time
           required to load the function is not spent until it is invoked.

           The string h is saved as a help string for the function.

           The string s is the pathname of  the  .EFASL  file  containing  the
           actual  function  definition.   The  first  time  the  function  is
           invoked, EMACS goes to the file specified by  the  pathname  s  and
           fasloads that  file,  replacing  the definition of the function and
           then executing it.  Subsequent invocations of the function use  the
           fasloaded definition directly.

           The def_auto function returns the value NIL.

           Example:

                (def_auto poem
                          "Anthony's program to write poetry"
                          "ANTHONY>EMACS>POEM")

           This statement  defines  poem  as an EMACS command to load and then
           execute the file ANTHONY>EMACS>POEM.EFASL.  Presumably a file named
           POEM.EM, containing the actual defcom for the "poem"  command,  had
           previously been compiled, by using the dump_file command.


--*-- default_tabs Command and Function

           The default_tabs  command  or  function  restores  tab positions to
           every five spaces.

           Command Format:  {ESC} X default_tabs

           Function Format:  (default_tabs)

           Argument:  A numeric argument, if specified, is ignored.

           Action:  EMACS restores the default tab  positions,  set  at  every
           five spaces.

           The default_tabs function returns the value NIL.


--*-- defcom Special Form

           The defcom special form defines a new command.

           Format:

               (defcom command_name
                    &doc  | &documentation <documentation_string>
                    &na   | &numeric_arg
                            &repeat | &pass <variable> [&default <value>]
                    &args | &arguments ((<name> &prompt <string>
                                                &default <value>
                                                &string | &symbol | &integer )
                                        ... )
                    &prefix
                    &chararg | &character_argument
                    <body>
               )

           Arguments:  (See Chapter 5.)

           Action:  EMACS defines a new command, as described in Chapter 5.

           The defcom function returns the value NIL.


--*-- defun Special Form

           The defun special form defines a new function.

           Format:  (defun name ((<argument1><type1>) ...
                                         &optional ... &rest ... &quote ...
                                         &returns <type>
                                         &local (<variable1><type2>) ... )
                               <body>
                        )

           Arguments:  (See Chapter 5.)

           Action:  The defun function defines a new function, as described in
           Chapter 5.

           The defun function returns the value NIL.

           You may also specify defun with the argument &macro.  In this case,
           the function returns a list that should be evaluated in the calling
           context.  (See page 127 of the second edition of Winston and Horn's
           LISP for an explanation of the LISP backquote-and-comma syntax used
           for &macro.)

           Example:  Consider the following definition:

                (defun foo (x &macro)
                  `(* ,x ,x))

           In this case, reference to (foo bar) returns (* bar bar).


--*-- delete_blank_lines Command and Function

           The delete_blank_lines  command or function deletes all blank lines
           around the current cursor.

           Command Format:  {ESC} X delete_blank_lines
                            or
                            {CTRL-X} {CTRL-O}

           Function Format:  (delete_blank_lines)

           Argument:  A numeric argument, if specified, is ignored.

           Action:  If the current cursor is on a nonblank line,  EMACS  moves
           the cursor down to the first blank line, stopping if the end of the
           buffer is reached.  EMACS then deletes blank lines until the cursor
           is again on a nonblank line or at the end of the buffer.

           The delete_blank_lines function returns the value NIL.


--*-- delete_buffer Function

           The delete_buffer function deletes the contents of a buffer without
           saving it on the kill ring.

           Format:  (delete_buffer)

           Arguments:  None.

           Action:  EMACS  deletes the contents of the current buffer, without
           saving it on the kill ring.

           The delete_buffer function returns the value NIL.


--*-- delete_char Command and Function

           The delete_char command or function deletes one or more  characters
           forward.

           Command Format:  [{ESC}n] {ESC} X delete_char
                            or
                            [{ESC}n] {CTRL-D}

           Function Format:  (delete_char [n])

           Argument:  The  argument n, if specified, must be an integer value.

           Action:  If n is not specified, let n equal 1.

           If the value of n is 0, no action takes place.

           If n is positive, EMACS deletes n  characters  beginning  with  the
           character at  the  current  cursor position and continuing forward,
           stopping if the end of the buffer is reached.

           If the value  of  n  is  negative,  EMACS  deletes  -n  characters,
           beginning with the character preceding the current cursor position,
           and continuing backward, stopping if the beginning of the buffer is
           reached.

           If the  absolute  value of n is greater than 64, a prompt "Count is
           <n>.  Are you sure?"  is displayed.

           The delete_char function returns the value NIL.


--*-- delete_point_cursor Function

           The delete_point_cursor function deletes all the text  between  the
           current cursor position and the argument cursor position.

           Format:  (delete_point_cursor cur)

           Argument:  The argument cur must be a cursor value.

           Action:  EMACS deletes all text between the current cursor position
           and the cursor position specified by the argument cur.

           The delete_point_cursor function returns the value NIL.


--*-- delete_region Command and Function

           The delete_region  command  and function deletes the current marked
           region without putting it onto the kill ring.

           Command Format:  {ESC} X delete_region

           Function Format:  (delete_region)

           Argument:  A numeric argument, if specified, is ignored.

           Action:  EMACS deletes all the  text  in  the  region  between  the
           current cursor  position  and the marked position.  The text is not
           saved on the kill ring.

           The delete_region function returns the value NIL.


--*-- delete_white_left Function

           The delete_white_left function deletes all  consecutive  whitespace
           to the left of the current cursor position.

           Format:  (delete_white_left)

           Arguments:  None.

           Action:  The delete_white_left function returns a Boolean value.

           If there  is  a whitespace character at the current cursor position
           and a whitespace character  to  the  left  of  the  current  cursor
           position, EMACS  deletes  all  consecutive whitespace characters to
           the left of the current cursor  position,  and  returns  the  value
           true.

           If those  conditions are not met, EMACS takes no action and returns
           the value false.


--*-- delete_white_right Function

           The delete_white_right function deletes all  contiguous  whitespace
           to the right of the current cursor position.

           Format:  (delete_white_right)

           Arguments:  None.

           Action:  The  delete_white_right  function returns a Boolean value.

           If there is a whitespace character at the current  cursor  position
           and a  whitespace  character  to  the  right  of the current cursor
           position, EMACS deletes all consecutive  whitespace  characters  to
           the right  of  the  current  cursor position, and returns the value
           true.

           If those conditions are not met, EMACS takes no action and  returns
           the value false.


--*-- delete_white_sides Function

           The delete_white_sides  function  deletes all whitespace characters
           surrounding the current position.

           Format:  (delete_white_sides)

           Arguments:  None.

           Action:  The delete_white_sides function returns a  Boolean  value.

           If there  is a whitespace character at the current cursor position,
           EMACS deletes it and all consecutive whitespace characters  to  the
           right and  to  the left of the current cursor position, and returns
           the value true.

           If the character at the current cursor position is not a whitespace
           character, EMACS returns the value false.

           Note:  The delete_white_sides function has the same effect  as  the
           white_delete function.


--*-- delete_word Command and Function

           The delete_word command or function deletes one or more words.

           Command Format:  [{ESC}n] {ESC}X delete_word
                            or
                            [ESC}n] {ESC} D

           Function Format:  (delete_word [n])

           Argument:  The  argument  n, if specified, must be an integer whose
           value may be positive, 0, or negative.

           Action:  If n is not specified, let n equal 1.

           If the value of n is 0, no action takes places.

           If the value of n is positive, EMACS deletes n words in  the  text,
           beginning  with  the  word  at  the  current  cursor  position  and
           continuing forward.  Deletion stops if the end  of  the  buffer  is
           reached.

           If the  value  of  n  is negative, EMACS deletes -n words beginning
           with the word preceding the current  cursor  position,  and  moving
           backward.  Deletion  stops  if  the  beginning  of  the  buffer  is
           reached.

           The delete_word function returns the value NIL.

           Note:  The token_chars atom contains a list of the characters  that
           define a word or token.


--*-- describe Command and Function

           The describe  command  or  function  gives you information about an
           EMACS command.

           Command Format:  {ESC} X describe
                            or
                            {CTRL-_} D

           Function Format:  (describe [s])

           Argument:  A numeric argument, if specified, is ignored.

           The argument s, if specified, must be a string value.

           Action:  If the argument s is not specified, EMACS prompts you  for
           a string s.

           If the string s does not begin with the character @, EMACS displays
           a list of all function names that begin with the string s.

           If the  string  s  begins with a single @ character, EMACS prints a
           list of all function names that contain the remaining characters in
           the string s anywhere in their name.

           If the string s begins with two @ characters, EMACS prints  a  list
           of all  function  names  for  functions  that  reference  any other
           function beginning with the remainder of the string s.


--*-- dispatch Special Form

           The dispatch special form compares the text following  the  current
           cursor against  a  set of strings to determine what action to take.

           Format:  (dispatch
                        x1 s1
                        x2 s2
                        ...
                        otherwise sx)

           Arguments:  Each argument, x1, x2, and ...  may consist of  one  or
           more string or character values.

           Each argument  s1,  s2, ..., and sx may consist of one or more PEEL
           statements.

           Action:  EMACS compares the text following point to x1, x2, and ...
           until a  match  is  found.   If  a  match  is   found,   then   the
           corresponding PEEL  statement  s1,  or s2, or ...  is executed, and
           the value of that statement is returned as the value  of  dispatch.
           Otherwise, the  statement  sx  is  executed,  and the value of that
           statement is returned as the value of dispatch.

           If no match is found and no  "otherwise"  statement  is  specified,
           dispatch returns the value NIL.

           (See Chapter 4 for more information.)


--*-- dispatch_info Function

           The dispatch_info  function  gets  or sets information on a mode or
           dispatch table.  It returns the old value of the property.

           Format:  (dispatch_info dt p [v])

           Arguments:  The argument dt must be a dispatch table.  The argument
           p must be an atom, as described below under action.   The  argument
           v, if specified, must have a data type compatible with the argument
           p.

           Action:  The  dispatch_info function can be used to set the handler
           associated with keys.  A mode value is a  dispatch  table  that  is
           found using  the  find_mode function.  The argument to find_mode is
           either an atom or a string (that is returned by the function).  The
           returned value  is  the  mode  value.   The  following  modes   are
           predefined:

                main      This is the main character dispatch mode.

                x         This is the dispatch table for the  {CTRL-X}  prefix
                          in the main dispatch table.

                esc       This is the dispatch table for ESCAPE  in  the  main
                          dispatch table.

                mb_mode   This is the dispatch table for minibuffers.

                reader    This is the dispatch  table  used  by  the  keyboard
                          reader.  It is used, for example, to define {CTRL-_}
                          to be help_on_tap.  If the function returns a string
                          or character  value, the result is returned in place
                          of the  character  actually  read.   Otherwise,  the
                          reader   will  read  another  character   from   the
                          keyboard.  Note  that  the  "raw"  reader  does  not
                          invoke reader functions.


           The dispatch_info  function  can  be used to interrogate and modify
           dispatch tables.  The argument dt is a dispatch table (that  is,  a
           mode).  The  argument  p  is either the quoted atom 'name, in which
           case the name of the mode is returned as  a  string,  or  it  is  a
           character, string,  or  integer  value  identifying the entry to be
           interrogated and/or modified.

           The argument v, if specified, is the new object to be  placed  into
           the dispatch table.

           The value  returned by dispatch_info is determined by the following
           rules:


               o  The function returns an atom if the dispatch table is  bound
                  to a  command  or  function.   The  atom  is  the command or
                  function.

               o  The function returns NIL if nothing is bound to  the  entry.

               o  The function returns a dispatch table (mode) if the entry is
                  a prefix key, that is, an intermediate part of a  key  path.
                  (For example,  the  {ESC}  entry  in main is bound to escape
                  mode.)

           Note:  To determine whether a  command  (handler)  or  function  is
           bound, use fsymeval on the returned atom.  If it is a handler, then
           handler_info may also be useful.


--*-- display_error_noabort Special Form

           The   display_error_noabort  special  form  is  the  same  as   the
           error_message function.


--*-- do_forever Special Form

           The do_forever function performs an infinite loop.

           Format:  (do_forever s1 [s2 ...])

           Arguments:  The arguments s1, s2, and ..., if  specified,  are  any
           PEEL statements to be executed in the loop.

           Action:  PEEL  executes  all  the  arguments,  s1, s2, and ..., and
           repeats execution of them in an infinite loop until  stop_doing  is
           executed.

           The do_forever function returns the value NIL.


--*-- do_n_times Special Form

           The do_n_times  special form executes a loop for a specified number
           of iterations.

           Format:  (do_n_times n s1 [s2 ...])

           Arguments:  The argument n must be an integer value.

           The arguments s1, s2, and  ...,  if  specified,  may  be  any  PEEL
           statements.

           Action:  If  the  value of n is 0, or negative, no action is taken.

           If the value of n is positive, PEEL executes the statements s1, s2,
           and ...  in a  loop  for  n  iterations,  or  until  stop_doing  is
           executed.

           The do_n_times function returns the value NIL.


--*-- downcase Function

           The downcase  function  converts  uppercase  letters  in its string
           argument to lowercase.

           Format:  (downcase s)

           Argument:  The argument s must be a string or character value.

           Action:  The downcase function returns a string value.  The  string
           is computed  by  returning  a copy of the string s after converting
           all uppercase letters to their corresponding lowercase letters.


--*-- dt Command and Function

           The dt command or function inserts the current date and  time  into
           your text buffer at the current cursor position.

           Command Format:  {ESC} X dt

           Function Format:  (dt)

           Argument:  A numeric argument, if specified, is ignored.

           Action:  EMACS  inserts  the  current  date and time into your text
           buffer at the current cursor position.  An example  of  the  format
           used is as follows:

                05/19/81 11:06:57


--*-- dump_file Command

           The dump_file  command  "compiles"  PEEL source to a fasdump format
           file.

           Format:  {ESC} X dump_file

           Argument:  A numeric argument, if specified, is ignored.

           Action:  EMACS partially compiles the PEEL program in  the  current
           text buffer  and  dumps it to a file.  If the buffer name is of the
           form x.EM, EMACS creates the fasdump file x.EFASL.  If  the  buffer
           name does  not  have  the  suffix .EM, EMACS simply adds the suffix
           .EFASL to the buffer name.


--*-- else Atom

           The else atom is used in  the  if  function.   (See  that  function
           description for further information.)


--*-- empty_buffer_p Function

           The empty_buffer_p  function  tests if the current buffer is empty.

           Format:  (empty_buffer_p)

           Arguments:  None.

           Action:  The empty_buffer_p function returns a Boolean value.   The
           value returned  is true if the current buffer is empty and false if
           the current buffer contains text.


--*-- end_line Command and Function

           The end_line command or function moves the cursor to the end of the
           current line.

           Command Format:  {ESC} X end_line
                            or
                            {CTRL-E}

           Function Format:  (end_line)

           Argument:  A numeric argument, if specified, is ignored.

           Action:  EMACS moves the cursor to the end of the current line.

           The end_line function returns the value NIL.


--*-- end_of_buffer_p Function

           The end_of_buffer_p function tests whether the current cursor is at
           the end of the buffer.

           Format:  (end_of_buffer_p)

           Arguments:  None.

           Action:  The end_of_buffer_p function returns a Boolean value.  The
           value returned is true if the current cursor is at the end  of  the
           buffer;  otherwise, it is false.


--*-- end_of_line_p Function

           The end_of_line_p  function  tests whether the current cursor is at
           the end of the line.

           Format:  (end_of_line_p)

           Arguments:  None.

           Action:  The end_of_line_p function returns a Boolean  value.   The
           value returned  is  true if the current cursor is at the end of the
           line;  otherwise, it is false.


--*-- eolp Function

           The eolp function is an abbreviation of end_of_line_p.


--*-- eq Function

           The eq function tests whether its arguments are the same object.

           Format:  (eq arg1 arg2)

           Arguments:  The arguments arg1 and arg2 may have any data type.

           Action:  The eq function returns a  Boolean  value.   The  returned
           value is  true  if  arg1 and arg2 are the same object, and false if
           they are different objects.

           Note:  In almost all cases,  you  should  use  the  =  function  in
           preference to  the  eq  function.   To  understand  the difference,
           consider the following two examples:

               (eq 2 2)
               (eq "a" "a")

           The first of these examples is always true because  the  integer  2
           always becomes  the  same  object.  But the second example is never
           true (if typed in the minibuffer), because a new copy of the string
           "a" is allocated for each argument by the reader.  However, if  the
           = function  is  used  instead  of eq in the above two examples, the
           values of both would be true.


--*-- error_message Special Form

           The error_message special form displays an  error  message  in  the
           minibuffer.  It does not abort the current command.

           Format:  (error_message s)

           Argument:  The argument s must be a string.

           Action:  EMACS displays the string s in the minibuffer.

           The error_message function returns the value NIL.

           Note:  Unlike  the  info_message  function,  this function forces a
           screen update even if redisplay has been  suppressed,  for  example
           with with_no_redisplay.


--*-- Escape Sequences

           Escape sequences  provide  a  method to enter control characters so
           that they  are  printable.   The  following  escape  sequences  are
           available:

                ~hnn        The character with hexadecimal code of nn

                ~cC         The control character  corresponding  to  the
                            character C

                ~n          The newline character

                ~" or ~q    The string delimiter (double quotation  mark)

                ~~          The string escape character (tilde)

                ~<nl>       Concealed newline,  allowing  strings  to  be
                            continued on  the next line without including
                            the newline character in the string


--*-- europe_dt Command and Function

           The europe_dt command or  function  inserts  the  current  date  in
           European format into your buffer.

           Command Format:  {ESC} X europe_dt

           Function Format:  (europe_dt)

           Argument:  A numeric argument, if specified, is ignored.

           Action:  EMACS  inserts  the  current  date  in  numerical European
           format, dd/mm/yr, into your text at the  current  cursor  position.
           The format is similar to the following:

                19/09/85

           The europe_dt function returns the value NIL.


--*-- eval Function

           The eval  function  is a LISP function that evaluates its arguments
           and returns the result.

           Format:  (eval f)

           Argument:  The argument f is a form or any executable PEEL program.

           Action:  PEEL executes the form f and returns the result.

           Note:  You can evaluate a form f simply by executing it as part  of
           your PEEL  program.   Therefore,  if  you are writing a simple PEEL
           program and explicitly calling the eval function, you are  probably
           doing something  wrong.   The  eval function is primarily useful in
           programs that deal with LISP or PEEL itself, rather  than  programs
           about string manipulation.


--*-- evaluate_af Function

           The evaluate_af  function  evaluates  an active function in PRIMOS.
           It is similar to the af function, but returns a string value rather
           than inserting it into the current buffer.

           Format:  (evaluate_af s)

           Argument:  The argument s must be a string value.

           Action:  EMACS evaluates the string s  as  an  active  function  in
           PRIMOS, and returns a string value.

           Example:  The function

                (evaluate_af "[ATTRIB <0>CMDNC0 -TYPE]")

           returns the string value "UFD".


--*-- exchange_mark Command and Function

           The exchange_mark command or function exchanges mark and point.

           Command Format:  {ESC} X exchange_mark
                            or
                            {CTRL-X} {CTRL-X}

           Function Format:  (exchange_mark)

           Argument:  A numeric argument, if specified, is ignored.

           Action:  EMACS  exchanges  mark  and  point.   That is, the current
           cursor position is set equal to the last marked position,  and  the
           mark is reset to the cursor position prior to the beginning of this
           command.

           The exchange_mark function returns the value NIL.


--*-- execute_macro Command and Function

           The execute_macro command or function executes a stored sequence of
           commands.

           Command Format:  [{ESC}n] {ESC} X execute_macro
                            or
                            [{ESC}n] {CTRL-X} E

           Function Format:  (execute_macro [n])

           Argument:  The  argument n, if specified, must be an integer value.

           Action:  If n is not specified, let n equal 1.

           EMACS repeats the following step n times:  it  executes  the  macro
           consisting of  the  collection  of keystrokes collected by the last
           collect_macro and finish_macro commands.


--*-- exit_minibuffer Command

           The exit_minibuffer command exits the minibuffer.

           Format:  {ESC} X exit_minibuffer
                    or
                    {RETURN}   (only when in minibuffer)

           Argument:  A numeric argument, if specified, is ignored.

           Action:  EMACS exits the  minibuffer.   You  are  returned  to  the
           current cursor position in your major window or buffer.


--*-- expand_macro Command and Function

           The expand_macro  command  or  function  expands  a stored keyboard
           macro into equivalent PEEL code.

           Command Format:  {ESC} X expand_macro

           Function Format:  (expand_macro [s])

           Argument:  A numeric argument, if specified, is ignored.

           The argument s, if specified, must be a string value.

           Action:  If the argument s is not specified, EMACS prompts  you  in
           the minibuffer  with  "macro  name:".   The string that you type is
           assigned to the variable s.

           EMACS expands the keyboard macro keystrokes collected by  the  last
           collect_macro into  PEEL code, as a defcom with a name specified by
           the string s, and stores the resulting PEEL source  code  into  the
           text buffer at the current cursor position.


--*-- explain_key Command and Function

           The explain_key  command or function invokes the help facility that
           explains a specified keypath.

           Command Format:  {ESC} X explain_key
                            or
                            {ESC}?

           Function Format:  (explain_key)

           Argument:  A numeric argument, if specified, is ignored.

           Action:  EMACS invokes the help facility that explains a  specified
           keypath.  EMACS  does  not  prompt  you.  The next keypath that you
           type is explained rather than performed.

           The explain_key function returns the value NIL.


--*-- extend_command Command

           The extend_command command is the EMACS facility that allows you to
           execute any EMACS  function  by  typing  {ESC} X  followed  by  the
           function's name.


--*-- fasdump Function

           The fasdump  function  compiles  and  dumps  the  current buffer in
           fasload format.

           Format:  (fasdump s [d])

           Arguments:  The argument s must be a string value.  The argument d,
           if specified, must be a Boolean value.

           Action:  The  fasdump  function   compiles   the   current   buffer
           (containing PEEL  code)  and puts the result into a file.  The name
           of the  file  is  the  concatenation  of  the  string  s  and   the
           string .EFASL.

           The fasdump function returns the value false.


--*-- fasload Function

           The fasload function loads a fasload format file.

           Format:  (fasload s [d])

           Arguments:  The argument s must be a string value.  The argument d,
           if specified, must be a Boolean value.

           Action:  The  fasload  function loads and executes a fasload-format
           file.  The name of the file is the concatenation of  the  string  s
           and the string ".EFASL".

           If the  argument  d  is  not  specified, let d equal false.  If the
           value of  d  is  true,  then  debugging  information  is   printed;
           otherwise, debugging information is not printed.

           The fasload function returns the value false.


--*-- file_info Function

           The file_info function queries or sets information about a file.

           Format:  (file_info s p [v])

           Arguments:  The argument s must be a string value.

           The argument s is the pathname of the file.

           The argument  p  (representing the desired property) must be one of
           the atoms listed below under action.

           The argument v, if  specified,  must  have  a  data  type  that  is
           consistent with the argument p.

           Action:  Each  possible  value  of  the argument p corresponds to a
           file property.  The different  possible  values  for  p  and  their
           corresponding properties are as follows:

                     p         Data Type              File Property

               path_name        string      Absolute pathname of the file.

               entry_name       string      Entry name of the file.

               directory_name   string      The name  of  the  directory  that
                                            contains the  file.   (read-only).

               type             string      Type  of   file:    none,    file,
                                            directory,   segdir,  or  unknown.
                                            (read-only)

               exists           Boolean     True if and only if  file  exists.
                                            (read-only)

               dumped           Boolean     True if and only if file has  been
                                            dumped.  (read-only)

           The argument v, if specified, must have the data type shown for the
           argument p in the preceding table.

           The file information attribute being set or queried is specified by
           the argument p, as shown in the preceding table.  If the argument v
           is specified,  it  is  ignored, because at the present time no file
           attribute values may be changed.

           The file_info function returns the  value  of  the  file  attribute
           specified by the argument p, as shown in the preceding table.


--*-- file_name Function

           The file_name function returns the default filename associated with
           a buffer.

           Format:  (file_name cur)

           Argument:  The argument cur must be a cursor value.

           Action:  The file_name function returns a string value.  The string
           value returned  is  the  file  name associated with the buffer into
           which the cursor cur points.


--*-- file_operation Function

           The file_operation function deletes a file.

           Format:  (file_operation s delete)

           Argument:  The argument s must be a string value.

           Action:  EMACS deletes the file with the pathname specified by  the
           string s, and returns the PRIMOS error code.  The error code equals
           zero if  the  delete was successful.  The error code equals nonzero
           if the delete fails for  any  of  the  following  reasons:   a  bad
           pathname, a nonexistent file, a file that is not a SAM or DAM file,
           or any other deletion error.


--*-- fill_array Function

           The fill_array function fills an array with a specified value.

           Format:  (fill_array a v [m [n]])

           Arguments:  The argument a must be an array value.  Usually it is a
           variable that  has  been bound to an array by means of the setq and
           make_array functions.

           The argument v is the value to which the elements of the arrays are
           to be set.  The data type of v must be  consistent  with  the  data
           type of  the  array a, as specified in the make_array function that
           created the array a.

           The arguments m and n, if specified, must be integer values.

           Action:  The fill_array function returns a value whose data type is
           the data type of the elements of the array a.

           If the argument m is not specified, let m equal 0.

           If the argument n is not specified, let n equal the  maximum  array
           index, which is one less then the number of elements in the arrays,
           as specified  in  the make_array function that created the array a.

           The value of m must be greater than or equal to 0 and less than  or
           equal to  n.   The  value  of  n  must  be  less than the number of
           elements in the array a, as specified in  the  make_array  function
           that created the array a.

           EMACS assigns  the  value v to each of the elements of the array a,
           beginning with index m and ending with index n.

           The fill_array function returns the value v.


--*-- fill_end_token_insert_left Function

           The fill_end_token_insert_left function wraps to  the  fill  column
           and inserts command characters.

           Format:  (fill_end_token_insert_left)

           Arguments:  None.

           Action:  EMACS  wraps  to  the  fill  column  and  inserts  command
           characters.


--*-- fill_end_token_insert_pfx Function

           The fill_end_token_insert_pfx function wraps to  the  fill  column,
           preserving the  current whitespace prefix on each line, and inserts
           command characters.

           Format:  (fill_end_token_insert_pfx)

           Arguments:  None.

           Action:  EMACS wraps to the fill  column,  preserving  the  current
           whitespace prefix  on  each  line,  and inserts command characters.
           The indent is similar to cret_indent_relative.


--*-- fill_off Command and Function

           The fill_off command or function turns off fill mode.

           Command Format:  {ESC} X fill_off

           Function Format:  (fill_off)

           Arguments:  A numeric argument, if specified, is ignored.

           Action:  EMACS turns off fill mode.

           The fill_off function returns the value NIL.


--*-- fill_on Command and Function

           The fill_on command or function turns on fill mode.

           Command Format:  {ESC} X fill_on

           Function Format:  (fill_on)

           Arguments:  A numeric argument, if specified, is ignored.

           Action:  EMACS turns on fill mode so that words  are  automatically
           moved from  line  to  line  in order to fill lines to the specified
           lengths.

           The fill_on function returns the value NIL.


--*-- fill_para Command and Function

           The fill_para command or function fills and  optionally  adjusts  a
           paragraph.

           Command Format:  [{ESC}n] {ESC} X fill_para
                            or
                            [{ESC}n] {ESC} Q

           Function Format:  (fill_para [n])

           Argument:  The  argument n, if specified, must be an integer value.

           Action:  The  fill_para  command  or  function  fills  the  current
           paragraph so  that  each line does not have more than the number of
           characters indicated by the function  (buffer_info fill_column)  or
           by the  command tell_right_margin.  It rearranges words on the line
           so that each line is about the same length.   Use  set_right_margin
           to change the right margin.

           If the  left  margin  is greater than zero, the text is indented by
           that number of characters.  The left margin  is  specified  by  the
           variable fill_prefix,  and  is  displayed  by  the tell_left_margin
           command.  Use set_left_margin to change the left margin.

           If the argument n  is  specified  and  is  greater  than  one,  the
           paragraph is additionally right-justified.

           To undo  the  results  of  fill_para,  use  the  untidy  command or
           function.


--*-- find_buffer Function

           The find_buffer function returns a cursor that points to the  start
           of a specified buffer.

           Format:  (find_buffer s)

           Argument:  The argument s must be a string value.

           Action:  The find_buffer function returns a cursor value.

           EMACS interprets  the  string s as a buffer name.  If a buffer with
           that name does not exist, EMACS creates  a  new  buffer  with  that
           name.

           EMACS returns  a  cursor  value pointing to the start of the buffer
           whose name is given by the string s.

           Example:  The following statement

                (go_to_cursor (find_buffer "xyz"))

           moves the current cursor to the start of the buffer  xyz,  creating
           that buffer if necessary.


--*-- find_file Command and Function

           The find_file  command  or function finds a file either in an EMACS
           buffer or in the PRIMOS file system.

           Command Format:  {ESC} X find_file
                            or
                            {CTRL-X} {CTRL-F}

           Function Format:  (find_file s)

           Argument:  The argument s to the find_file must be a string  value.

           A numeric argument, if specified, is ignored.

           Action:  For  the  find_file  command, EMACS prompts you for a file
           name, and assigns the string you type to the variable s.

           If there is a buffer with a name equal to the value of  the  string
           s, EMACS makes that buffer the current buffer.

           If there is no such buffer, EMACS proceeds as follows:

               o  It searches the PRIMOS file system for  a  file  with  names
                  specified by  s.  If there is no such file, EMACS terminates
                  this operation with an error message.

               o  It creates a new buffer with the buffer name  s,  and  loads
                  the text of the file into that buffer, making it the current
                  buffer.

           The find_file function returns the value NIL.

           Note:  You  may  use PRIMOS conventions in using special characters
           and options in your filename string.  For example, the string

                 foo@@ -after 7/22/85

           searches for all files beginning with "foo", created since July 22,
           1985.

           (See the Prime User's Guide manual for complete details.)


--*-- find_mode Function

           The find_mode function returns a dispatch table to a desired mode.

           Format:  (find_mode m)

           Argument:  The argument m must be either a string or a quoted atom.

           Action:  The find_mode function returns a value with the
           dispatch_table data type.

           The argument m must be the name (either in string or in quoted atom
           form) of a mode.  The find_mode function returns a dispatch table
           for that mode.  If the mode does not exist, it will be created.


--*-- finish_macro Command

           The finish_macro command terminates a macro whose keystrokes were
           collected beginning with the collect_macro command.

           Format:  {ESC} X finish_macro
                    or
                    {CTRL-X} )

           Argument:  A numeric argument, if specified, is ignored.

           Action:  Collection of keystrokes is begun with  the  collect_macro
           command and  ended with the finish_macro command.  The finish_macro
           command makes the keystroke collection available as  a  macro  that
           can be  invoked  by  the  execute_macro  command, which is normally
           bound as {CTRL-X} E.


--*-- first_line_p Function

           The first_line_p  function  returns  a  Boolean  value   indicating
           whether the  current  cursor  position  is at the first line in the
           buffer.

           Format:  (first_line_p)

           Arguments:  None.

           Action:  The first_line_p function returns a  Boolean  value.   The
           returned value  is  true if the current cursor position points to a
           character in the first line of the buffer;  otherwise it is  false.


--*-- firstlinep Function

           The firstlinep  function  is  an  abbreviation  of the first_line_p
           function.


--*-- flush_typeahead Function

           The flush_typeahead function flushes pending keyboard input.  It is
           usually used for error clean up.

           Format:  (flush_typeahead)

           Arguments:  None.

           Action:  The flush_typeahead function invokes the PRIMOS supervisor
           call that flushes typeahead by clearing the keyboard input  buffer.

           The flush_typeahead function returns the value NIL.


--*-- forward_char Command and Function

           The forward_char  command or function moves the cursor forward by a
           specified number of characters.

           Command Format:  [{ESC}n] {ESC} X forward_char
                            or
                            [{ESC}n] {CTRL-F}

           Function Format:  (forward_char [n])

           Argument:  The argument n, if specified, must be an  integer  whose
           value may be positive, 0, or negative.

           Action:  If n is not specified, let n equal 1.

           If the value of n is 0, no action takes place.

           If the  value  of  n  is  positive,  the  cursor is moved forward n
           characters, stopping if the end of the buffer is reached.

           If the value of n is  negative,  the  cursor  is  moved  back  (-n)
           characters, stopping if the beginning of the buffer is reached.

           The forward_char function returns the value NIL.


--*-- forward_clause Command and Function

           The forward_clause  command or function moves the cursor forward by
           a specified number of clauses.

           Command Format:  [{ESC}n] {ESC} X forward_clause
                            or
                            [{ESC}n] {CTRL-X} {CTRL-Z} {CTRL-E}

           Function Format:  (forward_clause [n])

           Argument:  The argument n, if specified, must be an  integer  whose
           value may be positive, 0, or negative.

           Action:  If n is not specified, let n equal 1.

           If the value of n is 0, no action takes place.

           If the  value  of  n is positive, EMACS moves the cursor forward to
           the nth occurrence of a character that delimits  a  clause.   (That
           is, EMACS  moves  the cursor ahead n clauses, leaving the cursor on
           the character immediately following  the  last  clause  delimiter.)
           Cursor movement stops if the end of the buffer is reached.

           If the  value  of n is negative, EMACS moves the cursor back to the
           character preceding the  (-n)th  occurrence  of  a  character  that
           delimits a  clause.   (That  is,  EMACS  moves the cursor back (-n)
           clauses and leaves it at the character preceding  the  last  clause
           delimiter.)  Cursor  movement  stops if the beginning of the buffer
           is reached.

           The forward_clause function returns the value NIL.

           Note:  The characters delimiting a  clause  are  contained  in  the
           global string variable clause_scan_table$.


--*-- forward_clausef Function

           The forward_clause function moves the cursor forward by a specified
           number of  clauses,  and returns a Boolean value indicating whether
           the operation was successful.

           Format:  (forward_clausef [n])

           Argument:  The argument n, if specified, must be an  integer  whose
           value may be positive, 0, or negative.

           Action:  The forward_clausef function returns a Boolean value.

           If n is not specified, let n equal 1.

           If the  value  of  n  is  0,  no  cursor  movement  takes place and
           forward_clausef returns the value true.

           If the value of n is positive, EMACS moves the  cursor  forward  to
           the nth  occurrence  of  a character that delimits a clause.  (That
           is, EMACS moves the cursor ahead n clauses, leaving the  cursor  on
           the last  character  following  the last clause delimiter.)  Cursor
           movement stops if the end of the buffer is reached.  If the end  of
           the buffer  is  reached,  forward_clausef  returns the value false;
           otherwise, forward_clausef returns the value true.

           If the value of n is negative, EMACS moves the cursor back  to  the
           character preceding  the  (-n)th  occurrence  of  a  character that
           delimits a clause.  (That is, EMACS  moves  the  cursor  back  (-n)
           clauses leaving  it  at  the  character  preceding  the last clause
           delimiter.)  Cursor movement stops if the beginning of  the  buffer
           is   reached.   If  the  beginning  of  the  buffer   is   reached,
           forward_clausef   returns    the    value    false;      otherwise,
           forward_clausef returns the value true.

           Note:  The  list  of characters delimiting a clause may be found in
           the global string variable clause_scan_table$.


--*-- forward_kill_clause Command and Function

           The forward_kill_clause command or function  kills  text  from  the
           current cursor position to the end of the specified clauses.

           Command Format:  [{ESC}n] {ESC} X forward_kill_clause
                            or
                            [{ESC}n] {CTRL-X} {CTRL-Z} {CTRL-K}

           Function Format:  (forward_kill_clause [n])

           Argument:  The  argument  n, if specified, must be an integer value
           whose value may be positive, 0, or negative.

           Action:  If n is not specified, let n equal 1.

           If the value of n is 0, no action takes place.

           If the value of n is positive, EMACS kills  all  the  text  in  the
           region starting  with  the  current cursor position and ending with
           the end of the nth clause in a forward direction.

           If the value of n is negative, EMACS kills all text in  the  region
           ending with  the  current  cursor  position, and beginning with the
           (-n)th clause in a backward direction.

           The forward_kill_clause function returns the value NIL.

           Note:  The list of characters delimiting a clause may be  found  in
           the global string variable clause_scan_table$.


--*-- forward_kill_sentence Command and Function

           The forward_kill_sentence  command  or function kills text from the
           current cursor position to the end of the specified sentence.

           Command Format:  [{ESC}n] {ESC} X forward_kill_sentence
                            or
                            [{ESC}n] {ESC} K

           Function Format:  (forward_kill_sentence [n])

           Argument:  The argument n, if specified, must be an  integer  whose
           value may be positive, 0, or negative.

           Action:  If n is not specified, let n equal 1.

           If the value of n is 0, no action takes place.

           If the value of n is positive, EMACS deletes all text in the region
           beginning with  the current cursor position and ending with the end
           of the nth sentence in a forward direction.

           If the value of n is negative, EMACS deletes all text in the region
           beginning with the (-n)th sentence in a  preceding  direction,  and
           stopping at the current cursor position.


--*-- forward_para Command and Function

           The forward_para  command or function moves the cursor forward by a
           specified number of paragraphs.

           Command Format:  [{ESC}n] {ESC} X forward_para
                            or
                            [{ESC}n] {CTRL-X}]

           Function Format:  (forward_para [n])

           Argument:  The argument n, if specified, must be an  integer  whose
           value may be positive, 0, or negative.

           Action:  If n is not specified, let n equal 1.

           If the value of n is 0, no action takes place.

           If the  value  of  n is positive, EMACS moves the cursor forward to
           the character preceding the nth  occurrence  of  a  character  that
           delimits a  paragraph.   (That is, EMACS moves the cursor forward n
           paragraphs, leaving  the  cursor  on  the   character   immediately
           following the  last paragraph delimiter.)  Cursor movement stops if
           the end of the buffer is reached.

           If the value of n is negative, EMACS moves the cursor  backward  to
           the (-n)th  occurrence  of  a  character that delimits a paragraph.
           (That is, EMACS moves the cursor back n paragraphs, leaving  it  at
           the character  preceding  the  last  paragraph  delimiter.)  Cursor
           movement stops if the beginning of the buffer is reached.

           The forward_para function returns the value NIL.

           Note:  Paragraphs are defined as lines beginning with a  period,  a
           blank line, or lines beginning with a space.


--*-- forward_search Function

           The   forward_search  function  searches  the  text  buffer  for  a
           specified string, and returns a Boolean value indicating success or
           failure.

           Format:  (forward_search s)

           Argument:  The argument s must be a string argument.

           Action:  EMACS searches forward for  the  string  s  in  your  text
           buffer, starting with the character at the current cursor position.

           If the  search  is  successful,  EMACS  moves  the  cursor  to  the
           character following the matching string in  the  text  buffer,  and
           returns the value true.

           If the search fails, the cursor is left unchanged, and the function
           returns the value false.


--*-- forward_search_command Command and Function

           The forward_search_command  command or function searches forward in
           your text buffer for a string.

           Command Format:  {ESC} X forward_search_command
                            or
                            {CTRL-S}

           Function Format:  (forward_search_command [s])

           Arguments:  A numeric argument, if specified, is ignored.

           The argument s, if specified, must be a string value.

           Action:  If the argument s is not specified, EMACS prompts you  for
           a string value, which is assigned to the string s.

           EMACS searches  forward  in  the  text  buffer  for  the  string s,
           starting with the character in the current cursor position.

           If the search succeeds, EMACS  moves  the  current  cursor  to  the
           character following the string.

           If the search is unsuccessful, EMACS displays an error message.


--*-- forward_sentence Command and Function

           The forward_sentence  command  or function moves the cursor forward
           by the specified number of sentences.

           Command Format:  [{ESC}n] {ESC} X forward_sentence
                            or
                            [{ESC}n] {ESC} E

           Function Format:  (forward_sentence [n])

           Argument:  The argument n, if specified, must be an  integer  whose
           value may be positive, 0, or negative.

           Action:  If n is not specified, let n equal 1.

           If the value of n is 0, no action takes place.

           If the  value  of  n is positive, EMACS moves the cursor forward to
           the nth occurrence of a character that delimits a sentence.   (That
           is, EMACS moves the cursor ahead n sentences, leaving the cursor on
           the character  immediately  following the last sentence delimiter.)
           Cursor movement stops if the end of the buffer is reached.

           If the value of n is negative, EMACS moves the cursor back  to  the
           character preceding  the  (-n)th  occurrence  of  a  character that
           delimits a sentence.  (That is, EMACS moves the  cursor  back  (-n)
           sentences, and  leaves  it  at  the  character  preceding  the last
           sentence delimiter.)  Cursor movement stops if the beginning of the
           buffer is reached.

           The forward_sentence function returns the value NIL.

           Note:  The characters delimiting  a  sentence  are  in  the  global
           string variable sentence_scan_table$.


--*-- forward_sentencef Function

           The forward_sentencef  function  moves  the  cursor  forward  by  a
           specified number  of  sentences,  and  returns  a   Boolean   value
           indicating whether the operation was successful.

           Format:  (forward_sentencef [n])

           Argument:  The  argument  n, if specified, must be an integer whose
           value may be positive, 0, or negative.

           Action:  The forward_sentencef function returns a Boolean value.

           If the value of n is not specified, let n equal 1.

           If the value of n  is  0,  no  cursor  movement  takes  place,  and
           forward_sentencef returns the value true.

           If the  value  of  n is positive, EMACS moves the cursor forward to
           the nth occurrence of a character that delimits a sentence.   (That
           is, EMACS moves the cursor ahead n sentences, leaving the cursor on
           the character  immediately  following the last sentence delimiter.)
           If the end of the buffer is reached,  cursor  movement  stops,  and
           forward_sentencef returns  the  value false;  otherwise, it returns
           the value true.

           If the value of n is negative, EMACS moves the cursor back  to  the
           character preceding  the  (-n)th  occurrence  of  a  character that
           delimits a sentence.  (That is, EMACS moves the  cursor  back  (-n)
           sentences, leaving  it  at  the  last  sentence delimited.)  If the
           beginning of the buffer  is  reached,  cursor  movement  stops  and
           forward_sentencef returns  the  value false;  otherwise, it returns
           the value true.

           Note:  The characters delimiting  a  sentence  are  in  the  global
           string variable sentence_scan_table$.


--*-- forward_word Command and Function

           The forward_word  command or function moves the cursor forward by a
           specified number of words.

           Command Format:  [{ESC}n] {ESC} X forward_word
                            or
                            [{ESC}n] {ESC} F

           Function Format:  (forward_word [n])

           Argument:  The argument n, if specified, must be an  integer  whose
           value may be positive, 0, or negative.

           Action:  If n is not specified, let n equal 1.

           If the value of n is 0, no action takes place.

           If the  value  of  n is positive, EMACS moves the cursor forward to
           the nth occurrence of a character that immediately follows a  word.
           (That is,  EMACS moves the cursor ahead n words, leaving the cursor
           on the whitespace character immediately following the  end  of  the
           words.)  Cursor movement stops if the end of the buffer is reached.

           If the  value  of n is negative, EMACS moves the cursor back to the
           (-n)th occurrence of a character that begins  a  word.   (That  is,
           EMACS moves  the  cursor  back  (-n) words, leaving it at the first
           character of that word.)  Cursor movement stops if the beginning of
           the buffer is reached.

           The forward_word function returns the value NIL.

           Note:  The token_chars atom contains a list of the characters  that
           define a word or token.


--*-- found_file_hook Command and Function

           The found_file_hook  command  or function checks a suffix and turns
           on the mode associated with that suffix.

           Command Format:  {ESC} X found_file_hook

           Function Format:  (found_file_hook)

           Arguments:  A numeric argument, if specified, is ignored.

           Action:  EMACS examines the suffix of the file associated with  the
           current buffer,  and turns on the mode associated with that suffix.
           (See the EMACS Reference Guide, Appendix A.)

           The found_file_hook function returns the value NIL.


--*-- fset Function

           The fset LISP function sets the function cell of an atom.

           Format:  (fset a f)

           Arguments:  The argument  a  is  any  atom,  usually  quoted.   The
           argument f is a function.

           Action:  The  fset function sets the function cell of the atom a to
           the value f, and returns the value f.

           Note:  Every PEEL symbol has associated with it a function cell (or
           function value) similar to its ordinary value.  Usually you set the
           function cell by means of a defun or  defcom.   The  fset  function
           lets you  set  it  explicitly,  and  the fsymeval function lets you
           obtain the function call explicitly.


--*-- fsymeval Function

           The fsymeval LISP function returns the  contents  of  the  function
           cell of an atom.

           Format:  (fsymeval a)

           Argument:  The argument a must be an atom.

           Action:  The  fsymeval  function  returns  the function cell of the
           atom a.  The value  returned  may  have  any  data  type.   If  the
           function cell is not set, fsymeval returns NIL.

           fsymeval usually  returns  a value of type handler for commands and
           type function for functions.

           (See the fset function for further information.)

--*-- function Data Type

           This is a data type.  Functions are objects that contain executable
           code.  A function contains all the information needed to call  this
           code.  This  includes  the number of expected arguments, their data
           types, and the type of  value  that  will  be  returned.   Built-in
           functions have  their  code  written  in  PL/I,  while user written
           functions are written in the PEEL extension language and have  list
           structure as their executable code.


--*-- function_info Function

           The   function_info  function  returns  information  about  a  PEEL
           function.

           Format:  (function_info f p [n])

           Arguments:  The argument f must have the  data  type  function,  as
           returned by  the fsymeval function, for example.  The argument p is
           an atom representing the property you wish to determine.  The  list
           of legal values for p is given below.

           The argument n, if specified, must be an integer value.

           Action:  The  data  type of the value returned by the function_info
           function depends upon the symbol p.

           The following table lists the legal values for p, the data type  of
           the value  returned  by  function_info,  and  the function property
           corresponding to the value of p.

           p                      Data Type   Property

           return_value           integer     Data type of the returned value.
                                              (See  typef   for   meaning   of
                                              integral value.)

           argument_type          integer     Data type of the  nth  argument.

           special_form           Boolean     True if arguments to handler are
                                              passed unevaluated in a list (as
                                              if &rest  was   used   for   all
                                              arguments for a defcom).

           user_defined_function  Boolean     True if code is PEEL rather than
                                              PL/I.

           returns_a_value        Boolean     True if the function  returns  a
                                              value.

           required_arguments     integer     Number of required arguments.

           optional_arguments     integer     Number of optional arguments.

           evaluate_argument      Boolean     True if   the   "&quote"   defun
                                              option   applies  to   the   nth
                                              argument, false otherwise.

           cleanup_handler        any         The handler to be invoked if the
                                              function is  aborted.   (NIL  if
                                              none   established.)   Atom   of
                                              cleanup_handler is returned.


--*-- get Function

           The get LISP function returns the value associated with a tag in  a
           given property list (plist).

           Format:  (get pl t)

           Arguments:  The  arguments  pl and t must be atoms, usually quoted.

           Action:  If the atom pl is an atom with a property list, and if the
           argument t appears as a tag in that property list, the get function
           returns the value associated with the tag t.   Otherwise,  the  get
           function returns the value NIL.

           Note:  A  tag  and value can be added to an atom's property list by
           means of the putprop function, and can be removed by means  of  the
           remprop.

           Example:  Suppose that the property list of the atom Jane is

                ((age 6) (hair blonde) (eyes blue))

           then the function

                (get 'Jane 'age)

           returns the value 6, while the function

                (get 'Jane 'weight)

           returns the value NIL.


--*-- get_cursor Function

           The get_cursor function returns a list of all the cursor properties
           that may be obtained by the cursor_info function.

           Format:  (get_cursor [cur])


           Argument:  The  argument cur, if specified, must be a cursor value.

           Action:  The get_cursor function returns a list value.

           If the argument cur is not specified, let  cur  equal  the  current
           cursor position.

           The get_cursor  function  returns a list containing all values that
           may be obtained by the cursor_info function.  These values are:

               o  A string value containing the buffer name of the cursor  cur

               o  An integer value containing the line number

               o  An integer value containing the character  position  on  the
                  line

               o  A Boolean value containing the sticky flag

           The get_cursor function returns a list containing those values.

           Example:  A typical value returned by get_cursor might be:

                ("main" 6 11 false)


--*-- get_filename Command and Function

           The get_filename command or function retrieves the current pathname
           of the current buffer and inserts it at point.

           Command Format:  {ESC} X get_filename
                            or
                            {CTRL-X} {CTRL-Z} {CTRL-F}

           Function Format:  (get_filename)

           Argument:  A numeric argument, if specified, is ignored.

           Action:  EMACS forms  a  string  containing  the  current  buffer's
           associated pathname  and  inserts it into the buffer at the current
           cursor position.

           The get_filename function returns the value NIL.


--*-- get_pname Function

           The get_pname function returns the print name of an atom.

           Format:  (get_pname a)

           Argument:  The value of the argument a must be a quoted atom.

           Action:  The get_pname function returns a string value that is  the
           name of the atom.

           Example:  The function

                (get_pname 'xyz)

           returns the string "xyz".


--*-- get_tab Command and Function

           The get_tab  command or function restores tabs that were previously
           saved.

           Command Format:  {ESC} X get_tab [s] [t]

           Function Format:  (get_tab [s] [t])

           Arguments:  A numeric argument, if specified, is ignored.

           The arguments s and t, if specified, must be string values.

           Action:  If the argument s is not specified, EMACS prompts you  for
           a filename.   The  typed  string is assigned to the variable s.  If
           the argument t is not specified, EMACS prompts you for the name  by
           which the  tabs  are  stored  in  the  file.   The  typed string is
           assigned to the variable t.

           The string s must be the filename of a file that was  created  with
           the save_tab  command  or function, and the string t must be a name
           of tabs in that file.  EMACS restores the  tab  settings  to  their
           value at the time that the file was saved.

           The get_tab function returns the value NIL.


--*-- go_to_buffer Function

           The go_to_buffer  function positions the cursor at the beginning of
           the specified buffer and returns that cursor.

           Format:  (go_to_buffer s)

           Argument:  The argument s must be a string value.

           Action:  The go_to_buffer function returns a cursor value.

           EMACS moves the current cursor  to  the  beginning  of  the  buffer
           specified by  the string s.  The go_to_buffer function returns that
           cursor position.


--*-- go_to_cursor Function

           The go_to_cursor function moves the current cursor to the specified
           cursor.

           Format:  (go_to_cursor cur)

           Argument:  The argument cur must have the cursor data type.

           Action:  EMACS moves the current cursor to the  position  specified
           by the  argument  cur.   The go_to_cursor function returns a cursor
           value equal to the new cursor position.


--*-- go_to_hpos Function

           The go_to_hpos function goes to the specified  horizontal  position
           on the current line.

           Format:  (go_to_hpos n)

           Argument:  The argument n must be an integer value.

           Action:  The go_to_hpos function returns a Boolean value.

           EMACS attempts  to  move  the  cursor  to  the  horizontal position
           specified by the argument n.  If this is possible,  the  go_to_hpos
           function returns  the  value true;  otherwise, it returns the value
           false.

           It is possible under the following conditions:

               o  The value of n is positive and smaller than  the  number  of
                  characters on the current line.

               o  The value of n is positive and smaller than the value of the
                  line margin, and two-dimensional mode is on.


--*-- go_to_window Function

           The go_to_window function moves the cursor to the buffer associated
           with the specified window.

           Format:  (go_to_window w)

           Argument:  The data type of the argument w must be a window.

           Action:  The argument w must be a window that  is  on  the  screen.
           The go_to_window  function  makes  the  cursor  associated with the
           window the current cursor.  It does not change the association of a
           window and a cursor.

           The go_to_window function returns the value NIL.


--*-- goto_line Command and Function

           The goto_line command or function moves the  current  cursor  to  a
           specified line in the buffer.

           Command Format:  [{ESC}n] {ESC} X goto_line
                            or
                            [{ESC}n] {ESC} G

           Function Format:  (goto_line [n])

           Argument:  The  argument n, if specified, must be an integer value.

           Action:  If n is not specified, let n equal 1.

           If n is less than or equal to 1, EMACS  moves  the  cursor  to  the
           first line of the buffer.

           If n  is larger than the number of lines in the buffer, EMACS moves
           the cursor to the last line of the buffer.

           Otherwise, EMACS moves the cursor to line n of the buffer.

           The goto_line function returns the value NIL.


--*-- handler Data Type

           The handler data type represents a handler, which is a  command  as
           defined by using defcom.


--*-- handler_info Function

           The handler_info function gets or sets information about a handler.

           Format:  (handler_info h p [v])

           Arguments:  The argument h must have the handler data type, usually
           as returned  either  from  the  current_handler  function  or  from
           fsymeval of an atom returned from dispatch_info.

           The argument p must be one of the atoms listed below under  action.

           The argument  v,  if  specified,  must  have  a  data  type that is
           compatible with the atom p.

           Action:  The handler_info function returns a value whose data  type
           depends upon the argument p.

           Each value  of  the argument p corresponds to information about the
           handler h.  The following table gives the possible values  for  the
           argument p, along with their associated data types and meanings.

           p            Data Type           Property

           name         string              Name of the handler.

           handler      function or         The  function code of the command.
                        PL/I_subroutine     If internal,   it   is   of   type
                                            PLI_subroutine;  if  external,  of
                                            type function.

           is_prefix    Boolean             Command has specified  &prefix  in
                                            its header.

           explanation  string              The  &doc   documentation   string
                                            associated with  the  command.  If
                                            none, null string.

           data_value   any                 Any data value may be here.

           uses_character_argument
                        Boolean             Command  has   &chararg   in   its
                                            header.

           If the  value v is not specified, the handler_info function returns
           the information associated with the argument p.  If the argument  v
           is specified,  the  handler_info  function  sets  the corresponding
           property value to v, and returns the old value of the property.

           If the command is internal or shared, none of  the  values  may  be
           changed.  Otherwise, any value except the name may be changed.


--*-- have_input_p Function

           The have_input_p  function  returns  a  Boolean value indicating if
           there is pending keyboard input.

           Format:  (have_input_p)

           Arguments:  None.

           Action:  The have_input_p function returns a  Boolean  value.   The
           value is true if there is pending keyboard input;  otherwise, it is
           false.


--*-- hcol Command and Function

           The hcol command or function sets or queries the horizontal column,
           that is, the column number of the leftmost column displayed on your
           screen.

           Command Format:  [{ESC}n] {ESC} X hcol

           Function Format:  (hcol [n])

           Argument:  The numeric argument n, if specified, must be an integer
           value.

           Action:  The  argument  n, if specified, must be positive.  If n is
           specified, EMACS  sets  the  horizontal  column   (for   horizontal
           scrolling) to  the  value  specified  by n.  The result is that the
           leftmost column displayed on your screen will be text column n.

           EMACS displays  the  current  horizontal  column   value   in   the
           minibuffer.  (This  happens  whether the argument n is specified or
           not.)

           The hcol function returns the value NIL.


--*-- help_char Command

           The help_char command invokes the explain command.

           Format:  {ESC} X help_char
                    or
                    {CTRL-_}

           Arguments:  A numeric argument, if specified, is ignored.

           Action:  The help_char command invokes the  explain  facility  that
           provides you with help information.


--*-- high_bit_off Function

           The high_bit_off  function  turns  off  the high-order bits in each
           character of a string.

           Format:  (high_bit_off s)

           Argument:  The argument s must be a string or character value.

           Action:  The high_bit_off function returns  a  string  value.   The
           string value  is obtained by turning off the high-order bit in each
           character of string s.


--*-- high_bit_on Function

           The high_bit_on function turns  on  the  high-order  bits  in  each
           character of a string.

           Format:  (high_bit_on s)

           Argument:  The argument s must be a string or character value.

           Action:  The  high_bit_on  function  returns  a  string value.  The
           string value is obtained by turning on the high-order bit  in  each
           character of string s.


--*-- hscroll Command and Function

           The hscroll command sets hcol to the current column position.

           Command Format:  {ESC} X hscroll

           Function Format:  (hscroll)

           Arguments:  A numeric argument, if specified, is ignored.

           Action:  Let  k  be  the horizontal position of the current cursor.
           Then EMACS executes

                (hcol k)

           The hscroll function returns the value NIL.


--*-- if Special Form

           The if special form  allows  you  to  perform  conditional  program
           execution.

           Format:  (if b s1 else s2)

           Arguments:   The  argument  b  must  have  a  Boolean  value.   The
           arguments s1 and s2 must be PEEL statements.

           Action:  If  the  value  of  b  is  true,  then  s1  is   executed;
           otherwise, s2 is executed.

           The if special form returns the value NIL.


--*-- if_at Special Form

           The if_at  special form performs conditional execution depending on
           the string to the right of the current cursor position.

           Format:  (if_at s s1 else s2)

           Arguments:  The argument s must be a string value.   The  arguments
           s1 and s2 must be PEEL source statements.

           Action:  If  the  text  to the right of the current cursor position
           equals the characters  of  the  string  s,  then  s1  is  executed;
           otherwise, s2 is executed.

           The if_at special form returns the value NIL.

           Note:  The use of if_at is the same as

                (if (looking_at "string") ...  ))


--*-- ignore_prefix Command

           The ignore_prefix  command  aborts  a  partially  completed command
           sequence.

           Format:  {ESC} X ignore_prefix

           Arguments:  None.

           Action:  This command only makes sense when bound.  It is  normally
           bound to the {CTRL-G} entry in dispatch tables referenced through a
           prefix.  For  example, {CTRL-X} {CTRL-G} is bound to ignore_prefix,
           so that you can abort a command prefixed by {CTRL-X}.


--*-- indent_line_to_hpos Command and Function

           The indent_line_to_hpos command or  function  indents  the  current
           line to the specified horizontal position.

           Command Format:  [{ESC}n] {ESC} X indent_line_to_hpos

           Function Format:  (indent_line_to_hpos n)

           Argument:  The argument n must be an integer value.

           Action:  The  indent_line_to_hpos function returns a Boolean value.

           EMACS deletes all whitespace characters from the beginning  of  the
           current line, and then inserts n blanks.

           The indent_line_to_hpos  function  returns  the  value  true if the
           operation succeeds;  otherwise, it returns false.


--*-- indent_relative Command and Function

           The indent_relative command or function indents the current line to
           the same horizontal position as the preceding line.


           Command Format:  [{ESC}n] {ESC} X indent_relative
                            or
                            [{ESC}n] {ESC} I

           Function Format:  (indent_relative [n])

           Argument:  The argument n, if specified, must be an  integer  whose
           value may be positive, 0, or negative.

           Action:  EMACS performs the following steps:

               o  Inserts or deletes whitespace characters at the beginning of
                  the current line, so that the first  nonblank  character  of
                  the line  is  indented exactly as much as the first nonblank
                  character of the preceding line.   (Note:   If  the  current
                  line is  the  first line of the buffer or the preceding line
                  contains only whitespace, then no blanks are inserted at the
                  beginning of the line.)

               o  Leaves the cursor at the first  nonblank  character  of  the
                  line.

               o  If n is not specified, let n equal 0.

               o  Executes the function

                       (insert_tab n)

                  If n is positive, this inserts n tabs.  If  n  is  negative,
                  this moves back (-n) tab stops.

           The indent_relative function returns the value NIL.


--*-- indent_to_fill_prefix Command and Function

           The indent_to_fill_prefix  command  or function indents the current
           line to the current left margin.

           Command Format:  [{ESC}n] {ESC} X indent_to_fill_prefix
                            or
                            [{ESC}n] {ESC} {CTRL-I}

           Function Format:  (indent_to_fill_prefix [n])

           Argument:  The argument n, if specified, must be an  integer  whose
           value may be positive, 0, or negative.

           Action:  If n is not specified, let n equal 1.

           If the value of n is 0, no action takes place.

           If the value of n is positive, then n lines of text, beginning with
           the current one and continuing forward, are indented.

           If the  value  of  n  is negative, then -n lines of text, beginning
           with the current one and proceeding backward, are indented.

           To indent a line of text, EMACS proceeds as follows:

               o  If the line is null  (contains  no  characters),  no  action
                  takes place.  Otherwise:

               o  EMACS removes all leading whitespace from the  beginning  of
                  the line.

               o  EMACS inserts fill_prefix spaces at  the  beginning  of  the
                  line.

           Note:  The value associated with the atom fill_prefix is set by the
           set_left_margin command.

           The indent_to_fill_prefix function returns the value NIL.


--*-- index Function

           The index  function,  which  is  like the PL/I function of the same
           name, returns the position of the second string within  the  first.

           Format:  (index s1 s2)

           Arguments:  The  arguments  s1  and  s2 must be string or character
           values.

           Action:  The index function returns an integer value.

           EMACS searches the string s1 for the  string  s2  as  a  substring.
           (For example,  "CDE" is a substring of "ABCDEF", but "CDF" is not.)

           If the string s2 appears as a substring of s1, the  index  function
           returns the position of the first character of the first occurrence
           of string  s2  within  s1.   If  s2 does not appear as a substring,
           index returns the value 0.

           Example:  The function

                (index "ABCDEF" "CDE")

           returns the value 3, because "CDE" appears as a substring  starting
           in character position 3 of "ABCDEF".

           The function

                (index "ABCDEF" "CDF")

           returns the  value 0, because "CDF" is not a substring of "ABCDEF".


--*-- info_message Special Form

           The info_message special form displays an  information  message  in
           the minibuffer.

           Format:  (info_message s1 [s2 ...  s8])

           Arguments:  The  info_message  special  form  takes  at  least  one
           argument and no more than eight arguments.  All arguments must have
           the string or character data type.

           Action:  EMACS concatenates all arguments  together,  as  described
           with the catenate function, and displays the concatenated string in
           the minibuffer.   The  message  will not appear on the screen until
           the next screen redisplay occurs.  Use error_message if you want to
           force a message to be displayed while redisplay is inhibited.


--*-- init_local_displays Function

           The init_local_displays function clears previous printout  material
           from the screen and starts "printout" mode.

           Format:  (init_local_displays s [b])

           Arguments:  The  argument  s must have a string or character value.
           The argument b, if specified, must be a Boolean value.

           Action:  EMACS clears the  main  text  window  on  your  screen  of
           previous printout  and  information messages, displays the string s
           on the first line, and enters "printout" mode.

           If the argument b is true or unspecified, the line is terminated at
           that point.  If the value of b is specified  and  false,  the  next
           call to  local_display_generator will append its data to the end of
           the current line.

           Example:  The function sequence

                         (print "The previous message")
                         (init_local_displays "23")

           would clear "The previous message" from the screen  and  print  the
           number 23 at the top.


--*-- insert Function

           The insert  function  inserts  a string into the text buffer at the
           specified cursor position.

           Format:  (insert s [cur])

           Arguments:  The argument s must have a string value.  The  argument
           cur, if specified, must have a cursor data type value.

           Action:  The insert function returns a string value.

           If the argument cur is specified, EMACS moves the current cursor to
           the position specified by the argument cur.

           EMACS inserts  the  characters  of string s into the text buffer at
           the current cursor position, and returns the value of string s.


--*-- insert_buf Command and Function

           The insert_buf command or function takes the  contents  of  a  text
           buffer and  inserts it into your current text buffer at the current
           cursor position.

           Command Format:  {ESC} X insert_buf
                            or
                            {CTRL-X} {CTRL-Z} I

           Function Format:  (insert_buf [s])

           Arguments:  A numeric argument, if specified, is ignored.

           The argument s, if specified, must be a string value.

           Action:  If the argument s is unspecified, EMACS  prompts  you  for
           the name  of  a  buffer.   The  resulting string is assigned to the
           variable s.

           EMACS inserts the contents of the buffer specified by the string  s
           into your current text buffer, at the current cursor position.  The
           cursor is left at the beginning of the inserted material.

           The insert_buf function returns the value NIL.


--*-- insert_buff Command and Function

           The insert_buff  command  or  function is an alternate name for the
           insert_buf command and function.


--*-- insert_file Command and Function

           The insert_file command or function inserts  a  disk  file  at  the
           current cursor position.

           Command Format:  {ESC} X insert_file
                            or
                            {CTRL-X} I

           Function Format:  (insert_file [s])

           Arguments:  A numeric argument, if specified, is ignored.

           The argument s, if specified to the insert_file function, must have
           a string value.

           Action:  If the argument s is not specified, EMACS prompts the user
           for a pathname, and assigns the typed string to the string s.

           EMACS opens  the  file  whose pathname is the string s, and inserts
           the text of that file at the current cursor position.   The  cursor
           is left at the beginning of the inserted material.

           The insert_file function returns the value NIL.


--*-- insert_tab Function

           The insert_tab  function inserts whitespace from the current cursor
           position to the next tab stop.

           Format:  (insert_tab [n])

           Argument:  The argument n,  if  specified,  must  have  an  integer
           value.

           Action:  If n is not specified, let n equal 1.

           If the value of n is 0, no action is taken.

           If n is positive, EMACS repeats the following step n times:  insert
           whitespace at the current cursor position to move the cursor to the
           next tab stop position.

           If n is negative, EMACS performs

                (type_tab n)

           which moves the cursor back (-n) tab stops.

           The insert_tab function returns the value NIL.


--*-- insert_version Function

           The insert_version  function  inserts  the  current  EMACS  version
           number into the text buffer at the current cursor position.

           Format:  (insert_version)

           Arguments:  None.

           Action:  EMACS inserts the current version  number  into  the  text
           buffer at the current cursor position.

           The format  of  the  inserted  characters  is  illustrated  by  the
           following:

                EMACS version 20.0.4e

           The insert_version function returns the value NIL.


--*-- integer Data Type

           A variable with the integer data type can  have  only  integers  as
           values.


--*-- integer_to_string Function

           The integer_to_string  function  converts  an  integer  value  to a
           string value.

           Format:  (integer_to_string n [k])

           Arguments:  The argument n, and the argument k if  specified,  must
           be integer values.

           Action:  The integer_to_string function returns a string value.

           EMACS forms a new string s as follows:

               o  EMACS converts the integer n to a string  representation  in
                  the decimal  number  system, with a - in front, if negative.
                  Let s equal this string.

               o  If the argument k is specified, and  if  the  string  s  has
                  fewer   characters  than  the  value  of  k,  EMACS  inserts
                  additional blanks in the front of the string s, so that  the
                  length of  the  resulting string is equal to the value of k.

               o  If the argument k is specified, and if the string s has more
                  characters than the value of k, EMACS replaces the string  s
                  with a new string containing k *'s.

           EMACS returns the string s.


--*-- intern Function

           The intern  function converts a string argument to an atom with the
           same name.  This is the inverse of the get_pname function.

           Format:  (intern s)

           Argument:  The argument s must be a string or character value.

           Action:  The intern function returns an atom value.

           EMACS returns an atom whose name is given by the characters in  the
           string s, creating such an atom if necessary.


--*-- kill_line Command and Function

           The kill_line  command  or  function  deletes text from the current
           cursor position to the end of the current line.

           Command Format:  [{ESC}n] {ESC} X kill_line
                            or
                            [{ESC}n] {CTRL-K}

           Function Format:  (kill_line [n])

           Argument:  The argument n, if specified, must be an integer  value.

           Action:  If n is not specified, let n equal 1.

           If n equals 0, no action is taken.

           If n  is greater than 0, EMACS deletes text to the end of the line,
           and at end of line  deletes  the  newline  character.   Then  EMACS
           deletes (n-1) additional lines.

           If n  is  negative, EMACS deletes n lines above the cursor line and
           from the cursor to the beginning of the current line.

           The kill_line function returns the value NIL.

           Note:  The killed text is placed  on  the  kill  ring  and  can  be
           recalled via yank.


--*-- kill_region Command and Function

           The kill_region  command  or  function deletes all text between the
           mark and the current cursor position, placing it on the kill  ring.

           Command Format:  {ESC} X kill_region
                            or
                            {CTRL-W}

           Function Format:  (kill_region)

           Argument:  A numeric argument, if specified, is ignored.

           Action:  EMACS deletes all text in the current region, that is, all
           text between the mark and the current cursor position.

           The kill_region function returns the value NIL.

           Note:  The  killed  text  is  placed  on  the  kill ring and can be
           recalled via yank_region.


--*-- kill_rest_of_buffer Command and Function

           The kill_rest_of_buffer command or function deletes all  text  from
           the current cursor position to the end of the buffer.

           Command Format:  {ESC} X kill_rest_of_buffer
                            or
                            {ESC} {CTRL-D}

           Function Format:  (kill_rest_of_buffer)

           Arguments:  None.

           Action:  EMACS deletes all text from the current cursor position to
           the end of the current text buffer.

           The kill_rest_of_buffer function returns the value NIL.

           Note:  The  killed  text  is  placed  on  the  kill ring and can be
           recalled via yank.


--*-- lambda Special Form

           This is the same as LISP lambda.  It is  a  special  function  that
           builds a function object from an argument list and program body.

                (lambda (argument_list) body_1 body_2 ...)

           Note:  The  syntax for lambda is the same as for defun, except that
           lambda defines a function that is unnamed.  Defun creates  a  named
           function with  a  global scope.  You use lambda in let lists or for
           fsets, to bind them to a function or a handler.


--*-- last_line_p Function

           The last_line_p function tests whether the current line is the last
           line in the buffer.

           Format:  (last_line_p)

           Arguments:  None.

           Action:  The last_line_p function returns  a  Boolean  value.   The
           value is  true  if  the  line at the current cursor position is the
           last line in the buffer;  otherwise, it returns false.


--*-- lastlinep Function

           The lastlinep  function  is  an  abbreviation  of  the  last_line_p
           function.


--*-- ld Command and Function

           The ld  command or function, which is permitted in SUI only, does a
           PRIMOS LD command.

           Command Format:  {ESC} X ld

           Function Format:  (ld)

           Argument:  A numeric argument, if specified, is ignored.

           Action:  EMACS executes a PRIMOS LD command at the  current  attach
           point.  This command is available only in SUI.


--*-- leave_one_white Command and Function

           The   leave_one_white  command  or  function  deletes   all   extra
           whitespace characters around point.

           Command Format:  {ESC} X leave_one_white
                            or
                            {ESC} {SPACE}

           Function Format:  (leave_one_white)

           Argument:  A numeric argument, if specified, is ignored.

           Action:  EMACS deletes all whitespace around  the  cursor  position
           and inserts a single blank.

           The leave_one_white function returns the value NIL.


--*-- let Special Form

           The let  special  form  is  the same as LISP let.  It locally binds
           variables to values, and, using those bindings, executes a body  of
           expressions.  The  first  thing  in  the  special form is a list of
           lists.  Each of the sublists consists of a variable and a value  to
           bind to it, as in:

                (let ((variable1 value1)
                      (variable2 value2)
                         ...
                                        )
                         body)

           The  values  are  evaluated  and  are  bound  to  their  respective
           variables, and then the expressions of the body are executed in the
           order specified.  The variables may assume values of any type,  not
           just those  of  the  values  bound  to  them.  When the let body is
           finished or otherwise executed, the variable bindings  are  popped.

           Note:  The  difference  between  let  and  set  is that let defines
           variables with local scope and set defines  variables  with  global
           scope.

           Example:  The form

                (let ((x 5))(print x))

           prints the value 5.


--*-- line_is_blank Function

           The line_is_blank function tests whether the current line is blank.

           Format:  (line_is_blank)

           Arguments:  None.

           Action:  The  line_is_blank  function returns a Boolean value.  The
           value is  true  if  the  current  line  contains  only   whitespace
           characters;  otherwise, it is false.


--*-- line_number Function

           The line_number  function  returns  the  line number at a specified
           cursor position.

           Format:  (line_number cur)

           Argument:  The argument cur must have a cursor value.

           Action:  The line_number function returns an  integer  value.   The
           value returned  equals  the  line  number  of the line to which the
           cursor value cur points.

           Note:  This function is the same as

                (cursor_info cur line_num)


--*-- lines_in_file Function

           The lines_in_file function returns the number of lines in  a  file.

           Format:  (lines_in_file)


           Arguments:  None.

           Action:  The  lines_in_file function returns an integer value equal
           to the number of lines in the current buffer.


--*-- LISP_comment Command and Function

           The LISP_comment command or function moves the cursor to  the  LISP
           comment column and places a semicolon (;)  in that position.

           Command Format:  {ESC} X LISP_comment
                            or
                            {ESC};

           Function Format:  (LISP_comment)

           Argument:  A numeric argument, if specified, is ignored.

           Action:  EMACS  inserts  blanks  into  your text buffer so that the
           cursor position is moved to the LISP comment column, usually column
           40.  EMACS inserts a semicolon (;)  at that point.

           The LISP_comment function returns the value NIL.

           Note:  If you wish to change the default LISP comment  column,  set
           the value  of  the  internal  variable  LISP_comment_column  to the
           desired new value.


--*-- LISP_off Command and Function

            The LISP_off command or function turns off LISP mode.

            Command Format:  {ESC} X LISP_off

            Function Format:  (LISP_off)

            Argument:  A numeric argument, if specified, is ignored.

            Action:  EMACS turns off LISP mode in the current buffer.


--*-- LISP_on Command and Function

           The LISP_on command or function turns on LISP mode.

           Command Format:  {ESC} X LISP_on

           Function Format:  (LISP_on)

           Argument:  A numeric argument, if specified, is ignored.

           Action:  EMACS turns on LISP mode in the current buffer.   In  this
           mode, EMACS  assumes  that  your buffer contains a PEEL program and
           provides additional syntax checking capabilities.


--*-- list Function

           The list function returns a list of its arguments.

           Format:  (list v1 [v2 ...  v8])

           Arguments:  There must be at least one argument and  no  more  than
           eight arguments.  The arguments may have any data type.

           Action:  The  list  function returns a value with a list data type.
           The value returned is a list of the arguments.

           Example:  (list 'a 'b 'c 'd) evaluates to (a b c d)


--*-- list_buffers Command

           The list_buffers command lists all user-created text buffers.

           Command Format:  {ESC} X list_buffers
                            or
                            {CTRL-X} {CTRL-B}

           Argument:  A numeric argument, if specified, is ignored.

           Action:  EMACS overwrites the text screen with a list of all active
           external (that is, user-created) buffers.  To restore  the  screen,
           you may use {CTRL-G}.

           Note:  This command will not show empty buffers or buffers in which
           (buffer_info dont_show) is true.


--*-- list_dir Function

           The list_dir function lists directory information.

           Format:  (list_dir p [opt1 ...  opt7])

           Arguments:  The  argument  p must be a string value.  The arguments
           opt1 through opt7, if specified, must be  among  the  atoms  listed
           below.

           Action:  EMACS  lists  directory  information  for  the  wildcarded
           pathname specified by the argument p.  The following options may be
           specified:

               Option                               Effect

               files                 A list of filenames is returned.

               directories           A list of directories is returned.

               segdirs               A list  of  segment  directories   is
                                     returned.

               entry_names           Only the entry name portion  of  each
                                     pathname is retained.

               insert_names          The directory information is inserted
                                     into the current text buffer  at  the
                                     current position, one entry per line.

               sorted                Names are sorted alphabetically.

               no_error_messages     Error messages are suppressed.

           The list_dir  function  returns  a  list  of  all  the  strings  of
           directory entries.


--*-- load_compiled Command and Function

           The load_compiled command or function loads a fasload file that was
           saved by means of the dump_file command.

           Command Format:  {ESC} X load_compiled

           Function Format:  (load_compiled [s])

           Arguments:  A numeric argument, if specified, is ignored.

           The argument  s, if specified, must be a string or character value.

           Action:  If the argument s is not specified, EMACS prompts  you  in
           the minibuffer  with "Fasdump file name:".  The characters that you
           type are assigned to the string s.

           EMACS forms a file name by  appending  the  suffix  .EFASL  to  the
           string specified  by  the variable s.  EMACS loads and executes the
           PEEL program that was saved in that file, usually with  a  previous
           dump_file command.


--*-- load_lib Command and Function

           The load_lib command or function loads a fasload format file.

           Command Format:  {ESC} X load_lib

           Function Format:  (load_lib s)

           Arguments:  A numeric argument, if specified, is ignored.

           The argument s to the load_lib function must be a string.

           Action:  EMACS  opens  for  input  a file whose name is obtained by
           adding the suffix .EFASL to the string s.  EMACS loads and executes
           that file as a fasload file.  EMACS  prints  a  message  indicating
           whether the load was successful.

           The load_lib function returns the value NIL.


--*-- load_package Command and Function

           The load_package command or function loads a package.

           Command Format:  {ESC} X load_package

           Function Format:  (load_package [s])

           Argument:  The  argument  s,  if  specified,  must  be  a string or
           character value.

           Action:  If the string s is not specified, EMACS prompts you for  a
           pathname and assigns the string you type to the variable s.

           EMACS opens  the  pathname  specified  by  the string s, loads that
           package, and then executes it.

           The load_package function returns the value NIL.


--*-- load_pl_source Command and Function

           The load_pl_source command or function loads and  executes  a  PEEL
           source file.

           Command Format:  {ESC} X load_pl_source

           Function Format:  (load_pl_source [s])

           Argument:  The  argument  s,  if  specified,  must  be  a string or
           character value.

           Action:  If the argument s is not specified, EMACS prompts you  for
           a file  name  and assigns the string you specify to the variable s.

           EMACS opens the file specified by the string  s  and  executes  the
           text in that file as a PEEL source program.

           The load_pl_source function returns the value NIL.


--*-- local_display_generator Function

           The local_display_generator function displays a line on your screen
           in "printout" mode.

           Format:  (local_display_generator s [b])

           Arguments:  The  argument  s  must  be a string or character value.
           The argument b, if specified, must be a Boolean value.

           Action:  EMACS displays the string s on your screen  in  "printout"
           mode.

           If the  argument  b  is  true  or  unspecified,  the output line is
           terminated at that point.  If the argument b  is  false,  the  next
           call to  local_display_generator will append its data to the end of
           the current line.

           Note:  The major  difference  between  the  local_display_generator
           function and  the  print  function  is that local_display_generator
           does not put quotation marks around displayed string arguments.


--*-- looked_at Function

           The looked_at function tests whether the text preceding the current
           cursor position is the same as a string argument.

           Format:  (looked_at s)

           Argument:  The argument s must be a string or character value.

           Action:  The looked_at function returns a Boolean  value.   If  the
           characters in the text buffer preceding the current cursor position
           are the  same  as  the  string  s,  then  looked_at  returns  true;
           otherwise, it returns false.

           Example:  The function

                (if (looked_at "house") ...)

           returns true  if  the  characters  preceding  the  current   cursor
           position are the string "house".


--*-- looking_at Function

           The looking_at function tests whether the characters in your buffer
           beginning at  the  current  cursor  position  equal  a given string
           value.

           Format:  (looking_at s)

           Argument:  The argument s must have a string or character value.

           Action:  The looking_at function returns a Boolean value.   If  the
           characters in your text buffer, beginning with the character at the
           current cursor  position  and continuing to the right, are equal to
           the characters of the argument s, then the value returned is  true;
           otherwise, the value is false.


--*-- looking_at_char Function

           The looking_at_char  function  tests  the  character at the current
           cursor position.

           Format:  (looking_at_char c)

           Argument:  The argument c must be a character value.

           Action:  The looking_at_char function returns a Boolean value.  The
           value is true if the character at the current  cursor  position  is
           the same as the argument c;  otherwise the value is false.

           Note:  This is exactly the same as

                (looking_at c)

           where c is character type.


--*-- lowercase_region Command and Function

           The lowercase_region  command or function changes all the uppercase
           letters in a region to lowercase.

           Command Format:  {ESC} X lowercase_region
                            or
                            {CTRL-X} {CTRL-L}

           Function Format:  (lowercase_region)

           Argument:  A numeric argument, if specified, is ignored.

           Action:  EMACS changes all the  uppercase  letters  in  the  region
           between mark and point to lowercase.

           Caution:  This  command  must  be used with extreme care.  If it is
           mistakenly applied to the wrong region of  text  in  uppercase  and
           lowercase, its effect must be undone manually.

           The lowercase_region function returns the value NIL.


--*-- lowercase_word Command and Function

           The lowercase_word  command  or  function changes the text from the
           current cursor position to the end of the word into lowercase.

           Command Format:  [{ESC}n] {ESC} X lowercase_word
                            or
                            {ESC} L

           Function Format:  (lowercase_word [n])

           Argument:  The argument n, if specified, must be an integer  value.

           Action:  If the argument n is not specified, let n equal 1.

           If the  value  of  n  is  positive, EMACS converts to lowercase all
           uppercase letters in the region from the beginning of  the  current
           word (or  the next word, if the cursor is on whitespace) to the end
           of the nth word, moving forward.  The cursor moves to  the  end  of
           that region.

           If the  value  of  n  is  negative,  EMACS changes to lowercase all
           uppercase letters in the region ending at the end  of  the  current
           word (or  the  previous word, if the cursor is on whitespace or the
           beginning of a word) and beginning at the beginning of  the  (-n)th
           word preceding  the  current  cursor  position.  The cursor is left
           unchanged.

           The lowercase_word function returns the value NIL.


--*-- major_window_count Function

           The major_window_count function returns the number of major windows
           presently on the screen.

           Format:  (major_window_count)

           Arguments:  None.

           Action:  The major_window_count function returns an integer  value.
           The integer  value equals the number of major windows.  You may use
           this number with do_n_times and select_any_window to  loop  through
           the windows.


--*-- make_array Function

           The make_array function creates an array and returns it.

           Format:  (make_array d n)

           Arguments:  The  argument  d  must  be a quoted atom representing a
           legal PEEL data type.  The argument n must be a  positive  integer.

           Action:  The  make_array  function  returns  an  array  value.  The
           make_array function creates an array of n elements, each  of  which
           has the data type d, and returns the resulting array.

           Example:  The statement

                (setq boxes (make_array 'integer 5))

           creates an  array  called  boxes.  This array contains five integer
           elements, numbered 0 through 4.


--*-- make_cursor Function

           The make_cursor function returns a cursor value generated from  the
           arguments.

           Format:  (make_cursor s ln cp [st])

           Arguments:  The  argument  s must be a string value.  The arguments
           ln and cp must be integer values.  The argument st,  if  specified,
           must be a Boolean value.

           Action:  The make_cursor function returns a cursor value.

           If the argument st is not specified, let st equal true.

           EMACS forms a cursor value with buffer name specified by the string
           s, line  number  specified  by  the  integer  value  ln,  character
           position specified  by  the  integer  value  cp,  and  sticky  flag
           specified by the value st.  EMACS returns that cursor value.

           Note:  The sticky flag currently has no effect.


--*-- mark Command and Function

           The mark  command  or function either sets the mark or pops a mark.

           Command Format:  [{ESC}n] {ESC} X mark
                            or
                            [{ESC}n] {CTRL-@}

           Function Format:  (mark [n])

           Argument:  The argument n, if specified, must be an integer  value.

           Action:  If the argument n is not specified, EMACS sets the mark to
           the current cursor position.

           If the  argument  n  is  specified,  EMACS  performs  the  pop mark
           function.  This function pops the last mark  saved  with  the  push
           mark function, and moves the cursor to that position.

           The mark function returns the value NIL.


--*-- mark_bottom Command and Function

           The mark_bottom  command or function places a mark at the bottom of
           the buffer, leaving the cursor unchanged.

           Command Format:  {ESC} X mark_bottom
                            or
                            {CTRL-X} {CTRL-Z} >

           Function Format:  (mark_bottom)

           Argument:  A numeric argument, if specified, is ignored.

           Action:  EMACS places a mark at the  bottom  of  the  current  text
           buffer, leaving the current cursor unchanged.

           The mark_bottom function returns the value NIL.


--*-- mark_end_of_word Command and Function

           The mark_end_of_word  command  or function places a mark at the end
           of the word, leaving the cursor unchanged.

           Command Format:  {ESC} X mark_end_of_word
                            or
                            {ESC} @

           Function Format:  (mark_end_of_word)

           Argument:  A numeric argument, if specified, is ignored.

           Action:  EMACS places a mark at the end of the  word,  leaving  the
           current cursor unchanged.

           The mark_end_of_word function returns the value NIL.


--*-- mark_para Command and Function

           The mark_para  command  or  function  puts  a  mark at the end of a
           paragraph and moves the cursor to the beginning of  the  paragraph.

           Command Format:  [{ESC}n] mark_para
                            or
                            [{ESC}n] {ESC} H

           Function Format:  (mark_para [n])

           Argument:  The  argument n, if specified, must be an integer value.

           Action:  If n is not specified, let n equal 1.

           EMACS puts a mark at the end of the  nth  paragraph  following  the
           current cursor  position,  and  then  moves  the cursor back to the
           beginning of the current paragraph.

           The mark_para function returns the value NIL.


--*-- mark_top Command and Function

           The mark_top command or function places a mark at the  top  of  the
           buffer, leaving the cursor unchanged.

           Command Format:  {ESC} X mark_top
                            or
                            {CTRL-X} {CTRL-Z} <

           Function Format:  (mark_top)

           Argument:  A numeric argument, if specified, is ignored.

           Action:  EMACS places a mark at the top of the current text buffer,
           leaving the current cursor unchanged.

           The mark_top function returns the value NIL.


--*-- mark_whole Command and Function

           The mark_whole  command or function places a mark at the end of the
           buffer and moves the current cursor to the beginning of the buffer.

           Command Format:  {ESC} X mark_whole
                            or
                            {CTRL-X} H

           Function Format:  (mark_whole)

           Argument:  A numeric argument, if specified, is ignored.

           Action:  EMACS places a mark at the end of the current text buffer,
           and moves the current cursor to the beginning of the  text  buffer.

           The mark_whole function returns the value NIL.


--*-- member Function

           The member function tests whether a specified item is in a list.

           Format:  (member i lst)

           Arguments:  The  argument  i  may have any data type.  The argument
           lst must be a list.

           Action:  The member function returns a Boolean  value.   The  value
           returned is true if the item i appears in the list lst;  otherwise,
           the value is false.

           Note:  The  test  for whether the item i appears in the list lst is
           made using the = function, not the eq function.


--*-- merge_lines Command and Function

           The merge_lines command or function merges two lines together.

           Command Format:  [{ESC}n] {ESC} X merge_lines
                            or
                            [{ESC}n] {ESC} ^

           Function Format:  (merge_lines [n])

           Argument:  The argument n, if specified, must be an integer  value.

           Action:  If the argument n is not specified, let n equal 1.

           If the  value  of n is positive, EMACS repeats the following step n
           times:  merge the current line with the next line  in  the  current
           text buffer  by  replacing  the  newline characters separating them
           with a space.

           If the value of n is negative, EMACS  repeats  the  following  step
           (-n) times:   merge  the  preceding line of the current text buffer
           with the  current  line  by  replacing   the   newline   characters
           separating them with a space.

           The merge_lines function returns the value NIL.


--*-- minibuf_response Function

           The minibuf_response  function  is an alternate name for the prompt
           function.


--*-- minibuffer_print Special Form

           The minibuffer_print special form is  an  alternate  name  for  the
           info_message function.


--*-- minibuffer_response Function

           The minibuffer_response  function  is  an  alternate  name  for the
           prompt function.


--*-- mod_one_window Command and Function

           The mod_one_window  command  or  function  transforms  the  current
           multiwindow display  into  a one-window display, saving information
           about the other window.

           Command Format:  {ESC} X mod_one_window
                            or
                            {CTRL-X} 1

           Function Format:  (mod_one_window)

           Argument:  A numeric argument, if specified, is ignored.

           Action:  EMACS expands the current window on your  display  to  the
           full screen,  saving  information  about  the other windows so that
           they can be restored by a future mod_split_window command.

           The mod_one_window function returns the value NIL.


--*-- mod_split_window Command and Function

           The mod_split_window command or function restores you screen to the
           two-window display in  effect  prior  to  the  last  mod_one_window
           command or function.

           Command Format:  {ESC} X mod_split_window
                            or
                            {CTRL-X} 2

           Function Format:  (mod_split_window)

           Argument:  A numeric argument, if specified, is ignored.

           Action:    EMACS  retrieves  the  information  saved  by  the  last
           mod_one_window command, and restores your screen  to  a  two-window
           display.

           If no  previous  mod_one_window  command  has  been executed, EMACS
           creates a two-window display using, as a default, a buffer name  of
           ALTERNATE for the second window.

           If there  were  more  than two windows on the screen at the time of
           the last mod_one_window display, EMACS chooses one of  the  windows
           that   was  removed  and  uses  it  as  a  second  window.   It  is
           unpredictable which window is chosen.

           The mod_split_window function returns the value NIL.


--*-- mod_write_file Command and File

           The mod_write_file command and file writes the current buffer to  a
           specified output  file,  prompting  you  in  case  the file already
           exists.

           Command Format:  {ESC} X mod_write_file
                            or
                            {CTRL-X} {CTRL-W}

           Function Format:  (mod_write_file [s])

           Arguments:  A numeric argument, if specified, is ignored.

           The argument s, if specified to the mod_write_file  function,  must
           be a string value.

           Action:  If  the string s is not specified, EMACS prompts you for a
           filename, and assigns the string you typed to the variable s.

           If the variable s is a null string (no characters), let s equal the
           name of the file currently associated with the current buffer.

           If the file with pathname s already exists as a PRIMOS file,  EMACS
           prompts you,  asking  whether you wish to replace the existing disk
           file.  If you respond "n", the command is aborted.

           EMACS saves the current text buffer to the output file specified by
           the pathname s.

           The mod_write_file function returns the value NIL.


--*-- modulo Function

           The modulo  function  computes  the  remainder  obtained  when  one
           integer is divided by another.

           Format:  (modulo n d)

           Arguments:  The arguments n and d must be integer values.

           Action:  The  modulo function returns an integer value, computed as
           follows:

               o  If the value of d is 0, let r equal n.

               o  If the value of d is nonzero,  let  r  equal  the  remainder
                  obtained when  the numerator n is divided by the denominator
                  d.  If the remainder is nonzero, the sign of r always equals
                  the sign of d.

           The modulo function returns the value r.


--*-- more_args_p Function

           The more_args_p function tests to see if more string arguments  are
           pending.

           Format:  (more_args_p)

           Arguments:  None.

           Action:  Whenever  you invoke a command, you can specify the string
           arguments for that command.  These arguments are assigned, in turn,
           to each &args directives and to prompt directives, as well.

           more_args_p indicates whether there  are  any  unclaimed  arguments
           from the  invocation, and can be used to determine if a prompt will
           really occur.


--*-- move_bottom Command and Function

           The move_bottom command or function moves the current cursor to the
           bottom of the buffer.

           Command Format:  {ESC} X move_bottom
                            or
                            {ESC} >

           Function Format:  (move_bottom)

           Argument:  A numeric argument, if specified, is ignored.

           Action:  EMACS moves the  current  cursor  to  the  bottom  of  the
           buffer.

           The move_bottom function returns the value NIL.


--*-- move_top Command and Function

           The move_top  command  or  function moves the current cursor to the
           top of the buffer.

           Command Format:  {ESC} X move_top
                            or
                            {ESC} <

           Function Format:  (move_top)

           Argument:  A numeric argument, if specified, is ignored.

           Action:  EMACS moves the current cursor to the top of  the  buffer.

           The move_top function returns the value NIL.


--*-- multiplier Command

           The multiplier  command  can  be  used  immediately after a numeric
           argument specification to multiply the numeric argument by 4.   The
           command can only be used when bound to a key.  It is normally bound
           as {CTRL-U}.

           Example:  The command

                          {ESC} 22 {CTRL-U} x

           inserts 88 x's into your buffer.


--*-- next_buf Command and Function

           The next_buf command or function cycles to your next external
           buffer.

           Command Format:  {ESC} X next_buf
                            or
                            {ESC} N

           Function Format:  (next_buf)

           Argument:  A numeric argument, if specified, is ignored.

           Action:  This  command  is  used to cycle through all your external
           (user-defined) buffers.  The order of searching is  as  defined  in
           the internal .buffers buffer.

           EMACS searches  for  your  current  buffer  in the .buffers buffer,
           finds the next buffer, and then changes your current buffer to  the
           next buffer.

           The next_buf function returns the value NIL.


--*-- next_buff Command and Function

           The next_buff  command  or  function  is  an alternate name for the
           next_buf command and function.


--*-- next_line Function

           The next_line function moves the cursor to the next line.

           Format:  (next_line [n])

           Arguments:  The argument n, if specified, must be an integer  whose
           value may be positive, 0, or negative.

           Action:  The next_line function returns a Boolean value.

           If n is not specified, let n equal 1.

           If the  value  of  n  is  0, no cursor movement takes place and the
           value true is returned.

           If the value of n is positive, EMACS moves the cursor down n  lines
           and then  to  the  beginning  of the line.  If the end of buffer is
           reached, cursor movement stops and the  value  false  is  returned;
           otherwise, the value true is returned.

           If the  value  of n is negative, EMACS moves the cursor up n lines,
           and then to the beginning of the line.  If the  top  of  buffer  is
           reached, cursor  movement  stops  and  the value false is returned;
           otherwise, the value true is returned.


--*-- next_line_command Command and Function

           The next_line_command command or function moves the cursor  to  the
           next line.

           Command Format:  [{ESC}n] {ESC} X next_line_command
                            or
                            [{ESC}n] {CTRL-N}

           Function Format:  (next_line_command [n])

           Arguments:  If  the  argument n is specified, it must be an integer
           value, which may be positive, 0, or negative.

           Action:  If n is not specified, let n equal 1.

           If n equals 0, no action takes place.

           If the value of n is positive, EMACS moves  the  cursor  vertically
           down n lines, stopping if the bottom of the buffer is reached.

           If the value of n is negative, EMACS moves the cursor vertically up
           n lines, stopping if the top of the buffer is reached.


--*-- next_page Command and Function

           The next_page  command or function moves the window forward a group
           of lines, usually 18.

           Command Format:  [{ESC}n] {ESC} X next_page
                            or
                            [{ESC}n] {CTRL-V}

           Function Format:  (next_page [n])

           Argument:  The argument n, if specified, must be an  integer  whose
           value may be positive, 0, or negative.

           Action:  If n is not specified, let n equal 1.

           If the  value  of n is 0, no action takes place.  If the value of n
           is positive, the window moves forward n pages, stopping if the  end
           of buffer  is  reached.   The  cursor  is left at approximately the
           middle of the window.

           If the value of n is negative,  the  window  moves  back  n  pages,
           stopping if  the beginning of the buffer is reached.  The cursor is
           left at approximately the middle of the window.

           The next_page function returns the value NIL.


--*-- not Function

           The not function returns the logical negation of its argument.

           Format:  (not b)

           Argument:  The argument b must be a logical value.

           Action:  The not function returns a logical value.  If the value of
           the argument  b  is  true,  then  not  returns  the  value   false;
           otherwise, not returns the value true.


--*-- nth Function

           The nth function returns the nth character in a string.

           Format:  (nth s n)

           Arguments:  The  argument  s  must  be a string or character value.
           The argument n must be an integer value.

           Action:  The nth function returns a character  value,  computed  as
           follows:

               o  Let k equal the number of characters in the string s.

               o  If 1<=n<=k, EMACS returns the character from position  n  of
                  string s.

               o  Otherwise, EMACS returns a null string.


--*-- nthcar Function

           The nthcar function returns the nth car of a list.

           Format:  (nthcar lst n)

           Arguments:  The argument lst must be a list value.  The argument  n
           must be an integer value.

           Action:  The  nthcar  function  returns  a  value  whose  data type
           depends upon the arguments.

           The value returned is the nth car of the list  lst.   This  is  the
           item of the list lst in position n.

           If the  list's  length  is shorter than n, the function returns the
           value NIL.


--*-- null Function

           The null function tests whether its argument is a null list.

           Format:  (null v)

           Argument:  The argument v may have any data type.

           Action:  The null function returns a Boolean value.  The  value  is
           true if v is a null list;  otherwise, the value is false.

           Notes:  The  null  list,  (),  is often represented in this book as
           NIL.  Either representation works in a PEEL program, as long as you
           never setq NIL.

           You can use the null function in a loop through the elements  of  a
           list, applying  it  to the cdr of the list to test if there are any
           items remaining.

           This function is equivalent to either

                (= v NIL)

           or

                (eq v NIL)


--*-- numberp Function

           The numberp function tests whether its argument is a number.

           Format:  (numberp v)

           Argument:  The argument v may have any data type.

           Action:  The number p function returns a Boolean value.  The  value
           returned is  true  if  v  has an integer data type;  otherwise, the
           value is false.


--*-- numeric_argument Function

           The numeric_argument function returns the  numeric  argument  to  a
           defcom command.

           Format:  (numeric_argument [n])

           Argument:  The  argument n, if specified, must be an integer value.

           Action:  The numeric_argument function may return either a  numeric
           argument or NIL.

           The numeric_argument  function  is normally used in the PEEL source
           for a defcom command.  When the  defined  command  is  invoked,  if
           there is  a  numeric argument to the invocation of the command, the
           numeric_argument function  returns  the  value  of   that   numeric
           argument.  If the command is invoked with no numeric argument, then
           the argument n serves as a default value:

               o  If an argument n has been  specified,  the  numeric_argument
                  function returns the value of n.

               o  If there is no argument  n,  the  numeric_argument  function
                  returns the value NIL.

           If the  numeric_argument  function  is  used other than in the PEEL
           source for a defcom, it returns the value NIL.

           Example:  The  standard  defcom  produced  by   expand_macro   uses
           numeric_argument, with  a  default  of  1, to control the number of
           times the defined command is executed.

                (defcom simple_example
                  (do_n_times (numeric_argument 1)
                  (print "EMACS is extensible.")
                ))

           Note:  The numeric_argument  function  is  similar  to  the  defcom
           option &na.  For instance, &na (&pass foo &default 2) is equivalent
           to (setq foo (numeric_argument 2)).


--*-- one_window Command and Function

           The   one_window  command  or  function  transforms   the   current
           multiwindow display into a one window display.

           Command Format:  {ESC} X one_window

           Function Format:  (one_window)

           Argument:  A numeric argument, if specified, is ignored.

           Action:  EMACS expands the current window on your  display  to  the
           full screen.

           The one_window function returns the value NIL.

           Note:  You  may  use the mod_one_window command to save information
           about the window being removed, so that it can  be  restored  by  a
           future mod_split_window command.


--*-- open_line Command and Function

           The open_line  command or function inserts a carriage return at the
           current cursor position without moving the cursor.

           Command Format:  [{ESC}n] {ESC} X open_line
                            or
                            [{ESC}n] {CTRL-O}

           Function Format:  (open_line [n]

           Argument:  The argument n, if specified, must be an integer  value.

           Action:  If n is not specified, let n equal 1.

           If n is positive, EMACS repeats the following step n times:  insert
           a carriage  return  into the buffer at the current cursor position,
           and then move  the cursor back over  the  character  just inserted.

           Therefore, this command is equivalent to the cr command followed by
           the back_char command.

           The open_line function returns the value NIL.


--*-- or Function

           The or function is a Boolean operator that has the logical "or"  as
           its arguments.

           Format:  (or b1 b2 [b3 ...  b8])

           Arguments:  The  or  function  takes  at least two arguments and no
           more than eight arguments.  All arguments  must  have  the  Boolean
           data type.

           Action:  The or function returns a Boolean value computed by taking
           the logical  "inclusive  or" of all of its arguments.  That is, the
           or function returns the value  false  if  the  values  of  all  its
           arguments are  false;   otherwise,  it returns the value true.  All
           arguments are evaluated regardless of whether any is  true.   Order
           of evaluation is unspecified.


--*-- other_window Command and Function

           The other_window  command  or  function switches the cursor between
           the current window and the last previously used window.

           Command Format:  {ESC} X other_window
                            or
                            {CTRL-X} O

           Function Format:  (other_window)

           Argument:  A numeric argument, if specified, is ignored.

           Action:  EMACS switches the cursor from the current window  to  the
           last window on the screen that was previously used.

           The other_window function returns the value NIL.


--*-- otherwise Keyword

           The otherwise  keyword  specifies  an action to be taken if none of
           the criteria in a select or a dispatch have been met.  It  must  be
           the last item in these special forms.


--*-- overlay_off Command and Function

           The overlay command or function turns off overlay mode.

           Command Format:  {ESC} X overlay_off

           Function Format:  (overlay_off)

           Argument:  A numeric argument, if specified, is ignored.

           Action:  EMACS  turns  off  overlay  mode,  so  that  when you type
           characters to be inserted into your text buffer, the new characters
           do not overlay existing characters.

           The overlay_off function returns the value NIL.


--*-- overlay_on Command and Function

           The overlay_on command or function turns on overlay mode.

           Command Format:  {ESC} X overlay_on

           Function Format:  (overlay_on)

           Argument:  A numeric argument, if specified, is ignored.

           Action:  EMACS turns on overlay mode.  In this mode, any  character
           that you  type  at  the keyboard overlays the existing character on
           your screen,  rather   than   being   inserted   between   existing
           characters.

           The overlay_on function returns the value NIL.


--*-- overlay_rubout Command and Function

           The overlay_rubout  command  or  function  deletes  a  character in
           overlay mode.

           Command Format:  [{ESC}n] {ESC} X overlay_rubout

           Function Format:  (overlay_rubout [n])

           Argument:  The argument n, if specified, must be an integer  value.

           Action:  If the value of n is not specified, let n equal 1.

           EMACS deletes  the  character to the left of the current cursor and
           inserts a space to replace it.  The cursor is  left  at  the  space
           that was inserted.

           The overlay_rubout function returns the value NIL.


--*-- overlayer Command and Function

           The overlayer command or function performs the actual overlaying in
           overlay mode.

           Command Format:  {ESC} X overlayer

           Function Format:  (overlayer [c] [n])

           Arguments:  The  argument  c,  if  specified,  must  be a character
           value.  The argument n, if specified, must be an integer value.

           Action:  The  last  character  of  a  key  sequence  bound  to  the
           overlayer command  (or,  in the case of the overlayer function, the
           character c), replaces the current character on the screen.

           Example:  See the self_insert function.


--*-- pending_reenter Function

           The pending_reenter function is the same as the  suppress_redisplay
           function.


--*-- pl Command and Function

           The pl  command  or  function compiles and executes the contents of
           the current buffer.

           Command Format:  {ESC} X pl

           Function Format:  (pl)

           Argument:  A numeric argument, if specified, is ignored.

           Action:  EMACS compiles and executes the contents  of  the  current
           text buffer.

           The pl function returns the value NIL.

           Note:  The buffer cannot exceed 32767 characters.


--*-- pl_minibuffer Command

           The pl_minibuffer  command  lets  you  type  an expression into the
           minibuffer that EMACS executes as a PEEL statement.

           Format:  {ESC} X pl_minibuffer
                    or
                    {ESC} {ESC}

           Argument:  A numeric argument, if specified, is ignored.

           Action:  EMACS prompts you in the minibuffer for a line  containing
           a PEEL statement.  EMACS then executes the statement that you type.


--*-- point_cursor_to_string Function

           The point_cursor_to_string  function  returns  the text between the
           argument cursor and the current cursor.

           Format:  (point_cursor_to_string cur)

           Argument:  The argument cur must be a  cursor  value  in  the  same
           buffer as the current cursor.

           Action:  The point_cursor_to_string function returns a string value
           consisting of  all  the  text  in  the  current  buffer between the
           current cursor position and the argument cur.


--*-- popmark Command and Function

           The popmark command or function pops a mark off the top of the mark
           stack.

           Command Format:  {ESC} X popmark

           Function Format:  (popmark)

           Argument:  A numeric argument, if specified, is ignored.

           Action:  EMACS pops the mark off the top of the mark stack and sets
           the mark to that position.

           The popmark function returns the value NIL.

           Note:  Use the pushmark command or function to store a mark on  the
           mark stack.


--*-- prepend_to_buf Command and Function

           The prepend_to_buf  command or function prepends the current region
           to a buffer.  The word "prepend" means that the insertion  is  made
           at the beginning of the buffer.

           Command Format:  [{ESC}n] {ESC} X prepend_to_buf
                            or
                            [{ESC}n] {CTRL-X} P

           Function Format:  (prepend_to_buf [n [s]])

           Argument:  The numeric argument n, if specified, must be an integer
           value.

           The argument s, if specified, must be a string value.

           Action:  If  the argument s is unspecified, EMACS prompts you for a
           buffer name and assigns the resulting string to the variable s.

           EMACS prepends the current region  to  the  buffer  whose  name  is
           specified by the string s.  This means that the text in the current
           region is inserted at the beginning of that buffer.

           If n  is  not specified, the text in the current region is deleted,
           meaning that the prepend operation is, in effect, a move.  If n  is
           specified, the text is copied and the marked region is not deleted.


--*-- prepend_to_file Command and Function

           The prepend_to_file command or function prepends the current region
           to a  file.   The word "prepend" means that the text is inserted at
           the beginning of the file.

           Command Format:  [{ESC}n] {ESC} S prepend_to_file
                            or
                            [{ESC}n] {CTRL-X} {CTRL-Z} P

           Function Format:  (prepend_to_file [n [s]])

           Argument:  The argument n, if specified, must be an integer  value.

           Action:  If  the string s is not specified, EMACS prompts you for a
           filename.  The resulting string is assigned to the variable s.

           EMACS prepends the current region to that file.   This  means  that
           the text  in the current marked region is inserted at the beginning
           of that file.

           If n is not specified, the text in the current region  is  deleted,
           meaning that  the prepend operation is, in effect, a move.  If n is
           specified, the text is copied and the marked region is not deleted.


--*-- prev_buf Command and Function

           The prev_buf  command  or  function  cycles  you  to  the  previous
           external buffer.

           Command Format:  {ESC} X prev_buf
                            or
                            {ESC} P

           Function Format:  (prev_buf)

           Argument:  A numeric argument, if specified, is ignored.

           Action:  This  command  is  used to cycle through all your external
           (user-defined) buffers.  The order of searching is in reverse order
           from the order defined in the internal .buffers buffer.

           EMACS searches for your current  buffer  in  the  .buffers  buffer,
           finds the preceding buffer in the .buffers buffer, and then changes
           the current buffer to that buffer.

           The prev_buf function returns the value NIL.


--*-- prev_line Function

           The prev_line function moves the cursor to the previous line.

           Format:  (prev_line [n])

           Argument:  The  argument  n, if specified, must be an integer whose
           value that may be positive, 0, or negative.

           Action:  The prev_line function returns a Boolean value.

           If n is not specified, let n equal 1.

           If the value of n is 0, no cursor  movement  takes  place  and  the
           value true is returned.

           If the  value  of n is positive, EMACS moves the cursor up n lines,
           and then to the beginning of the line.  If the top of the buffer is
           reached, cursor movement stops and the  value  false  is  returned;
           otherwise, the value true is returned.

           If the  value  of  n  is negative, EMACS moves the cursor down (-n)
           lines, and then to the beginning of the line.  If the  end  of  the
           buffer is  reached,  cursor  movement  stops and the value false is
           returned;  otherwise, the value true is returned.


--*-- prev_line_command Command and Function

           The prev_line_command command or function moves the cursor  to  the
           previous line.

           Command Format:  [{ESC}n] {ESC} X prev_line_command
                            or
                            [{ESC}n] {CTRL-Z}

           Function Format:  (prev_line_command [n])

           Argument:  If  the  argument  n is specified, it must be an integer
           whose value may be positive, 0, or negative.

           Action:  If n is not specified, let n equal 1.

           If n equals 0, no action takes place.

           If the value of n is positive, EMACS moves the cursor vertically up
           n lines, stopping if the beginning of the buffer is reached.

           If the value of n is negative, EMACS moves  the  cursor  vertically
           down (-n) lines, stopping if the end of the buffer is reached.

           Note:  EMACS maintains the horizontal character position as well as
           possible.


--*-- primos_command Command and Function

           The primos_command  command  or  function executes a PRIMOS command
           without leaving EMACS.

           Command Format:  {ESC} X primos_command
                            or
                            {CTRL-X} {CTRL-E}

           Function Format:  (primos_command [s])

           Arguments:  A numeric argument, if specified, is ignored.

           The argument s, if specified, must be a string value.

           Action:  If the argument s is not specified, EMACS prompts you with
           "primos command:".   The  string  that  you  type  in  response  is
           assigned to the variable s.

           EMACS proceeds as follows:

               o  If the first character in the  string  s  is  not  !,  EMACS
                  executes

                       (primos_external s)

               o  If the first character of the string s is !, but the  second
                  character of the string is not !, EMACS executes

                       (primos_internal_como s2)

                  where s2  is  a  string  equal  to s, but with the leading !
                  removed.

               o  If the first two characters of the string s  are  !!,  EMACS
                  runs

                       (primos_internal_screen s2)

                  where s2  is  a  string  equal  to s, but with the first two
                  characters removed.

           The primos_command function returns the value NIL.

           Note:  At Revision  19.4  of  PRIMOS,  any  PRIMOS  command  except
           "EMACS"   may  be   executed   via     primos_internal_como      or
           primos_internal_screen.  External  commands  no  longer   overwrite
           EMACS.


--*-- primos_external Command and Function

           The primos_external  command  or function executes a PRIMOS command
           by means of a separate phantom job.

           Command Format:  {ESC} X primos_external

           Function Format:  (primos_external [s])

           Arguments:  A numeric argument, if specified, is ignored.

           The argument s, if specified, must be a string value.

           Action:  If the argument s is not specified, EMACS prompts you with
           "external command:".  The characters that you type in response  are
           assigned to the string variable s.

           EMACS runs  a  separate  phantom  job to execute the PRIMOS command
           specified by the string s.  It waits for the  command  to  complete
           and then displays the results in the file_output buffer.

           After the  phantom  job has terminated, EMACS creates or overwrites
           the text buffer named file_output, loading into it the text of  the
           listing file  created by the phantom job.  You may continue editing
           your original file by switching back to the buffer into which  that
           file was loaded.

           The primos_external function returns the value NIL.


--*-- primos_internal_como Command and Function

           The primos_internal_como  command or function runs a PRIMOS command
           with como output.

           Command Format:  {ESC} X primos_internal_como

           Function Format:  (primos_internal_como [s])

           Arguments:  A numeric argument, if specified, is ignored.

           The argument s, if specified, must be a string value.

           Action:  If the argument s is not specified, EMACS prompts you with
           "internal command:".  The characters that you type in response  are
           assigned to the string s.

           The characters  of  the  string  s  must  form a PRIMOS command not
           requiring any interactive keyboard input from the user.  EMACS runs
           the command using CP$.

           After execution of the  command  is  completed,  EMACS  creates  or
           overwrites the  text  buffer named file_output, loading into it the
           text of the command output.


--*-- primos_internal_quiet Command and Function

           The primos_internal_quiet command or  function  executes  a  PRIMOS
           command, overwriting your screen with any terminal output.

           Command Format:  {ESC} X primos_internal_quiet

           Function Format:  (primos_internal_quiet [s])

           Arguments:  A numeric argument, if specified, is ignored.

           The argument s, if specified, must be a string value.

           Action:  If the argument s is not specified, EMACS prompts you with
           "quiet command:".  The characters you type in response are assigned
           to the string s.

           The characters  of  the  string  s  may  contain any PRIMOS command
           except "EMACS".  EMACS runs the command using CP$.

           After execution of the command is completed, EMACS overwrites  your
           screen display  with the terminal output from the command.  You may
           clear your screen by using {CTRL-L}.

           The primos_internal_quiet function returns the value NIL.

           Note:  This command is useful for executing  PRIMOS  commands  that
           normally do not produce any terminal output, such as ATTACH.


--*-- primos_internal_screen Command and Function

           The primos_internal_screen  command  or  function executes a PRIMOS
           command.

           Command Format:  {ESC} X primos_internal_screen

           Function Format:  (primos_internal_screen [s])

           Arguments:  A numeric argument, if specified, is ignored.

           The argument  s,  if  specified   to   the   primos_internal_screen
           function, must be a string value.

           Action:    If  the  argument  s  is  not   specified    to      the
           primos_internal_screen function, or if  the  primos_internal_screen
           command is  used,  EMACS prompts you with "internal command:".  The
           characters that you type in response are  assigned  to  the  string
           variable s.

           The characters  of  the  string  s may be any PRIMOS command except
           "EMACS".  EMACS executes the command using CP$.

           After execution of the command  is  completed,  EMACS  clears  your
           display screen and displays the terminal output from the command on
           your screen.  You may restore your screen by typing {CTRL-G}.

           The primos_internal_screen function returns the value NIL.

           Note:  This  is  used  for  interactive  commands.  The terminal is
           reset, the command is  executed,  and  when  command  execution  is
           completed, typing any character restores your EMACS screen.


--*-- primos_recycle Command

           The primos_recycle  command runs the PRIMOS rescheduler.  It should
           not normally be used by PEEL programmers.


--*-- primos_smsg1 Function

           The primos_smsg1 function sends a PRIMOS  message  to  a  specified
           user.

           Format:  (primos_smsg1 a s)

           Arguments:  The  argument  a  must  be  either a string value or an
           integer value.  The argument s must be a string value.

           Action:  EMACS transmits a PRIMOS message to a specified user.  The
           argument a  specifies  the  addressee  either  as  a  string  value
           representing the  name  or  as  an  integer  value representing the
           process number.  (None of the usual PRIMOS MESSAGE command options,
           such as -ON or -NOW, are supported.)

           The argument s is the message to be sent.

           If the message was successfully sent, primos_smsg1 function returns
           the value NIL.


--*-- prin1 Function

           The prin1 function prints a value or  inserts  a  value  into  your
           text.  The  prin1 function is similar to the print function, except
           that no new line is displayed or inserted.

           Format:  (prin1 v [cur])

           Arguments:  The argument v may have any data type.

           The argument cur, if specified, must be a cursor value.

           Action:  The prin1 function returns a value whose data type  equals
           the data type of the argument v.

           If the  argument cur is specified, EMACS sets the current cursor to
           cur, and then inserts a printed representation of the value of  the
           argument v into your text buffer at that cursor position.

           If the  argument  cur is not specified, EMACS displays the value of
           the argument v on  your  screen.   To  restore  your  screen,  type
           {CTRL-G}.

           The prin1 function returns the value of v.

           Note:  The  printed  line  is not terminated.  Thus, the results of
           consecutive prin1 invocations will be  concatentated  on  the  same
           line.


--*-- print Function

           The print  function  displays or inserts a specified value followed
           by a newline.

           Format:  (print v [cur])

           Arguments:  The argument v may have any data type.

           The argument cur, if specified, must be a cursor value.

           Action:  The print function returns a value whose data type  equals
           the data type of the argument v.

           If the  argument cur is specified, EMACS changes the current cursor
           to cur, and then inserts a printed representation the value of  the
           argument v,  followed by a newline character, into your text buffer
           at that position.

           If the argument cur is not specified, EMACS displays the  value  of
           the argument  v,  followed  by a newline character, on your screen.
           To restore your screen, type {CTRL-G}.

           The format of the value displayed depends upon the data type of the
           variable v.  If v is an atom, the name of the atom is printed;   if
           v is an integer, a number is printed;  if v is a string, the string
           is printed  in  quotation marks, with appropriate escape sequences;
           if v is a character, the character (preceded  by  a  backslash)  is
           printed.    For  all  other  data  types,  a  bracketed  descriptor
           describing the item is displayed.

           The print function returns the value of the argument v.

           Note:  The difference between the print and local_display_generator
           functions is that the latter  does  not  display  string  arguments
           enclosed in quotation marks.


--*-- progn Special Form

           The progn  function  evaluates  one or more expressions and returns
           the value of the last expression.

           Format:  (progn s1 [s2 ...])

           Arguments:  The arguments s1, s2, and ..., when specified,  may  be
           any PEEL expressions.

           Action:  EMACS  evaluates each of the arguments s1, s2, and ...  in
           turn, and returns the value of the last one.


--*-- prompt Function

           The prompt function prompts the user for a string value.

           Format:  (prompt s)

           Argument:  The argument s must be a string value.

           Action:  The prompt function returns a string value.

           EMACS displays the string s, followed by a colon symbol (:), in the
           minibuffer, and awaits a typed response.  The characters  typed  in
           response form  the  string  value  that  is  returned by the prompt
           function.

           Note:  This function will return  the  next  pending  argument,  in
           place of  a  prompt, if there are more arguments pending.  (See the
           more_args_p function.)


--*-- prompt_for_integer Function

           The prompt_for_integer function prompts the  user  for  an  integer
           value.

           Format:  (prompt_for_integer s n)

           Arguments:  The  argument s must be a string value.  The argument n
           must be an integer value.

           Action:  The prompt_for_integer function returns an integer  value.

           EMACS displays  the  contents  of the string s, followed by a colon
           (:), in the minibuffer, and awaits a  typed  response.   The  typed
           response must  be  an  optional  string of characters followed by a
           newline.  The  characters  must  form  a  legal   decimal   number,
           optionally signed.

           If  no  characters  are  typed  prior  to  the  newline,  then  the
           prompt_for_integer function returns the value  n;   otherwise,  the
           prompt_for_integer function returns the value of the integer typed.

           Note:  This  function  will  return  the  next pending argument, in
           place of a prompt, if there are more arguments pending.   (See  the
           more_args_p function.)


--*-- prompt_for_string Function

           The prompt_for_string  function  prompts  the user for a string and
           returns the value typed.

           Format:  (prompt_for_string s t)

           Arguments:  The arguments s and t must be string values.

           Action:  The prompt_for_string function returns a string value.

           EMACS displays the string s, followed by a colon symbol (:), in the
           minibuffer, and awaits a typed user response.  The  typed  response
           is an optional string of characters ending with a newline.

           If a  string  of characters is typed prior to the newline, then the
           prompt_for_string function  returns   a   string   containing   the
           characters   typed;   otherwise,  the  prompt_for_string   function
           returns the value t.

           Note:  This function will return  the  next  pending  argument,  in
           place of  a  prompt, if there are more arguments pending.  (See the
           more_args_p function.)


--*-- pushmark Command and Function

           The pushmark command or function pushes  the  mark  onto  the  mark
           stack and sets a new mark.

           Command Format:  {ESC} X pushmark

           Function Format:  (pushmark)

           Argument:  A numeric argument, if specified, is ignored.

           Action:  EMACS  pushes  the  position  of the current mark onto the
           mark stack, and sets a new mark at the current cursor position.

           Note:  The stacked mark value may  be  restored  by  means  of  the
           popmark command or function.


--*-- putprop Function

           The putprop  LISP  function assigns a tag and a value to a property
           list (plist).  Plist is an association list.

           Format:  (putprop pl v t)

           Arguments:  The arguments pl and t must be atoms,  usually  quoted.
           The argument v may have any data type.

           Action:  The  putprop function assigns the tag t and the value v to
           the property list for the atom pl.

           The putprop function returns the value NIL.

           Note:  If an atom has a property list, the get function can be used
           to determine the value  corresponding  to  a  desired  tag  in  the
           property list.   The  remprop function removes a tag and value from
           the property list.  EMACS  has  no  way  of  accessing  the  entire
           contents of an atom's plist.

           Example:  If  the  atom  Jane  is  previously  undefined,  then the
           statement

                (putprop 'Jane 6 'age)

           gives Jane a property list with the value

                ((age 6))


--*-- query_replace Command and Function

           The query_replace command or function replaces occurrences  of  one
           string with another, querying you prior to each replacement.

           Command Format:  {ESC} X query_replace
                            or
                            {ESC} %

           Function Format:  (query_replace [s [t]])

           Arguments:  A numeric argument, if specified, is ignored.

           The arguments  s and t, if specified to the query_replace function,
           must be string values.

           Action:  If the argument s is not specified, EMACS prompts you with
           "search for:".  The characters you type  prior  to  a  newline  are
           assigned to the string s.

           If the  character string t is not specified, EMACS prompts you with
           "replace with:".  The characters  you  type  are  assigned  to  the
           string t.

           EMACS searches  the current marked region, starting from the top of
           the region, for occurrences of  the  string  s.   When  the  search
           fails, EMACS  displays "not found" and terminates the query_replace
           function.

           For each occurrence found, EMACS positions the cursor at the end of
           the occurrence of the string s and prompts the user  for  a  single
           character, which may be any of the following:

               o  Space to replace the occurrence of s with the  string  t  in
                  the text buffer

               o  Return for no replacement

               o  Period to replace the occurrence of s with t, and  terminate
                  query_replace

               o  {CTRL-G} to terminate query_replace with no replacement

           When the query_replace function terminates, EMACS moves the  cursor
           back to  its  original  position  prior  to  the  execution  of the
           function.

           The query_replace function returns the value NIL.


--*-- quit Command and Function

           The quit command returns you from EMACS to its invocation  process,
           usually PRIMOS.

           Command Format:  {ESC} X quit
                            or
                            {CTRL-X} {CTRL-C}

           Function Format:  (quit)

           Argument:  A numeric argument, if specified, is ignored.

           Action:  If  there  are  modified  buffers,  EMACS  overwrites your
           screen with a list of modified buffers that have not been saved  to
           files, and  asks  you if you wish to quit executing anyway.  If you
           type "y", EMACS terminates immediately, returning  to  the  process
           that invoked  it,  usually  PRIMOS.   If  you  type "n", you simply
           return to editing.

           Note:  The function quit simply sets a flag indicating EMACS should
           exit, rather than actually having the exit occur at that time.


--*-- quote Function

           The quote function is a LISP function  that  returns  its  argument
           without evaluating it.

           Format:  (quote x)
                    or
                    'x

           Argument:  The argument x may have any data type.

           Action:  The  quote  function prevents the normal evaluation of the
           argument x.  It returns x, not the value of x.


--*-- quote_command Command

           The quote_command  command  accepts  the   next   character   typed
           literally for insertion into the text buffer.

           Format:  [{ESC}n] {ESC} X quote_command
                    or
                    [{ESC}n] {CTRL-Q}

           Argument:  The  argument n, if specified, must be an integer value.

           Action:  If the argument n is not specified, let n equal 1.

           EMACS inserts the typed character n times  into  the  text  buffer.
           Nonprinting characters  are  usually  displayed  as a question mark
           (?), or as a rectangular block.


--*-- range_to_string Function

           The range_to_string function returns a character string  containing
           the text between two cursors.

           Format:  (range_to_string cur1 cur2)

           Arguments:  The arguments cur1 and cur2 must be cursor values.

           Action:  The  range_to_string  function  returns a character string
           value containing all the characters in  your  text  buffer  between
           cur1 and  cur2.  The string cannot be longer than 32767 characters.

           Note:  It is not required that cur1 precede cur2.


--*-- read Function

           The read function reads and returns a PEEL form  beginning  at  the
           specified cursor position.

           Format:  (read cur)

           Argument:  The argument cur must be a cursor value.

           Action:  Beginning  at  the cursor position indicated by cur, EMACS
           reads a PEEL form from your text buffer and returns it  as  a  list
           that can then be evaluated.


--*-- read_character Function

           The read_character function reads a character from the terminal and
           returns it.

           Format:  (read_character [raw])

           Argument:  An argument, if specified, must be the atom raw.

           Action:  The read_character function returns a character value.

           EMACS reads  a  single  character  from  the  terminal.   If raw is
           specified, the character read is done as a raw read, that is,  with
           no help_on_tap processing.)

           EMACS returns this character.


--*-- read_file Command and Function

           The read_file  command  or  function reads a file into your current
           text buffer.

           Command Format:  {ESC} X read_file
                            or
                            {CTRL-X} {CTRL-R}

           Function Format:  (read_file [s])

           Arguments:  A numeric argument, if specified, is ignored.

           The argument s, if specified, must be a character-string value.

           Action:  If the argument s is not specified, EMACS prompts you with
           "read file:", and assigns  the  characters  you  type  prior  to  a
           newline to the string s.

           If the  current  buffer  is  not  empty, EMACS prompts you with the
           question, "buffer is not empty, delete it?".  If you  respond  with
           "n", EMACS  aborts the command;  if you respond "y", EMACS proceeds
           as follows:

               o  It deletes the contents of the current buffer, if any.

               o  If the string s contains a valid pathname, EMACS  opens  the
                  file specified  by  that  pathname  and  loads  it into your
                  current buffer.

           The read_file function returns the value NIL.

           Note:  If s is a bad pathname, the previous contents of the  buffer
           will have been destroyed.


--*-- redisplay Function

           The redisplay function forces EMACS to update the screen to reflect
           the current state.

           Format:  (redisplay)

           Arguments:  None.

           Action:  EMACS  updates  the  screen  to reflect the current state.
           The redisplay function returns the value NIL.


--*-- reexecute Command

           The reexecute command reexecutes the command entered most  recently
           at the keyboard.

           Format:  [{ESC}n] {ESC} X reexecute
                    or
                    [{ESC}n] {CTRL-C}

           Argument:  The  argument  n, if specified, must be a numeric value.

           Action:  EMACS reexecutes the last command entered at the keyboard.
           If the argument  n  is  specified  and  greater  than  zero,  EMACS
           reexecutes the command n times.


--*-- refresh Command and Function

           The refresh command or function repaints the display screen.

           Command Format:  [{ESC}n] {ESC} X refresh
                            or
                            [{ESC}n] {CTRL-L}

           Function Format:  (refresh [n])

           Argument:  The  argument  n, if specified, must be a numeric value.

           Action:  If  the  value  of  n  is  not  specified,  EMACS  totally
           refreshes   the  screen.   That  is,  the  screen  is  cleared  and
           repainted.  Otherwise, EMACS repaints your screen so that the  line
           in the  current  cursor position is in the nth line in your window.


--*-- reject Command

           The reject command is equivalent to executing an undefined command,
           and it  prints  "Invalid  command:"   in  the  minibuffer.   It  is
           typically used to rebind keys that are to be disabled.


--*-- remassoc Function

           The remassoc function removes an item from a LISP-style association
           list.

           Format:  (remassoc k lst)

           Arguments:  The  argument  lst  must  be  an association list.  The
           argument k may have any data type.

           Action:  The remassoc function returns  the  sublist  of  the  list
           obtained by removing the first sublist associated with the key k in
           lst.

           Example:  After the following:

                 (setq a '((foo bar) (go stop) (hi there) (foo bang)))
                 (remassoc 'foo a)

           the value of a becomes

                     ((go stop) (hi there) (foo bang))

           Notice that only the first sublist with key foo is removed.

           Notice also that there is no need to assign the result of remassoc
           to a again with setq.  The remassoc function automatically changes
           the value of a as a side-effect.


--*-- remove Function

           The remove function removes a member from a list.

           Format:  (remove i lst)

           Arguments:  The argument i may have any data type.  The argument
           lst must be a list value.

           Action:  The remove function returns a list value.  The list value
           returned is obtained by removing the item i from the list lst.

           Note:  The test for whether the item i appears in the list lst is
           made with the = function rather than the eq function.


--*-- remove_charset Function

           The remove_charset function removes all specified characters from a
           string.

           Format:  (remove_charset s1 s2)

           Arguments:  The arguments s1 and s2 must be string values.

           Action:  The remove_charset function returns a string value.  The
           string value returned is computed by removing from string s1 any
           and all characters that also appear in string s2.


--*-- remprop Function

           The remprop LISP function removes a tag and associated value from a
           property list.

           Format:  (remprop pl t)

           Arguments:  The arguments pl and t must be atoms, usually quoted.

           Action:  If the atom pl has a property list with a tag equal to the
           tag t, EMACS removes the tag t and the corresponding value from
           that property list.

           The remprop function returns the value NIL.

           Note:  If an atom has a property list, the get function can be used
           to determine a value corresponding to a desired tag in the property
           list.


--*-- repaint Command and Function

           The repaint command or function moves the cursor to the specified
           window line.

           Command Format:  [{ESC}n] {ESC} X repaint
                            or
                            [{ESC}n] {CTRL-X} R

           Function Format:  (repaint [n])

           Argument:  The  argument n, if specified, must be an integer value.

           Action:  If the argument n is not specified, let n equal 1.

           EMACS moves the cursor to line n on your screen display.

           The repaint function returns the value NIL.


--*-- replace Command and Function

           The replace command or  function  replaces  all  instances  of  one
           string with another in a current region.

           Command Format:  {ESC} X replace

           Function Format:  (replace [s1 [s2]])

           Arguments:  The  arguments  s1 and s2, if specified, must be string
           values.

           Action:  If the string s1 is not specified, EMACS prompts the  user
           with "search  for:".   The  characters typed prior to a newline are
           assigned to the string s1.

           If the argument  s2  is  not  specified,  EMACS  prompts  you  with
           "replace with:".   The  characters  typed  prior  to  a newline are
           assigned to the string s2.

           EMACS replaces all occurrences of the string  s1  in  your  current
           region   with  the  characters  of  the  string  s2.    After   all
           replacements have been  made,  EMACS  returns  the  cursor  to  its
           original position prior to the execution of replace.

           The replace function returns the value NIL.


--*-- reset Command and Function

           The reset  command  or  function puts the screen back in one-window
           mode, sets hcol to one, and refreshes the screen.

           Command Format:  {ESC} X reset

           Function Format:  (reset)

           Argument:  A numeric argument, if specified, is ignored.

           Action:  EMACS resets several status values to their defaults.  You
           are returned  to  one-window  mode,  hcol  (the   leftmost   column
           displayed on  the  screen)  is  set  to  one,  and  the  screen  is
           refreshed.

           The reset function returns the value NIL.

--*-- reset_tabs Command and Function

           The reset_tabs command or function sets tabs at every  five  spaces
           up to column 130.

           Command Format:  {ESC} X reset_tabs

           Function Format:  (reset_tabs)

           Argument:  A numeric argument, if specified, is ignored.

           Action:  EMACS  sets  the  tabs at every five spaces, in columns 5,
           10, 15, and so forth, up to column 130.

           The reset_tabs function returns the value NIL.


--*-- rest$ Function

           The rest$ function is the same as the suffix$ function.


--*-- rest_of_line Function

           The rest_of_line function returns a character string containing the
           rest of the current line, excluding the newline character.

           Format:  (rest_of_line [cur])

           Argument:  The argument cur, if specified, must be a cursor  value.

           Action:  The rest_of_line function returns a string value.

           If the  argument  cur  is  not specified, let cur equal the current
           cursor position.

           EMACS forms a string containing all the characters in the text from
           cur to the end of the line containing cur, and returns that  string
           value.


--*-- restrict_to_sui$ Function

           The restrict_to_sui$  function  is used in definitions of functions
           that are restricted to SUI.

           Format:  (restrict_to_sui$)

           Arguments:  None.

           Action:  If you are not using the SUI interface, EMACS displays the
           error message "That command is not used in  this  interface."   You
           use this function in definitions of functions and commands that are
           to be invoked only from the SUI interface.


--*-- return Function

           The return  function terminates a PEEL function by returning to the
           caller.

           Format:  (return [x])

           Argument:  The argument x, if specified, may have any data type.

           Action:  If the argument x is not specified, let x equal NIL.

           EMACS terminates the current function and returns  to  the  caller,
           with the  value x as the function value.  The data type of x should
           match that specified by the  function's  &returns  declaration,  if
           specified.


--*-- reverse_search Function

           The reverse_search  function searches back in the text buffer for a
           specified string, and returns a Boolean value indicating success or
           failure.

           Format:  (reverse_search s)

           Argument:  The argument s must be a string value.

           Action:  EMACS searches the  text  buffer  back  from  the  current
           cursor position for the string s.

           If the  search  is  successful, EMACS moves the cursor to the first
           character of the matching string in the text  buffer,  and  returns
           the value true.

           If the search fails, the cursor is left unchanged, and the function
           returns the value false.


--*-- reverse_search_command Command and Function

           The reverse_search_command command or function searches back in the
           text buffer for a string.

           Command Format:  {ESC} X reverse_search_command
                            or
                            {CTRL-R}

           Function Format:  (reverse_search_command [s])

           Arguments:  A numeric argument, if specified, is ignored.

           The argument s, if specified, must be a string value.

           Action:  If  the  argument  s is unspecified, EMACS prompts you and
           assigns the resulting string to the variable s.

           EMACS searches  the  text  buffer  back  from  the  current  cursor
           position for the string s.  If the search succeeds, EMACS moves the
           current cursor to the first character of the matching string in the
           text buffer.   The  matched  string  cannot  end beyond the current
           cursor position.

           If the search is unsuccessful, EMACS displays an error message.


--*-- ring_the_bell Function

           The ring_the_bell function sends a {CTRL-G} to your terminal.

           Format:  (ring_the_bell)

           Arguments:  None.

           Action:  EMACS  sends  a  {CTRL-G}  character  to   your   terminal
           producing a sound.

           The ring_the_bell function returns the value NIL.


--*-- rubout_char Command and Function

           The rubout_char  command  or  function deletes the character to the
           left of the current cursor.

           Command Format:  [{ESC}n] {ESC} X rubout_char
                            or
                            [{ESC}n] {CTRL-H}
                            or
                            [{ESC}n] {backspace}
                            or
                            [{ESC}n] {delete}

           Function Format:  (rubout_char [n])

           Argument:  The argument n, if specified, must be an integer  value.

           Action:  If n is not specified, let n equal 1.

           If the value of n is 0, no action takes place.

           If the  value  of  n  is  positive,  EMACS  deletes  n  characters,
           beginning with the character preceding the current cursor  position
           and continuing backward, stopping if the beginning of the buffer is
           reached.

           If the  value  of  n  is  negative,  EMACS  deletes (-n) characters
           beginning with the character at the  current  cursor  position  and
           continuing forward,  stopping  if the end of the buffer is reached.

           The rubout_char function returns the value NIL.


--*-- rubout_word Command and Function

           The rubout_word command or  function  deletes  one  or  more  words
           backwards in the current buffer.

           Command Format:  [{ESC}n] {ESC} X rubout_word
                            or
                            [{ESC}n] {ESC} {CTRL-H}
                            or
                            [{ESC}n] {ESC} {backspace}
                            or
                            [{ESC}n] {ESC} {delete}

           Function Format:  (rubout_word [n])

           Argument:  The  argument  n, if specified, must be an integer whose
           value may be positive, 0, or negative.

           Action:  If the argument n is not specified, let n equal 1.

           If the value of n is 0, no action takes place.

           If the value of n is positive, EMACS deletes n words beginning with
           the word preceding the current cursor position and moving backward.
           Deletion stops if the beginning of the buffer is reached.

           If the value of n is negative, EMACS  deletes  (-n)  words  in  the
           text, beginning  with  the  word at the current cursor position and
           continuing forward.  Deletion stops if the end  of  the  buffer  is
           reached.

           The rubout_word function returns the value NIL.


--*-- same_buffer_p Function

           The same_buffer_p  function  returns  a Boolean value indicating if
           two cursors point into the same text buffer.

           Format:  (same_buffer_p cur1 cur2)

           Arguments:  The arguments cur1 and cur2 must be cursor values.

           Action:  The same_buffer_p function returns a  Boolean  value.   If
           cur1 and  cur2  are  cursor values within the same text buffer, the
           function returns the value true;  otherwise, it returns false.


--*-- save_all_files Command and Function

           The save_all_files command or function saves all  files  that  have
           been modified.

           Command Format:  {ESC} X save_all_files

           Function Format:  (save_all_files)

           Argument:  A numeric argument, if specified, is ignored.

           Action:  EMACS saves the contents of every modified buffer into its
           associated file.  Unmodified buffers are ignored.

           The save_all_files function returns the value NIL.


--*-- save_excursion Special Form

           The save_excursion  special  form saves the current cursor position
           and modes, executes all of its arguments, and restores the original
           cursor and modes.

           Format:  (save_excursion s1 [s2 ...])

           Arguments:  The arguments s1, s2, and ..., if  specified,  must  be
           legal PEEL statements.

           Action:  EMACS  saves  the current cursor and all values and modes.
           Then EMACS executes s1, s2, and so forth.   When  completed,  EMACS
           restores the  saved  cursor,  values,  and  modes.   The  cursor is
           repositioned to the center of the window.

           The save_excursion function returns the value NIL.


--*-- save_file Command and Function

           The save_file command or function writes the current buffer to  the
           file associated with that buffer.

           Command Format:  {ESC} X save_file
                            or
                            {CTRL-X} {CTRL-S}
                            or
                            {CTRL-X} S

           Function Format:  (save_file)

           Argument:  A numeric argument, if specified, is ignored.

           Action:  EMACS  writes the current text buffer out to a file, using
           the filename associated with  the  buffer.   If  the  file  already
           exists on disk, this operation overwrites it.


--*-- save_position Special Form

           The save_position  special  form  is the same as the save_excursion
           special form, except that the current cursor is  not  repositioned.


--*-- save_tab Command and Function

           The save_tab command or function saves the current tab positions in
           a file.

           Command Format:  {ESC} X save_tab

           Function Format:  (save_tab)

           Arguments:  A numeric argument, if specified, is ignored.

           Action:  EMACS prompts you for a filename.  Let the typed string be
           assigned to the variable s.  EMACS next prompts you for the name by
           which the tabs are to be stored in the file.  Let that typed string
           be assigned to the variable t.

           EMACS saves the current tab settings into the file specified by the
           string s.   They  are  stored in PEEL as a setq statement, which if
           executed, will assign the list of tab stops to a variable named  by
           the string t.

           The save_tab function returns the value NIL.

           Note:  You  may restore the saved tab settings by using the get_tab
           command or function.


--*-- say_more Function

           The say_more function is the same  as  the  local_display_generator
           function.


--*-- scan_errors Function

           The scan_errors function scans the current buffer for errors in the
           format of the specified language.

           Format:  (scan_errors lng)

           Argument:  The argument lng must be an unquoted atom.

           Action:  The  argument  lng must be one of the following atoms:  C,
           RPG, FTN,  PMA,  or  TSI.   (TSI   refers   to   all   of   Prime's
           common-envelope compilers:   PL/1,  PL/1G,  PASCAL,  CBL, VRPG, and
           SPL.)  EMACS scans the current buffer  for  errors  in  the  format
           specified by the language atom lng.  This is used by COMPILE.


--*-- scroll_other_backward Command and Function

           The scroll_other_backward command or function scrolls backward that
           window reached by the other_window command or function.

           Command Format:  [{ESC}n] {ESC} X scroll_other_backward
                            or
                            [{ESC}n] {CTRL-X} V

           Function Format:  (scroll_other_backward [n])

           Argument:  The  argument  n, if specified, must be an integer whose
           value may be positive, 0, or negative.

           Action:  If n is not specified, let n equal 1.

           If the value of n is 0, no action takes place.

           If the value of n is positive, EMACS scrolls the other window  back
           n lines.

           If the  value  of  n  is  negative,  EMACS scrolls the other window
           forward (-n) lines.

           The scroll_other_backward function returns the value NIL.


--*-- scroll_other_forward Command and Function

           The scroll_other_forward command or function scrolls  forward  that
           window reached by the other_window command or function.

           Command Format:  [{ESC}n] {ESC} X scroll_other_forward
                            or
                            [{ESC}n] {ESC} {CTRL-V}

           Function Format:  (scroll_other_forward [n])

           Argument:  The  argument  n, if specified, must be an integer whose
           value may be positive, 0, or negative.

           Action:  If n is not specified, let n equal 1.

           If the value of n is 0, no action takes place.

           If the value of n is  positive,  EMACS  scrolls  the  other  window
           forward n lines.

           If the  value of n is negative, EMACS scrolls the other window back
           (-n) lines.

           The scroll_other_forward function returns the value NIL.


--*-- search Function

           The search function returns the position of the first character  of
           a string that also appears in a second string.

           Format:  (search s t)

           Arguments:  The  arguments  s  and  t  must  be string or character
           values.

           Action:  The search function returns an integer value.

           If no characters in string t occur in string s, search returns  the
           value 0.

           If any character in string t occurs in string s, search returns the
           character position  in  s  of  the  first  character  matching  any
           character in t.

           Example:  The function

                (search "abcdef" "cb")

           returns the value 2, while the function

                (search "abcdef" "ce")

           returns the value 3.


--*-- search_back_first_charset_line Function

           The search_back_first_charset_line function  is  the  same  as  the
           search_bk_in_line function.


--*-- search_back_first_not_charset_line Function

           The search_back_first_not_charset_line  function is the same as the
           verify_bk_in_line function.


--*-- search_bk Function

           The search_bk function searches back in your text buffer for any of
           a specified set of characters.

           Format:  (search_bk s [n])

           Arguments:  The argument s must be a string value.  The argument n,
           if specified, must be an integer value.

           Action:  The search_bk function returns a Boolean value.

           If n is not specified, let n equal 1.

           If n is positive, EMACS does the following n times:  starting  from
           the current  cursor  position,  it searches back in the text buffer
           for any character from the set in string s.  If no  such  character
           is found,  the  search  terminates,  EMACS leaves the cursor at the
           beginning of the buffer, and the function returns the value  false.
           If a  character  is  found matching any in the set s, the cursor is
           left on this character and the function returns true.

           If the value of n is negative, EMACS performs

                (search_fd (- n))


--*-- search_bk_in_line Function

           The search_bk_in_line function  is  like  the  search_bk  function,
           except that  it  only  looks  back  as  far as the beginning of the
           current line.


--*-- search_charset_backward Function

           The search_charset_backward function is the same as  the  search_bk
           function.


--*-- search_charset_forward Function

           The search_charset_forward  function  is  the same as the search_fd
           function.


--*-- search_fd Function

           The search_fd function searches forward in your text buffer for any
           of a specified set of characters.

           Format:  (search_fd s [n])

           Arguments:  The argument s must be a string value.  The argument n,
           if specified, must be an integer value.

           Action:  The search_fd function returns a Boolean value.

           If n is not specified, let n equal 1.

           If n is positive, EMACS does the following n times:  starting  from
           the current cursor position, it searches forward in the text buffer
           for any  character  from  the  set  in  the  string  s.  If no such
           character is found, the search terminates, EMACS leaves the  cursor

           at the end of the buffer, and the function returns the value false.
           If a  character  is  found matching any in the set s, the cursor is
           left on this character, and the function returns true.

           If the value of n is negative, EMACS performs

                (search_bk (- n))


--*-- search_fd_in_line Function

           The search_fd_in_line function is the  same  as  search_fd,  except
           that the search stops at the end of the current line.


--*-- search_for_first_charset_line Function

           The search_for_first_charset_line  function  is  the  same  as  the
           search_fd_in_line function.


--*-- search_for_first_not_charset_line Function

           The search_for_first_not_charset_line function is the same  as  the
           verify_fd_in_line function.


--*-- search_not_charset_backward Function

           The   search_not_charset_backward  function  is  the  same  as  the
           verify_bk function.


--*-- search_not_charset_forward Function

           The search_not_charset_forward  function  is  the   same   as   the
           verify_fd function.


--*-- select Special Form

           The select  special  form  evaluates  an expression and compares it
           against a set of constants to determine what action to take.

           Format:  (select v
                        x1 s1
                        x2 s2
                        ...
                        otherwise sx)

           Arguments:  The argument v may have any data type.

           Each argument x1, x2, and ...  may consist of one or more constants
           of the same data type as v.

           Each argument s1, s2, ..., and sx may consist of one or  more  PEEL
           statements.

           Action:  EMACS  evaluates the argument v and compares it to x1, x2,
           and ...  until a match is found.  If a match  is  found,  then  the
           corresponding PEEL  statement  s1,  or s2, or ...  is executed, and
           the value of that statement is returned as  the  value  of  select.
           Otherwise, the  statement  sx  is  executed,  and the value of that
           statement is returned as the value of select.  (See Chapter  4  for
           additional information and an example.)

           If no  match  is  found  and no "otherwise" statement is specified,
           select returns the value NIL.


--*-- select_any_window Command and Function

           The select_any_window command or function selects any  window  and,
           therefore, can be used to cycle through all windows.

           Command Format: {ESC} X select_any_window
                           or
                           {CTRL-X} 4

           Function Format:  (select_any_window [n])

           Argument:  The  argument  n, if specified, must be a numeric value.

           Action:  EMACS repeats the following  step  n  times:   change  the
           current window  to  the  next major window in its standard order of
           windows.

           Note:  Use this command to cycle through  all  your  windows.   The
           major_window_count command can be used to get a count of the number
           of windows.


--*-- select_buf Command and Function

           The select_buf command or function lets you change buffers.

           Command Format:  {ESC} X select_buf
                            or
                            {CTRL-X} B

           Function Format:  (select_buf [s])

           Arguments:  A  numeric  argument,  if  specified,  is ignored.  The
           argument s, if specified, must be a string value.

           Action:  If the argument is not specified, EMACS prompts  you  with
           "Buffer:".  The  characters  that  you type up to the first newline
           are stored as a string in the variable s.

           If the string s is not a null string, EMACS  switches  you  to  the
           buffer whose name is given by the characters of the string s.

           If the  string  s  is a null string, EMACS switches you back to the
           buffer from which you switched to the current buffer.

           The select_buf function returns the value NIL.


--*-- self_insert Function

           The self_insert function inserts a character into your text buffer.

           Format:  (self_insert ch)

           Argument:  The argument ch must be a character.

           Action:  EMACS inserts the character ch into your  text  buffer  at
           the current cursor position.  (See also the overlayer function.)

           The self_insert function returns the value NIL.

           Example:

                (self_insert \G)

           This function  inserts  the  character  "G"  at  the current cursor
           position.

                (overlayer \H)

           This function overlays the current  character  with  the  character
           "H".


--*-- send_raw_string Function

           The  send_raw_string  function  sends  a  string  directly  to  the
           terminal.

           Format:  (send_raw_string s)

           Argument:  The argument s must be a string value.

           Action:  The send_raw_string function returns a string value.

           EMACS sends the string s to your terminal in raw mode  and  returns
           the value  of  s.   Use  send_raw_string to send "escape sequences"
           that directly manipulate features of  the  terminal,  but  remember
           that by doing so you might confuse EMACS.


--*-- set Function

           The set  function  assigns  the  second  argument to the first, and
           returns the value assigned.

           Format:  (set a v)

           Arguments:  The argument a must be an atom, usually quoted with  '.

           The argument v may have any data type.

           Action:  EMACS  assigns  the value v to the atom a, and returns the
           value v.

           Note:  The set function follows the standard PEEL  convention  that
           both arguments  are evaluated.  That is why it is usually necessary
           to quote the first of  the  two  arguments.   This  is  not  always
           necessary, however, as illustrated by the following example:

                (set 'a 'b)
                (set a 23)

           The first  assignment  statement  gives the atom a the value b.  In
           the second assignment statement, the argument  a  is  evaluated  as
           yielding the value b;  thus the value of b is set to 23.  The value
           of a is unchanged, still equaling the atom b.

           The setq  function is related.  In general, use of the set function
           with a ' preceding the first argument is equivalent of use of  setq
           with no  such  '.   For example, the first of the two set functions
           shown above could be changed to:

                (setq a 'b)


--*-- set_command_abort_flag Function

           The set_command_abort_flag function sets the command_abort flag.

           Format:  (set_command_abort_flag)

           Arguments:  None.

           Action:  EMACS aborts the current command.


--*-- set_fill_column Command and Function

           The set_fill_column command or function sets the fill  column  used
           for fill mode.

           Command Format:  {ESC} X set_fill_column

           Function Format:  (set_fill_column [k])

           Argument:  The  argument k, if specified, must be an integer value.

           Action:  If the argument k is not specified, EMACS prompts you  for
           an integer value, and assigns the result to k.  EMACS sets the fill
           column to k.

           Note:  The current fill column can be obtained by the following:

                (buffer_info fill_column)


--*-- set_hscroll Command and Function

           The set_hscroll  command  or function sets the value of hcol, which
           controls horizontal scrolling.

           Command Format:  {ESC} X set_hscroll

           Function Format:  (set_hscroll [k])

           Arguments:  A numeric argument, if specified, is ignored.

           The argument k, if specified, must be a numeric value.

           Action:  If the argument k is not specified, EMACS prompts you with
           "What is the horizontal column:", and assigns  the  result  to  the
           variable k.

           EMACS uses  the  value  of  k  to  set  the  value  of  hcol, which
           determines the column number of the leftmost  column  displayed  on
           your screen.


--*-- set_key Command and Function.

           The set_key  command  or  function  binds  a  keypath  to a desired
           function name.

           Command Format:  {ESC} X set_key

           Function Format:  (set_key [p [f]])

           Arguments:  The arguments p and f,  if  specified  to  the  set_key
           function, must be string values.

           Action:  If the argument p is not specified, EMACS prompts you with
           "Key path:".   The  characters  you  type  are assigned as a string
           value to the variable p.

           If the argument f is not specified, EMACS prompts you with "command
           name:".  The characters you type, prior to a newline, are  assigned
           as a string to the variable f.

           The string  f  must  be  the  name of a previously-defined command.
           EMACS binds the keypath specified by the characters in the string p
           to the command specified by the string  f.   This  binding  applies
           only to the current buffer.

           The key_key function returns the value NIL.

           Note:    The  set_key  function  is  not  normally  as  useful   as
           set_permanent_key.  The two functions differ only in that a set_key
           binding applies to the current buffer,  while  a  set_permanent_key
           binding applies  to  all  buffers  throughout the remainder of your
           session.  Both functions are described in Chapter 2 of this manual.


--*-- set_left_margin Command and Function

           The set_left_margin command or function sets the left margin.

           Command Format:  {ESC} X set_left_margin

           Function Format:  (set_left_margin [k])

           Arguments:  A numeric argument, if specified, is ignored.

           The argument k, if specified, must be a numeric value.

           Action:  If the argument k is not specified, EMACS prompts you  for
           an integer  value  with "what is the left margin:", and assigns the
           result to the variable k.

           EMACS uses the value of k as the left-margin value in fill mode.

           Note:  The left margin is used with the  indent_to_fill_prefix  and
           fill_para commands when fill mode is on.


--*-- set_mode Command and Function

           The set_mode  command  or  function  lets you specify the mode that
           EMACS sets for your current buffer.

           Command Format:  {ESC} X set_mode

           Function Format:  (set_mode [m])

           Arguments:  A numeric argument, if specified, is ignored.

           The argument m, if specified to the set_mode function,  must  be  a
           string value.

           Action:  If the argument m is not specified, EMACS prompts you with
           "Mode name:".   The  characters  you  type  prior  to a newline are
           assigned as a string to the variable m.

           EMACS sets the mode for your current buffer to the  name  specified
           by string m.  All other modes are turned off.

           The set_mode function returns the value NIL.


--*-- set_mode_key Command and Function

           The set_mode_key  command  or function lets you bind a keypath to a
           command on a per-mode basis.

           Command Format:  {ESC} X set_mode_key

           Function Format:  (set_mode_key [m [p [f]]])

           Arguments:  A numeric argument, if specified, is ignored.

           The arguments m, p, and f, if specified, must be string values.

           Action:  If the argument m is not specified, EMACS prompts you with
           "Mode name:".  The characters that  you  type  are  assigned  as  a
           string to the variable m.

           If the  argument  p  is  not specified, EMACS prompts you with "Key
           path:".  The characters that  you  type  prior  to  a  newline  are
           assigned as a variable to the string p.

           If the argument f is not specified, EMACS prompts you with "Command
           name:".  The characters you type prior to a newline are assigned as
           a string to the variable f.

           The string  p must define a legal EMACS keypath.  The string f must
           name a previously defined EMACS command.

           EMACS binds the command specified by f to the keypath specified  by
           p.  The  binding  is  in effect only for those buffers in which the
           specified mode is turned on.

           The set_mode_key function returns the value NIL.


--*-- set_permanent_key Command and Function

           The set_permanent_key command or function  binds  a  keypath  to  a
           desired function name.

           Command Format:  {ESC}X set_permanent_key

           Function Format:  (set_permanent_key [p [f]])

           Arguments:    The  arguments  p  and  f,  if  specified   to    the
           set_permanent_key function, must be string values.

           Action:  If the argument p is not specified, EMACS prompts you with
           "Key path:".  The characters you type  are  assigned  as  a  string
           value to the variable p.

           If the argument f is not specified, EMACS prompts you with "Command
           name:".  The  characters you type, prior to a newline, are assigned
           as a string to the variable f.

           The string f must be the name  of  a  previously  defined  command.
           EMACS binds the keypath specified by the characters in the string p
           to the  command  specified  by  string f.  This binding affects all
           buffers.


--*-- set_right_margin Command and Function

           The set_right_margin command or function sets the right margin  for
           wrapping in fill mode.

           Command Format:  {ESC} X set_right_margin
                            or
                            {CTRL-X} F

           Function Format:  (set_right_margin [k])

           Arguments:  A numeric argument, if specified, is ignored.

           The argument k, if specified, must be an integer value.

           Action:  If  k  is  not specified, EMACS prompts you for an integer
           value with "What is the right margin:", and assigns the  value  you
           type to the variable k.

           EMACS uses  the value of k as the right margin for word wrapping in
           fill mode.


--*-- set_tab Command and Function

           The set_tab command or function is an alternate name for the settab
           command and function.


--*-- set_tabs Command and Function

           The set_tabs command or function  is  an  alternate  name  for  the
           settab command and function.


--*-- setmark Command and Function

           The setmark command or function sets the mark at the current cursor
           position.  It is the same as pushmark, except that it does not push
           a mark if the mark has not changed.


--*-- setq Function

           The setq  function  is  a  standard  LISP function that assigns the
           second argument to the first after quoting the first.

           Format:  (setq a x)

           Arguments:  The argument a is an atom  with  any  data  type.   The
           argument x may be any PEEL expression with a matching data type.

           Action:  EMACS computes

                (set 'a x)

           and returns the value of that expression.


--*-- settab Command and Function

           The settab command or function lets you set your tabs to any values
           you wish.

           Command Format:  {ESC} X settab

           Function Format:  (settab)

           Argument:  A numeric argument, if specified, is ignored.

           Action:  EMACS  displays  a  ruler  on your screen and lets you set
           tabs at whatever positions you want.  (This command is described in
           detail in the EMACS Reference Guide.)


--*-- settabs_from_table Command and Function

           The settabs_from_table command or function sets tab positions based
           on the column position of words in the current line.

           Command Format:  {ESC} X settabs_from_table
                            or
                            {ESC} X setft

           Function Format:  (settabs_from_table)
                             or
                             (setft)

           Argument:  A numeric argument, if specified, is ignored.

           Action:  EMACS sets the tab stop at the first column of every  word
           on the  current  line.   For  this command, a word is a sequence of
           consecutive characters delimited by a space or a punctuation  mark.

           (This command is described in detail in the EMACS Reference Guide.)


--*-- share_library$ Function

           The share_library$  function  loads a shared fasload format file at
           EMACS initialization.

           Format:  (share_library$ s)

           Argument:  The argument s must be a string value.

           Action:  This function is for use only in INIT_EMACS  when  sharing
           EMACS, and cannot be used for any other purpose.

           EMACS opens  for  input a file whose name is obtained by adding the
           suffix .EFASL to the string s.  That file must have only defun  and
           defcom statements  in  it.   EMACS then loads that file and defines
           the functions and commands in it.


--*-- show_lib_alc$ Command

           The show_lib_alc$ command displays the current shared EMACS library
           segments when initializing EMACS.

           Format:  {ESC} X show_lib_alc$

           Argument:  A numeric argument, if specified, is ignored.

           Action:  This command is  used  only  in  INIT_EMACS  when  sharing
           EMACS, and  cannot be used for any other purpose.  It prints at the
           supervisor terminal the current shared EMACS library segments.


--*-- skip_back_over_white Function

           The skip_back_over_white  function  skips  back   over   whitespace
           characters,  returning  a  Boolean  value  indicating  whether  the
           operation succeeded.

           Format:  (skip_backing_over_white [n])

           Arguments:  The argument n, if specified, must be an integer value.

           Action:  The skip_back_over_white function returns a Boolean value.

           If the argument n is not specified, let n equal 1.

           If n equals 0, no action is performed.

           If n is equal to 1, EMACS  proceeds  as  follows:   if  the  cursor
           currently points  to  a  whitespace  character (as indicated by the
           atom whitespace),  EMACS  moves  the  cursor  back  to  the   first
           preceding nonwhitespace  character  and  returns  the  value  true;
           otherwise, EMACS returns the value false.

           If n is greater than 1, EMACS  skips  back  over  (n-1)  groups  of
           whitespace characters,  and  then  proceeds  as described above for
           n=1.  This is done by alternating between skip_back_over_white  and
           skip_back_to_white.

           When n is less than 0, EMACS performs the following:

                (skip_over_white (- n))

           Note:  This is equivalent to (verify_bk whitespace).


--*-- skip_back_to_white Function

           The skip_back_to_white  function  moves  the  cursor  back  to  the
           preceding whitespace   character,   returning   a   Boolean   value
           indicating whether the operation succeeded.

           Format:  (skip_back_to_white [n])

           Arguments:  The argument n, if specified, must be an integer value.

           Action:  If n is not specified, let n equal 1.

           If n equals 0, no action takes place.

           If n equals 1, EMACS proceeds as follows:  if the current cursor is
           not on  a  whitespace  character, EMACS moves the cursor back until
           either the beginning of the  buffer  is  reached  or  a  whitespace
           character  is  found.   If  the  cursor  is  now  on  a  whitespace
           character, the function returns  the  value  true;   otherwise,  it
           returns the value false.

           If n is greater than 1, EMACS first skips back over (n-1) groups of
           whitespace characters,  and  then  proceeds  as described above for
           n=1.

           If n is less than 0, EMACS performs the following:

                (skip_to_white (- n))

           Note:  This is equivalent to (search_bk whitespace).


--*-- skip_over_white Command and Function

           The skip_over_white command or function moves  the  cursor  forward
           over whitespace  characters,  returning  a Boolean value indicating
           whether the operation succeeded.

           Command Format:  [{ESC}n] {ESC} X skip_to_white

           Function Format:  (skip_to_white [n])

           Arguments:  The argument n, if specified, must be an integer value.

           Action:  The skip_over_white function returns the value NIL.

           If the argument n is not specified, let n equal 1.

           If n equals 0, no action takes place.

           If n equals 1, EMACS proceeds as follows:  if the cursor  currently
           points  to  a  whitespace  character  (as  indicated  by  the  atom
           whitespace), then EMACS moves  the  cursor  forward  to  the  first
           nonwhitespace character,  and  returns  the value true;  otherwise,
           EMACS returns the value false.

           If n is greater than 1, EMACS skips forward over  (n-1)  groups  of
           whitespace characters,  and then proceeds as described above when n
           equals 1.

           If the value of n is less than 0, EMACS performs

                (skip_back_over_white (- n))


--*-- skip_to_white Command and Function

           The skip_to_white command or function moves the cursor  forward  to
           the proceeding  whitespace  character  returning  a  Boolean  value
           indicating whether the operation succeeded.

           Command Format:  [{ESC}n] {ESC} X skip_to_white

           Function Format:  (skip_to_white [n])

           Arguments:  The argument n, if specified, must be an integer value.

           Action:  If n is not specified, let n equal 1.

           If n equals 0, no action takes place.

           If n equals 1, EMACS proceeds as follows:  if the current cursor is
           not on a whitespace character, EMACS moves the cursor forward until
           either the end of the buffer is reached or a  whitespace  character
           is found.  If the cursor is now on a whitespace character, then the
           function returns  the  value true;  otherwise, it returns the value
           false.

           If n is greater than 1, EMACS first skips forward over (n-1) groups
           of whitespace characters, and then proceeds as described above  for
           n=1.

           If n is less than 0, EMACS performs

                (skip_back_to_white (- n))


--*-- sleep_for_n_milliseconds Function

           The sleep_for_n_milliseconds  function  directs  EMACS to pause for
           the specified time interval.

           Format:  (sleep_for_n_milliseconds n)

           Arguments:  The argument n must be an integer value.

           Action:  The sleep_for_n_milliseconds function returns  an  integer
           value.

           EMACS sleeps for n milliseconds, and returns the value of n.


--*-- sort_dt Command and Function

           The sort_dt  command or function inserts the current date into your
           text buffer in a format suitable for sorting.

           Command Format:  {ESC} X sort_dt

           Function Format:  (sort_dt)

           Argument:  A numeric argument, if specified, is ignored.

           Action:  EMACS inserts the current date into your  text  buffer  at
           the current cursor position.  The format is as follows:

                YY/MM/DD

           This format is suitable for sorting.

           The sort_dt function returns the value NIL.


--*-- sort_list Function

           The sort_list function sorts a list and returns the result.

           Format:  (sort_list lst)

           Argument:  The argument lst must be a list of lists.

           Action:  The sort_list function returns a list value.

           The list lst is of the following form:

                ((key1 ...)  (key2 ...)  ...)

           EMACS forms  a  new  list obtained by rearranging the items of this
           list so that they are in increasing order by the keys.

           Each key is obtained by taking the car of  each  inner  list.   The
           keys must  be  mutually  comparable.   In  usual practice, they are
           either all  integers,  or   all   characters,   or   all   strings.
           (Characters are, however, comparable with strings.)

           The sort_list function returns the resulting list.

           Example:

                (setq names
                      '(("Fred" 37) ("Adam" 14) ("Joe" 34) ("Bert" 296)))
                (setq numbers
                      '((37 "Fred") (14 "Adam") (34 "Joe") (296 "Bert")))
                (print (sort_list names))
                (print (sort_list numbers))

           Executing these statements displays the following results:

                (("Adam" 14) ("Bert" 296) ("Fred" 37) ("Joe" 34))
                ((14 "Adam") (34 "Joe") (37 "Fred") (296 "Bert"))


--*-- split_line Command and Function

           The split_line  command  or  function  breaks a line at the current
           cursor position,  preserving  the  horizontal   position   of   the
           right-hand portion of the line.

           Command Format:  [{ESC}n] {ESC} X split_line
                            or
                            [{ESC}n] {ESC} {CTRL-O}

           Function Format:  (split_line [n])

           Argument:  The  argument  n, if specified, must be a numeric value.

           Action:  If the argument n is not specified, let n equal 1.

           Let k equal the column  position  of  the  current  cursor.   EMACS
           inserts n  newlines, followed by k blanks, so that the current line
           has been split into n+1 lines, preserving the  horizontal  position
           of all characters on the original line.

           The cursor is left at the inserted newline.

           The split_line function returns the value NIL.


--*-- split_window Command and Function

           The split_window command or function splits the current window into
           two, putting the cursor into the new window.

           Command Format:  [{ESC}n] {ESC} X split_window
                            or
                            [{ESC}n] {CTRL-X} 2

           Function Format:  (split_window [n])

           Argument:  The  argument  n, if specified, must be a numeric value.

           Action:  If the value of n is unspecified, let n equal one half the
           height of the current window.

           EMACS splits the current window into two, moving  the  cursor  into
           the second window.  The split occurs at the nth line of the window.

           The split_window function returns the value NIL.


--*-- split_window_stay Command and Function

           The split_window_stay command or function splits the current window
           into two, leaving the cursor in the current window.

           Command Format:  [{ESC}n] {ESC} X split_window_stay
                            or
                            [{ESC}n] {CTRL-X} 3

           Function Format:  (split_window_stay [n])

           Argument:  The  argument  n, if specified, must be a numeric value.

           Action:  If the value of n is not specified, let n equal  one  half
           the height of the current window.

           EMACS splits the current window into two, leaving the cursor in the
           original window.  The split occurs in the nth line.

           The split_window_stay function returns the value NIL.


--*-- stem_of_line Function

           The stem_of_line function returns the stem (leading portion) of the
           current line.

           Format:  (stem_of_line [cur])

           Argument:  The  argument cur, if specified, must be a cursor value.

           Action:  The stem_of_line function returns a string value.

           If the argument cur is not specified, let  cur  equal  the  current
           cursor position.

           EMACS forms a string containing the characters preceding cur on the
           same line as cur.  The function returns the resulting string.


--*-- stop_doing Special Form

           The stop_doing  function  stops execution of the current do_forever
           or do_n_times loop.

           Format:  (stop_doing)

           Arguments:  None.

           Action:  EMACS  stops  execution  of  the  current  do_forever   or
           do_n_times loop.

           The stop_doing function returns the value NIL.


--*-- string Data Type

           Variables with  the  string  data  type  can  be assigned character
           strings.


--*-- string_length Function

           The string_length function returns the length of a string argument.

           Format:  (string_length s)

           Argument:  The argument s must be a string or character.

           Action:  The string_length function returns an integer value  equal
           to the  number  of  characters  in  the  string  s,  or 1 if s is a
           character.


--*-- string_of_length_n Function

           The string_of_length_n function pads or truncates  a  string  to  a
           specified length.

           Format:  (string_of_length_n s n [p])

           Arguments:  The  argument  s  must  be  a string or character.  The
           argument n must be an integer.  The argument p, if specified,  must
           be a string or character.

           Action:  The  string_of_length_n  function  returns a string value.
           The length of the resulting string is given by the argument n.

           If the  argument  p  is  not  specified,  let  p  equal  the  space
           character.

           The value of n must be nonnegative.

           If the  length  of  string  s  is greater than n, EMACS forms a new
           string by truncating the string s to the length n.

           If the length of string s is less then n, EMACS forms a new  string
           by concatenating  sufficient  copies  of the string p to the end of
           string s so that the length of the new string is  greater  than  or
           equal to n, and then truncates this result to the length n.

           The resulting string is returned.


--*-- string_to_integer Function

           The string_to_integer function converts a string to an integer.

           Format:  (string_to_integer s)

           Argument:  The argument s must be a string value.

           Action:  The  string_to_integer  function returns an integer value.

           The string s must contain decimal digits, optionally preceded by  a
           sign.  EMACS  converts  the  string  to  the  corresponding integer
           value, and returns the result.


--*-- stringp Function

           The stringp function tests whether an argument is a string.

           Format:  (stringp x)

           Argument:  The argument x may have any data type.

           Action:  The stringp function returns a Boolean value.

           The value returned is true  if  the  data  type  of  x  is  string;
           otherwise, the value is false.


--*-- sublist Function

           The sublist function returns a sublist of a given list.  It acts on
           lists exactly as the substr function does on strings.

           Format:  (sublist lst n [k])

           Arguments:  The  argument lst must be a list value.  The argument n
           must be an integer.  The argument  k,  if  specified,  must  be  an
           integer.

           Action:  The sublist function returns a list value.

           If the argument k is not specified, let k equal infinity.

           EMACS forms  a new list by taking items from the list lst, starting
           at item number n, and continuing for k items, stopping if  the  end
           of list lst is reached.

           The resulting list value is returned.


--*-- substr Function

           The substr  function  returns a substring of a given string.  It is
           like the PL/I substr function.

           Format:  (substr s n [k])

           Arguments:  The argument s must be a  string  or  character  value.
           The argument  n  must be an integer.  The argument k, if specified,
           must be an integer.

           Action:  The substr function returns a string value.

           If the argument k is not specified, let k equal infinity.

           EMACS forms a new  string  by  taking  characters  from  string  s,
           starting at  character position n, and continuing for k characters,
           stopping if the end of string s is reached.

           The resulting string value is returned.

           Example:  The function

                (substr "abcdef" 3 2)

           returns the string "cd", while the function

                (substr "abcdef" 3)

           returns the value "cdef".


--*-- suffix$ Function

           The suffix$ function returns  the  substring  after  the  rightmost
           period (.)  in the name of the current buffer or the passed string.

           Format:  (suffix$ [s])

           Argument:  The argument s, if specified, must be a string value.

           Action:  The suffix$ function returns a string value.

           If the  argument  s  is  not  specified, let s equal a string value
           containing the name of the current buffer.  (To be useful, normally
           s must be a string whose value is a treename.)

           EMACS computes a new string value, t, as follows:

               o  If the string s does  not  contain  any  occurrence  of  the
                  character ".", or if the string s contains the character ">"
                  but does not contain "."  to the right of the rightmost ">",
                  let t equal "" (the null string).

               o  Otherwise, let  t  equal  the  substring  of  the  string  s
                  containing all characters to the right of the rightmost ".".

           The suffix$ function returns the value t.


--*-- sui_exchange_mark Command and Function

           The sui_exchange_mark  command  or function is a SUI version of the
           exchange_mark command or  function  that  provides  the  user  with
           additional information.


--*-- sui_primos_command Command and Function

           The sui_primos_command  command  or  function is the SUI version of
           the primos_command command or function.


--*-- sui_set_tabs Command

           The sui_set_tabs command  establishes  the  tab  settings  for  SUI
           users.

           Format:  {ESC} X sui_set_tabs

           Arguments:  None.

           Action:  The  sui_set_tabs command establishes tab settings for SUI
           users.


--*-- suppress_redisplay Function

           The  suppress_redisplay   function   checks   or   enables/disables
           redisplay.

           Format:  (suppress_redisplay [b])

           Argument:  The  argument  b, if specified, must be a Boolean value.

           Action:  The suppress_redisplay function returns a  Boolean  value.

           Let x equal the current value of the redisplay variable.

           If the  argument  b is specified, set the redisplay variable to the
           value specified by b.

           The suppress_redisplay function returns the value x.


--*-- tab Command and Function

           The tab command or function moves the cursor to the next tab  stop.

           Command Format:  [{ESC}n] {ESC} X tab
                            or
                            [{ESC}n] {CTRL-I}

           Function Format:  (tab [n])

           Argument:  The  argument n, if specified, must be an integer value.

           Action:  If n is not specified, let n equal 1.

           If n equals 0, no action takes place.

           If n is positive, EMACS does the following n times:  it  moves  the
           cursor to the next tab-stop position on the current line.  If there
           are not  enough  characters  remaining  on  the current line, EMACS
           inserts a sufficient number of blanks so that the cursor  can  move
           to the next tab-stop position.


--*-- tablist Command and Function

           The tablist  command  and function accepts a series of numbers from
           the terminal and sets tab stops at those positions.

           Command Format:  {ESC} X tablist

           Function Format:  (tablist)

           Argument:  A numeric argument, if specified, is ignored.

           Action:  EMACS prompts you  with  "Set  tab  columns  separated  by
           blanks:".  You  may  then  type  a  list  of  numbers, separated by
           blanks, ending in a newline.  EMACS  sets  the  tab  stops  at  the
           positions you specify.

           The tablist function returns the value NIL.


--*-- tablist_to_array Function

           The tablist_to_array function takes a list of integers and sets tab
           stops at the specified positions.

           Format:  (tablist_to_array lst)

           Argument:  The argument lst must be a list, normally quoted.

           Action:  The items in the argument lst must all be integers.  EMACS
           sets the tab stops at positions indicated by those integers.

           The tablist_to_array function returns the value NIL.

           Example:  (tablist_to_array '(5 13 24 60))


--*-- take_left_margin Command and Function

           The  take_left_margin command  or  function  sets the  left  margin
           equal to the current column position of the cursor.

           Command Format:  {ESC} X take_left_margin

           Function Format:  (take_left_margin)

           Arguments:  A numeric argument, if specified, is ignored.

           Action:  EMACS sets the left margin, without prompting the user, by
           taking  the  value  for the  left  margin from  the current  column
           position of the cursor.

           EMACS uses the value of the current  column position of the  cursor
           as the left-margin value in fill mode.

           Note:  The left margin is used with the  indent_to_fill_prefix  and
           fill_para commands when fill mode is on.


--*-- take_right_margin Command and Function

           The  take_right_margin command or function  sets the  right  margin
           equal to the current column position of the cursor.

           Command Format:  {ESC} X take_right_margin

           Function Format:  (take_right_margin)

           Arguments:  A numeric argument, if specified, is ignored.

           Action: EMACS sets the right margin, without prompting the user, by
           taking  the  value for the  right  margin from  the current  column
           position of the cursor.

           EMACS uses the value of the current  column position of the  cursor
           as the right-margin value in fill mode.

           Note:  The right margin is used with the  indent_to_fill_prefix and
           fill_para commands when fill mode is on.


--*-- tell_left_margin Command

           The tell_left_margin  command  or  function prints the current left
           margin position.

           Command Format:  {ESC} X tell_left_margin

           Function Format:  (tell_left_margin)

           Argument:  A numeric argument, if specified, is ignored.

           Action:  EMACS prints  the  current  left-margin  position  in  the
           minibuffer.

           Note:  The  left  margin  is  the  value  bound  to  the atom named
           fill_prefix.


--*-- tell_modes Command and Function

           The tell_modes command or  function  displays  all  modes  for  the
           current buffer.   This  function  is needed for those situations in
           which all modes are not shown on the mode line.

           Command Format:  {ESC} X tell_modes

           Function Format:  (tell_modes)

           Argument:  A numeric argument, if specified, is ignored.

           Action:  EMACS displays all current  modes  on  your  screen.   Use
           {CTRL-G} to restore the display.


--*-- tell_position Command and Function

           The tell_position  command or function displays buffer information,
           including the current line and character position.

           Command Format:  {ESC} X tell_position
                            or
                            {CTRL-X} =

           Function Format:  (tell_position)

           Argument:  A numeric argument, if specified, is ignored.

           Action:  In  the  minibuffer  EMACS  displays  current   line   and
           character   information,  buffer  size  information,   and   window
           information.

           The tell_position function returns the value NIL.


--*-- tell_right_margin Command and Function

           The tell_right_margin command or function prints the current  right
           margin position.

           Command Format:  {ESC} X tell_right_margin

           Function Format:  (tell_right_margin)

           Argument:  A numeric argument, if specified, is ignored.

           Action:  EMACS  prints  the  current  right-margin  position in the
           minibuffer.


--*-- terminal_info Function

           The terminal_info function queries or sets  information  about  the
           user's terminal.

           Format:  (terminal_info p [v])

           Arguments:  The  argument p must be an atom chosen from among those
           listed below under action.  This atom should not be quoted.

           The argument v, if specified, must have a data type compatible with
           the atom p, as specified below.

           Action:  The terminal_info function returns a value whose data type
           depends upon the argument p.

           The argument p is an atom that specifies a terminal property to  be
           queried or  set.   The  legal values for the argument p, their data
           types, and their meanings are shown in the following table.

                p           Data Type  Meaning

                type        string     Terminal type

                speed       integer    Baud rate

                height      integer    Number of rows in the display

                width       integer    Number of columns in the display

                crtp        Boolean    True if the terminal is a CRT

                can_insert  Boolean    Can insert/delete lines, making  screen
                                       refresh a bit faster

           If the  argument  v is specified, and if the property p is not read
           only, EMACS sets the property p to the value specified by v.

           Note that at the present time all properties are read-only.

           The terminal_info function returns the old value of the property p.


--*-- terminal_type Function

           The terminal_type function returns a string containing the terminal
           type.

           Format:  (terminal_type)

           Arguments:  None.

           Action:  The  terminal_type  function  returns   a   string   value
           containing the type of terminal you are using.


--*-- terpri Function

           The terpri function inserts a newline.

           Format:  (terpri cur)

           Argument:  The  argument cur, if specified, must be a cursor value.

           Action:  If cur is not specified, let cur equal the current  cursor
           position.

           EMACS inserts  a newline character at the cursor position indicated
           by cur, and sets the current cursor to the character following  the
           newline.

           The terpri function returns the value NIL.


--*-- throw Function

           The throw  function  is  like  the *throw function, except that the
           argument order is different.

           Format:  (throw body tag)

           This is like *throw, except that the body  and  tag  arguments  are
           reversed.  Because  throw's  argument order makes programming quite
           difficult, the use of *throw is recommended instead.   (See  *throw
           for further information.)


--*-- tld Command

           The tld  command is a SUI command that lists your file directory in
           order of date-and-time last written.

           Format:  {ESC} X tld

           Arguments:  None.

           Action:  EMACS executes the following PRIMOS command at the current
           attach point:

                LD -LONG -SRTD


--*-- toggle_redisp Command and Function

           The toggle_redisp command or function toggles redisplay  mode.   It
           is usually used with slow display terminals.

           Command Format:  {ESC} X toggle_redisp
                            or
                            {CTRL-X} {CTRL-T}

           Function Format:  (toggle_redisp)

           Argument:  A numeric argument, if specified, is ignored.

           Action:  If the redisplay flag is off, EMACS turns it on.  If it is
           on, EMACS turns it off.  (See suppress_redisplay.)

           The toggle_redisp function returns the value NIL.


--*-- token_chars Variable

           The token_chars variable is a global string variable whose value is
           a string  containing all the characters in the basic character set.
           Specifically, it is set to the following character string:

           "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ_0123456789"

           These tokens are considered to be legal characters in a word.   The
           forward_word, back_word, delete_word, and rubout_word commands will
           treat all characters in this string as components of a word.


--*-- translate Function

           The translate  function translates a string by replacing one set of
           characters with another.  This is similar  to  the  PL/I  translate
           function.

           Format:  (translate sa sb [sc])

           Arguments:  The  arguments sa and sb, and sc, if specified, must be
           string or character values.

           Action:  The translate function returns a string value.

           If the argument  sc  is  not  specified,  let  sc  equal  a  string
           containing the  entire collating sequence (character set) supported
           by EMACS.

           If the length of sb is greater than or equal to the length  of  sc,
           then let  sb2  equal  sb;   otherwise,  let  sb2  equal  the string
           obtained by concatenating a sufficient number of blanks to the  end
           of string sb, so that the resulting string is as long as the string
           sc.

           EMACS forms  a  new string sa2 from the characters in the string sa
           by performing the following steps for k=1 to the length  of  string
           sa:

               o  Let ch be the character in position k of string sa.

               o  If ch does not appear in the string sc, leave ch  unchanged.

               o  Otherwise, if ch appears  in  the  string  sc,  and  if  the
                  leftmost such  appearance is at position m in string sc, let
                  ch equal the character in position m of string sb.

               o  EMACS sets the character in position k of string sa2 to  ch.

           The translate function returns the string sa2.


--*-- transpose_word Command and Function

           The transpose_word command or function inverts the positions of the
           words before and after the current cursor.

           Command Format:  {ESC} X transpose_word
                            or
                            {ESC} T

           Function Format:  (transpose_word)

           Argument:  A numeric argument, if specified, is ignored.

           Action:  EMACS  transposes  the  words before and after the current
           cursor position.  The current cursor is left at the first character
           of the second word.

           The transpose_word function returns the value NIL.


--*-- trim Function

           The trim function  removes  leading  and  trailing  blanks  from  a
           string.

           Format:  (trim s)

           Argument:  The argument s must be a string value.

           Action:  The  trim  function  returns  a  string  value.  The value
           returned is computed by removing leading and trailing  blanks  from
           the string s.


--*-- trim_date Command and Function

           The trim_date  command  or function inserts the current date at the
           current cursor position.

           Command Format:  {ESC} X trim_date

           Function Format:  (trim_date)

           Argument:  A numeric argument, if specified, is ignored.

           Action:  EMACS inserts the current date into  your  buffer  at  the
           current cursor  position,  using a format similar to the following:

                19 Sep 1985

           The trim_date function returns the value NIL.


--*-- trim_dt Command and Function

           The trim_dt command or function inserts the  current  date  at  the
           current cursor position.

           Command Format:  {ESC} X trim_dt

           Function Format:  (trim_dt)

           Argument:  A numeric argument, if specified, is ignored.

           Action:  EMACS  inserts  the  current  date into your buffer at the
           current cursor position, using a format similar to  the  following:

                09/19/85

           The trim_dt function returns the value NIL.


--*-- turn_mode_off Function

           The turn_mode_off  function  turns  off a mode by removing the mode
           name from the buffer mode list.

           Format:  (turn_mode_off d)

           Argument:  The argument d must be a dispatch table.

           Action:  EMACS removes all occurrences the specified dispatch table
           d from the buffer mode list.

           The turn_mode_off function returns the value NIL.

           Example:

                (turn_mode_off (find_mode 'LISP))

           In this statement the find_mode function returns a  dispatch  table
           for LISP  mode, and the turn_mode_off function turns LISP mode off.


--*-- turn_mode_on Function

           The turn_mode_on function turns a mode on and adds the mode name to
           the buffer mode list if the mode is not already on.

           Format:  (turn_mode_on d [f])

           Arguments:  The argument d must be a dispatch table.  The  argument
           f, if specified, must be the unquoted atom first.

           Action:  EMACS  turns the specified mode on, and adds the mode name
           to the buffer mode list.  If the argument f is  specified  (as  the
           atom first), EMACS places the new mode in the first position on the
           mode list;  otherwise, EMACS places it last.

           The turn_mode_on function returns the value NIL.

           Example:

                (turn_mode_on (find_mode 'LISP) first)

           This statement  turns LISP mode on and places the new mode first on
           the mode list.

           Note:  The order of modes  in  the  list  is  the  order  in  which
           dispatch tables are searched while processing key bindings.


--*-- twiddle Command and Function

           The twiddle  command or function transposes the position of the two
           characters preceding the current cursor.

           Command Format:  {ESC} X twiddle
                            or
                            {CTRL-T}

           Function Format:  (twiddle)

           Argument:  A numeric argument, if specified, is ignored.

           Action:  EMACS  reverses  the  position  of  the   two   characters
           preceding the current cursor.

           The twiddle function returns the value NIL.


--*-- type_tab Command and Function

           The type_tab  command  or  function  moves  the cursor forward by a
           specified number of tab stops.

           Command Format:  [{ESC}n] {ESC} X type_tab

           Function Format:  (type_tab [n])

           Argument:  The argument n, if specified, must be an  integer  whose
           value may be positive, 0, or negative.

           Action:  If the argument n is not specified, let n equal 1.

           If the value of n is 0, no action takes place.

           If the  value  of  n is positive, the cursor is moved forward n tab
           stop positions.   If  the  end  of  the  line  is  reached,   EMACS
           automatically fills  the  end of the line with blank characters, up
           to the desired tab stop position.

           If the value of n is negative, the cursor is moved  back  (-n)  tab
           stops, stopping if the beginning of the line is reached.

           The type_tab function returns the value NIL.


--*-- typef Function

           The typef  function  returns an integer indicating the data type of
           its argument.

           Format:  (typef x)

           Argument:  The argument x may have any data type.

           Action:  The typef function returns an integer argument.  The value
           returned depends upon the data type of x, as shown in the following
           table:

               Data Type of x      Value Returned

               any                        1
               Boolean                    2
               character                  3
               integer                    4
               string                     5
               atom                       6
               function                   7
               list                       8
               cursor                     9
               dispatch_table            11
               handler                   12
               window                    14


--*-- uid Function

           The uid  function  returns  a  string  value  containing  a  unique
           identifier.

           Format:  (uid)

           Arguments:  None.

           Action:  The uid function returns a string value.

           The string  contains  characters  that  may  be  used  as  a unique
           identifier.


--*-- unmodify Command and Function

           The unmodify command or function tells EMACS to treat  the  current
           buffer as if it were unmodified.

           Command Format:  {ESC} X unmodify
                            or
                            {ESC} ~

           Function Format:  (unmodify)

           Argument:  A numeric argument, if specified, is ignored.

           Action:  EMACS  clears  its "modified" flag for the current buffer.

           The unmodify function returns the value NIL.


--*-- untidy Command and Function

           The untidy command or function removes indenting and  justification
           from a paragraph.

           Command Format:  {ESC} X untidy

           Function Format:  (untidy)

           Argument:  A numeric argument, if specified, is ignored.

           Action:  The  untidy  command  or  function  removes  indenting and
           justification while filling the current  paragraph,  so  that  each
           line does  not have more than the number of characters indicated by
           the  function   (buffer_info fill_column)   or   by   the   command
           tell_right_margin.  It  rearranges  words  on the line so that each
           line is about the same length.  Use set_right_margin to change  the
           right margin.


--*-- upcase Function

           The upcase function converts a string to uppercase.

           Format:  (upcase s)

           Argument:  The argument s must be a string value.

           Action:  EMACS  returns  a  string  value  obtained by changing all
           lowercase letters in s to uppercase, leaving all  other  characters
           unchanged.


--*-- uppercase_region Command and Function

           The uppercase_region  command  or  function  converts all lowercase
           letters in the current region to uppercase.

           Command Format:  {ESC} X uppercase_region
                            or
                            {CTRL-X} {CTRL-U}

           Function Format:  (uppercase_region)

           Argument:  A numeric argument, if specified, is ignored.

           Action:  EMACS changes all lowercase letters in the current  region
           to uppercase, leaving all other characters unchanged.

           The uppercase_region function returns the value NIL.

           Caution:  This  command  must  be used with extreme care.  If it is
           mistakenly applied to the wrong region of  text  in  uppercase  and
           lowercase, its effect must be undone manually.


--*-- uppercase_word Command and Function

           The uppercase_word  command  or function changes the text in one or
           more words to uppercase.

           Command Format:  [{ESC}n] {ESC} X uppercase_word
                            or
                            [{ESC}n] {ESC} U

           Function Format:  (uppercase_word [n])

           Argument:  The argument n, if specified, must be an  integer  whose
           value may be positive, 0, or negative.

           Action:  If the argument n is not specified, let n equal 1.

           If the value of n is 0, no action takes place.

           If the  value  of  n  is  positive, EMACS converts to uppercase all
           lowercase letters in the region from the beginning of  the  current
           word (or  the next word, if the cursor is on whitespace) to the end
           of the nth word, moving forward.  The cursor moves to  the  end  of
           that region.

           If the  value  of  n  is  negative,  EMACS changes to uppercase all
           lowercase letters in the region ending at the end  of  the  current
           word (or  the  previous  word,  if the cursor is on whitespace) and
           beginning at the beginning of the (-n)th word preceding the current
           cursor position.  The cursor is left unchanged

           The uppercase_word function returns the value NIL.


--*-- user_name Variable

           The user_name variable is a string variable containing  your  login
           name.


--*-- using_cursor Special Form

           The using_cursor  function executes PEEL statements and then resets
           the cursor.

           Format:  (using_cursor cur s1 [s2 ...])

           Arguments:  The argument cur must be a cursor value.  The arguments
           s1, s2, and ...  must be PEEL statements.

           Action:  EMACS executes all the statements s1,  s2,  and  ...,  and
           then performs the following:

                (go_to_cursor cur)

           The using_cursor function returns the value NIL.


--*-- verify Function

           The verify function tests a string for legal characters.

           This is the PL/I verify built-in function.

           Format:  (verify sa sb)

           Arguments:  The arguments sa and sb must be string values.

           Action:  The verify function returns an integer value.

           If all  characters  of string sa also appear in string sb, then the
           function returns 0.

           Otherwise, the function returns the position of the first character
           in string sa that is not also in string sb.


           Example:  The function

                (verify "ABACUS" "ABCDEFGHIJKLMNOPQRSTUVWXYZ")

           returns the value 0, while

                (verify "ABACUS" "ABCD")

           returns the value 5.


--*-- verify_bk Function

           The verify_bk  function  scans  back  from  the   current   cursor,
           searching for a character not in the argument string.

           Format:  (verify_bk s [n])

           Arguments:  The  argument  s  must  be a string or character value.
           The argument n, if specified, must be an integer value.

           Action:  The verify_bk function returns a Boolean value.

           If the argument n is not specified, let n equal 1.

           If the value of n is 0, no operation takes place.

           Starting from the current  cursor  position  and  moving  backward,
           EMACS searches  for  the  nth occurrence of a character in the text
           buffer that does not also appear  in  the  string  s.   If  such  a
           character is  found  before  reaching  the beginning of the buffer,
           then EMACS leaves the cursor at that character position and returns
           true;  otherwise, EMACS leaves the cursor at the beginning  of  the
           buffer and returns false.

           If the value of n is less than 0, EMACS performs the following:

                (verify_fd (- n))


--*-- verify_bk_in_line Function

           The verify_bk_in_line  function  is like verify_bk, except that the
           search ends at the beginning of the current line.


--*-- verify_fd Function

           The verify_fd function searches forward from the current cursor for
           a character not in the argument string.

           Format:  (verify_fd s [n])

           Arguments:  The argument s must be a string value.  The argument n,
           if specified, must be an integer value.

           Action:  The verify_fd function returns a Boolean value.

           If the argument n is not specified, let n equal 1.

           If the value of n is 0, no operation takes place.

           Starting from the current cursor position and moving forward, EMACS
           searches for the nth occurrence of a character in the  text  buffer
           that does  not also appear in the string s.  If such a character is
           found before reaching the end of the buffer, then EMACS leaves  the
           cursor at  that  character  position  and returns true;  otherwise,
           EMACS leaves the cursor at the end of the buffer and returns false.

           If n is less than 0, EMACS performs the following:

                (verify_bk (- n))


--*-- verify_fd_in_line Function

           The verify_fd_in_line function is the  same  as  verify_fd,  except
           that the search ends at the end of the line.


--*-- view_file Command and Function

           The view_file command or function allows you to view (look through)
           a file in read-only mode without being able to modify it.

           Command Format:  {ESC} X view_file

           Function Format:  (view_file [s])

           Argument:  The argument s, if specified, must be a string value.

           Action:  If the argument s is not specified, EMACS prompts you with
           "View file:".   EMACS assigns all characters typed before a newline
           is reached to the string variable s.

           EMACS opens in view mode the file whose name is  specified  by  the
           string s,  meaning that you may examine the file but not modify it.


--*-- view_kill_ring Command and Function

           The view_kill_ring command or function lets you view  the  contents
           of kill buffers.

           Command Format:  {ESC} X view_kill_ring
                            or
                            {CTRL-X} {CTRL-Z} K

           Function Format:  (view_kill_ring)

           Argument:  A numeric argument, if specified, is ignored.

           Action:  EMACS  allows  you  to  review  your  kill buffers.  (This
           command is described in detail in the EMACS Reference Guide.)


--*-- view_lines Command and Function

           The view_lines command or function updates your screen  on  a  slow
           terminal.

           Command Format:  {ESC} X view_lines
                            or
                            {CTRL-X} {CTRL-Z} {CTRL-V}

           Function Format:  (view_lines)

           Argument:  A numeric argument, if specified, is ignored.

           Action:  EMACS updates your display.

           The view_lines function returns the value NIL.

           Note:  This  command  is  used after you have used toggle_redisp to
           suppress automatic updating of your display.


--*-- vld Command

           The vld command is a SUI command that provides a verbose listing of
           your file directory.

           Format:  {ESC} X vld

           Arguments:  None.

           Action:  EMACS executes following the PRIMOS command at the current
           attach point.

                LD -LONG -SRTN


--*-- vsplit Command and Function

           The vsplit  command  or  function  splits   your   current   window
           vertically into two windows.

           Command Format:  {ESC} X vsplit

           Function Format:  (vsplit)

           Argument:  A numeric argument, if specified, is ignored.

           Action:  EMACS  splits  your current window into two at the current
           cursor position.

           The vsplit function returns the value NIL.


--*-- wait_for_input Function

           The wait_for_input function waits for the user to type a character.
           The typed character is NOT removed from the input buffer.

           Format:  (wait_for_input)

           Arguments:  None.

           Action:  EMACS waits until the user types a character.

           The wait_for_input function returns the value NIL.


--*-- wallpaper Command and Function

           The wallpaper command or function inserts all help information into
           your current text buffer.

           Command Format:  {ESC} X wallpaper

           Function Format:  (wallpaper)

           Argument:  A numeric argument, if specified, is ignored.

           Action:  EMACS inserts all of  its  apropos  help  text  into  your
           current buffer.  This includes all your current bindings.

           The wallpaper function returns the value NIL.


--*-- which_tabs Command and Function

           The which_tabs command or function informs a user which set of tabs
           (local or global) is currently in effect.

           Command Format:  {ESC} X which_tabs

           Function Format:  (which_tabs)

           Arguments:  A numeric argument, if specified, is ignored.

           Action: EMACS informs the user whether local or global tab settings
           are currently in effect.


--*-- white_delete Command and Function

           The white_delete  command or function deletes all whitespace around
           point.

           Command Format:  {ESC} X white_delete
                            or
                            {ESC} \

           Function Format:  (white_delete)

           Argument:  A numeric argument, if specified, is ignored.

           Action:  If the character at the current  cursor  position  or  the
           character preceding  the  current  cursor  position is a whitespace
           character, then it and all  contiguous  whitespace  characters  are
           deleted;  otherwise, no action takes place.

           The white_delete function returns the value NIL.

           Note:  The  white_delete  function  has  the  same  effect  as  the
           delete_white_sides function.


--*-- whitespace Variable

           The whitespace variable is a string variable that contains all  the
           characters used  when  searching for whitespace.  EMACS initializes
           it to a space.


--*-- whitespace_to_hpos Function

           The whitespace_to_hpos  function  inserts  whitespace   until   the
           specified horizontal position is reached.

           Format:  (whitespace_to_hpos n)

           Argument:  The argument n must be an integer value.

           Action:  The  whitespace_to_hpos  function returns a Boolean value.

           Let h equal the current horizontal position.

           If n is greater than h, EMACS inserts (n-h) blanks at  the  current
           cursor position.

           After the  insertion  is  completed, the function returns the value
           true.


--*-- window Data Type

           A variable with the window data type represents a screen window.


--*-- window_info Function

           The window_info  function  sets  or  queries  information  about  a
           window.

           Format:  (window_info p [x])

           Arguments:  The  argument  p  must be an unquoted atom, chosen from
           the atom names listed below  under  action.   The  argument  x,  if
           specified, must have a data type compatible with the argument p, as
           described below.

           Action:  The  window_info  function returns a value whose data type
           depends upon the argument p.

           The following table gives the legal  values  for  the  argument  p,
           along with the corresponding function data type and meaning:

                   p               Data Type              Meaning

               top_line            integer    The top line of  the  screen  on
                                              which   the  current  window  is
                                              displayed.  (read-only)

               bottom_line         integer    The last line on the  screen  on
                                              which the  window  is displayed.
                                              (read-only)

               left_column         integer    The leftmost  screen  column  in
                                              which   the   window    appears.
                                              (read-only)

               right_column        integer    The rightmost screen  column  in
                                              which   the   window    appears.
                                              (read-only)

               is_active           Boolean    Whether the  window   is   being
                                              redisplayed.  (read-only)

               is_major            Boolean    Whether the window is  an  major
                                              window.  This  will  usually  be
                                              true.  The minibuffer window  is
                                              not a major window.  (read-only)

               top_line_cursor     cursor     This cursor points into the  top
                                              line of the text that appears as
                                              the  top  line  of  the  window.
                                              (writable)

               showing_numbers     Boolean    Whether line  numbering  is  on.
                                              (writable)

               column_offset       integer    The value  of   the   horizontal
                                              column offset  for  the  window.
                                              (See hcol.)  (writable)

               last_buffer_cursor  cursor     The current cursor position  for
                                              this window.  (writable)

               mark_bottom         Boolean    Mark is  at  bottom  of  window.
                                              (writable)

           If the  argument  x is specified, and if the property corresponding
           to the argument  p  is  not  read-only,  EMACS  sets  the  property
           corresponding to  the  argument  p  to  the  value  of  x.  This is
           permitted only for property shown as "writable" in the above table.

           The window_info function returns the old value of  the  property  p
           for the current window.


--*-- with_cleanup Special Form

           The with_cleanup  function  executes  PEEL code and then executes a
           handler that will be run whether an error occurs or not.   This  is
           similar to the CLEANUP$ condition in PL/I.

           Format:  (with_cleanup s1 [s2 ...])
                        handler hs1 [hs2 ...])

           Arguments:  The  arguments  s1,  s2,  and  ...,  and  hs1, hs2, and
           ... must be PEEL statements.

           Action:  EMACS executes the statements s1, s2, and  ...   .   After
           completion of that execution, whether normally or because of error,
           EMACS executes hs1, hs2, and ...  .

           The with_cleanup function returns the value NIL.


--*-- with_command_abort_handler Special Form

           The with_command_abort_handler  function  executes PEEL code with a
           handler for errors.

           Format:  (with_command_abort_handler s1 [s2 ...]
                        command_abort_handler hs1 [hs2 ...])

           Arguments:  The arguments s1,  s2,  and  ...,  and  hs1,  hs2,  and
           ... must be PEEL statements.

           Action:  EMACS  executes  s1,  s2,  and ...  .  If no error occurs,
           execution of the with_command_abort_handler function terminates.

           If an error occurs, EMACS resets the error  flags  and  throw,  and
           executes hs1, hs2, and ...  .

           The with_command_abort_handler function returns the value NIL.


--*-- with_cursor Special Form

           The with_cursor  function executes a body of code after copying the
           current cursor to a temporary cursor.

           Format:  (with_cursor c s1 [s2 ...])

           Arguments:  The argument c must be an unquoted atom.  The arguments
           s1, s2, and ...  must be PEEL statements.

           Action:  EMACS copies the current cursor to c and then executes s1,
           s2, and ...  .


--*-- with_no_redisplay Special Form

           The with_no_redisplay  function  executes  code  while  suppressing
           redisplay.

           Format:  (with_no_redisplay s1 [s2 ...])

           Arguments:  The arguments s1, s2, and ...  must be PEEL statements.

           Action:  EMACS  executes  s1,  s2,  and  ...  without updating your
           display.


--*-- wrap Command and Function

           The wrap command or function inserts  a  carriage  return  if  word
           wrapping should occur.

           Command Format:  [{ESC}n] {ESC} X wrap

           Function Format:  (wrap [n])

           Argument:  The  argument  n, if specified, must be a numeric value.

           Action:  If the argument n is not specified, let n equal 1.

           EMACS inserts its last invocation  character  (&character_argument)
           and checks its horizontal position.  If it is greater than the fill
           column, wrap replaces it with a newline.


--*-- wrap_line_with_prefix Function

           The wrap_line_with_prefix  function  specifies  the wrap column and
           the prefix string.

           Format:  (wrap_line_with_prefix n s)

           Arguments:  The argument n must be an integer value.  The  argument
           s must be a string value.

           Action:  This  is  the  function  that  actually  performs the wrap
           operation.


--*-- wrapoff Command and Function

           The wrapoff command or function is obsolete.  Use fill_off.


--*-- wrapon Command and Function

           The wrapon command or function is obsolete.  Use fill_on.


--*-- write_file Command and Function

           The write_file command or function writes the current buffer to the
           specified file.

           Command Format:  {ESC} X write_file

           Function Format:  (write_file [s])

           Arguments:  A numeric argument, if specified, is ignored.

           The argument s, if specified must be a string value.

           Action:  If the argument s is not specified, EMACS prompts you with
           "write file:"  and assigns the typed string to the variable s.

           If the value of s is a  null  string,  let  s  equal  the  filename
           associated with the current buffer.

           EMACS writes  the  current  buffer  to  the  file whose pathname is
           specified by the string s.

           The write_file function returns the value NIL.

           Note:  This will overwrite an existing file with NO WARNING.   (See
           also mod_write_file.)


--*-- yank_kill_text Command and Function

           The yank_kill_text  command  or  function  inserts  the  text saved
           during view_kill_ring at the current cursor position.

           Command Format:  {ESC} X yank_kill_text
                            or
                            {CTRL-X} {CTRL-Z} {CTRL-Y}

           Function Format:  (yank_kill_text)

           Argument:  A numeric argument, if specified, is ignored.

           Action:  EMACS inserts the text saved by view_kill_ring  into  your
           text buffer at the current cursor position.

           The yank_kill_text function returns the value NIL.


--*-- yank_minibuffer Command and Function

           The yank_minibuffer  command  or function inserts the response to a
           previous minibuffer prompt at the current cursor position.

           Command Format:  [{ESC}n] {ESC} X yank_minibuffer
                            or
                            [{ESC}n] {ESC} {CTRL-Y}

           Function Format:  (yank_minibuffer [n])

           Argument:  The argument n, if specified, must be an integer  value.

           Action:  If the argument n is not specified, let n equal 0.

           EMACS inserts  into  your  current  buffer  at  the  current cursor
           position the characters typed in response to the  (n+1)st  previous
           minibuffer prompt.

           The yank_minibuffer function returns the value NIL.


--*-- yank_region Command and Function

           The yank_region  command  or  function  inserts a previously killed
           region into your current buffer at the current cursor position.

           Command Format:  {ESC} X yank_region
                            or
                            {CTRL-Y}

           Function Format:  (yank_region [n])

           Argument:  The argument n, if specified, must be a  numeric  value.

           Action:  If the argument n is not specified, let n equal 0.

           EMACS inserts the text in the (n+1)st previous kill region into the
           current buffer, at the current cursor position.

           The yank_region function returns the value NIL.


--*-- yank_replace Command and Function

           The yank_replace  command  or  function  replaces the text inserted
           with yank_region with the text in a preceding kill_ring buffer.

           Command Format:  {ESC} X yank_replace
                            or
                            {ESC} Y

           Function Format:  (yank_replace [n])

           Argument:  The argument n, if specified, is ignored.

           Action:  You  use  yank_replace  after  a  yank_region  command  or
           function.

           If the argument n is not specified, let n equal 0.

           The yank_replace  function replaces the text you have just inserted
           with text from the (n+1)st preceding buffer on the kill ring.

           Notes:  You may use yank_replace repeatedly until the text you want
           from the kill ring appears.

           EMACS remembers only the last ten or so responses.


--*-- yesno Function

           The yesno function prompts the user for a yes or no reply.

           Format:  (yesno s)

           Argument:  The argument s must be a string value.

           Action:  The yesno function returns a Boolean value.

           EMACS prompts the user in the minibuffer with the string s.  If the
           reply is "yes", "OK", or "true", then the  yesno  function  returns
           the value true;  otherwise, it returns the value false.


--*--
