Mon Jul  3 12:34:26 1989
    Documentation strings for Emacs lisp extensions
    Mark Weissman
    Apollo Computer Inc.

 To Use Domain/CommonLISP Programming Environment:

Add the following line into the file: ~/user_data/common_lisp/startup.lisp
       (load "/sys/common_lisp/gnuemacs_support/apollo-lisp-support")
Add the following lines into the file ~/.emacs
       (load "/sys/common_lisp/gnuemacs_support/clisp.elc")
        ;;; Note that the lisp called will be the same as when
        ;;; typing the value of inferior-lisp-program to the shell.
       (setq inferior-lisp-program "lisp")
       ;; (setq apollo:gnuemacs-client-p t) ;; use newer interface
       (save-excursion (lisp))

There is newer, faster, more robust code to handle the communication
interface between emacs and Domain/CommonLISP 3.0.  This code has not been
tested as fully as the current interface.  If you wish to use this
newer interface, uncomment the line: 
        ;; (setq apollo:gnuemacs-client-p t) ;; use newer interface
in the above code.

To use RMAIL on an Apollo ring running Apollo DPSS/MAIL (not UNIX Mail), add the
following lines into the file ~/.emacs:
       (setq rmail-primary-inbox-list '("~/user_data/mail/inbox/"))
       (load "/sys/common_lisp/gnuemacs_support/dpss-rmail-support.elc")
  and if you are running a mail server add to speed up mail access:
       (setq apollo-rmail-fetch nil)
Note: dpss-rmail-support is for DPSS mail and not for UNIX sendmail.  Loading
      dpss-rmail-support will cause UNIX sendmail to stop working!

The last line in your ~/.emacs file should be:
       (switch-to-buffer "*scratch*")


The following is a description of the functionality made available by doing the above.



 Concepts

 1. Hooks
 
 Hooks are lists of functions which are automatically executed before or after an
 Emacs Lisp function. They come in 3 varieties:
       1. before-hooks: a list of functions which are funcalled (executed) before
          the original function is executed. These functions are called with the
          same arguments as the original function.
       2. unwind-hooks:  a list of functions which are funcalled after the original
          function is executed. These functions are called with the same arguments as
          the original function.  These functions are unwind protected so that they
          will run in the presence of throws, errors, aborts etc.
       3. after-hooks: a list of functions which are funcalled after the original
          function is executed.  These functions will be called with the result of
          executing the original function followed by the original arguments.
 When a function has hooks added to it (via the macro apollo:add-hooks), the following
 local-variables are created:
          <function-name> bound to the symbol function of the original function
          <function-name>-documentation which will be the doc string for the original function.
          <function-name>-before-hooks, the list of before-hooks.

          <function-name>-unwind-hooks, the list of unwind-hooks.
          <function-name>-after-hooks, the list of after-hooks.

 An example of where you might see hooks mentioned is when you type meta-x 
 describe-function message. The resultant output is:

        message:
        Print a one-line message at the bottom of the screen.
        The first argument is a control string.
        It may contain %s or %d or %c to print successive following arguments.
        %s means print an argument as a string, %d means print as number in decimal,
        %c means print a number as a single character.
        The argument used by %s must be a string or a symbol;
        the argument used by %d or %c must be a number.

        Added hooks: apollo:message-before-hooks,
                     apollo:message-unwind-hooks &
                     apollo:message-after-hooks.

 Notice that the Emacs Lisp function message has before, unwind, and after
 hooks listed. If you evaluated the symbols, you would see that
 apollo:message-before-hooks was bound to the list: (apollo:notification),
 and that apollo:message-unwind-hooks and apollo:message-after-hooks were
 both bound to NIL. This means that the function message only has a
 before-hook, apollo:notification, which is called with the same arguments
 as the original function, message, prior to its execution.


 2. Sections

 A section is a compilation unit.  Currently they are only supported in Lisp and
 Emacs-Lisp Modes.  The current definition used for incremental compilation by 
 isapollo:lisp-compile-defun the section in which the cursor is found. To see the
 sections of a buffer use the command meta-x list-sections.


 3. S-Expression (abbreviated sexp)

 A symbol, string, bracketed expression, or list of s-expressions.
 A list is a parenthesized expression. In non-Lisp languages, where
 s-expressions are used in commands (e.g. mouse-insert-thing), the 
 behavior may occasionally be unexpected (e.g. a Lisp symbol is a 
 superset of C identifiers).


 4. Region

 The area of text between mark and point.  Mark may be explicitly set
 using control-space (some commands set mark automatically). Point is 
 the location of the cursor. Many commands operate on a region (e.g.
 control-y).


 5. Modes

 Modes may affect the applicability and/or behavior of commands.
 Commands prefixed by Control-c are either present or absent based on the
 mode of a buffer (e.g. Control-c . is only available in Lisp modes).
 Meta-x commands may do nothing in some modes (e.g. meta-x 
 evaluate-into-buffer in non-Lisp buffers) or behave differently
 (e.g. meta-x update-attribute-list will insert a language dependent
 leading comment in a buffer).



 6. Attribute List

 Each file or Gnuemacs buffer has a set of attributes which can be displayed
 textually. It must be the first line in the source and should be a comment in the
 language (if there is one) of the source code. The attribute list parser expects
 a list of keyword-value pairs between -*- delimiters. The attribute list appears
 as follows:
         CommentStart -*- Attribute1: Value1; AttributeN: ValueN -*- CommentEnd
       where:
         CommentStart is language dependent (e.g. ; in Lisp, and /* in C)
         CommentEnd would be the null string in Lisp and */ in C.
 A sample attribute list might look like:
       ;;; -*- Mode: Lisp; Syntax: Common-Lisp; Package: Apollo -*-

 This is parsed when the file is read in and the appropriate variables are then
 set in the buffer.  These attributes can affect what commands are applicable,
 as the Mode does, or cause the compiler to exhibit different behavior as the
 Syntax and Package attributes do.


 7. Numeric Arguments to Emacs Commands

 Numeric arguments are used to modify the behavior of a command.
 When numeric arguments are available for a specific command, then
 the command description will mention "ARG N" where N is an integer.
 The way to explicitly pass an argument to a meta-x, control-x, or 
 control-c command is via typing meta-N, followed by the command
 (e.g. you would type "meta-2 meta-x evaluate-common-lisp" to
 have the results displayed in a buffer named *LISP-OUTPUT* ).
 A synonym for the use of meta-N above is control-u N, thus the example
 could read "control-u 2 meta-x evaluate-common-lisp" to achieve the
 same behavior.

 Further Notes

 1. The meta and Escape keys are similar, but have some important 
 differences. The Escape key is a command prefix, i.e. it is
 an independent keystroke.  The meta key is a shift key. Thus
 "meta-." executes the same command as "<escape> .", but the former
 is one keystroke and the latter is two (i.e. the meta key must be
 held down while typing the ".", but the Escape key is typed prior
 to typing the ".").



CONFIGURATION VARIABLES:

apollo:aegis-directory
   Default:  "/com"   
  "Location of Apollo Domain Aegis Files"

apollo:os-version
   Default:  (apollo:get-os-version)   
  "String indicating version of Domain OS.
        Does bldt command to find string to use as default."

apollo:*lowercase-file-directories*
   Default:  (eql 0 (string-match "9" apollo:os-version))   
  "If true (that is, the variable has a non-nil value), Emacs changes
all uppercase letters in directory pathnames to the pre-SR10 convention of using
lowercase letters preceded by colons.  For example, DOC becomes :d:o:c and Doc
becomes :doc.

        If false (that is, the variable has a nil value), uppercase letters in
directory pathnames remain unchanged."

apollo:lisp-interrupt
   Default:  
  (if (eql 0 (string-match "9" apollo:os-version)) 'quit-process 'interrupt-process)   
  "This must be reset according to Apollo Domain OS!
        This is the argument to /bin/kill to provide a keyboard
        interrupt to lisp.
        For SR10  use interrupt-process
        For SR9.7 use quit-process"

apollo:eval-on-closure
   Default:  t   
  "If this variable contains a value other than nil and all nested
parentheses in a Lisp listener buffer become closed, Emacs evaluates the
s-expression in that buffer."

apollo:check-parenthesis-before-saving-p
   Default:  t   
  "When this Boolean's value is t and unbalanced parentheses exist,
Emacs queries before saving files."

apollo:look-for-in-package-p
   Default:  t   
  "If true (that is, the variable has a non-nil value), Emacs searches
backwards in the common lisp buffer for a line starting with the in-package
function and uses the specified package when evaluating Common Lisp forms.

        If false (that is, the variable has a nil value) or if Emacs cannot
find the in-package function, then Emacs uses the apollo:
look-for-attribute-line-package-p configuration variable.  If this second
variable has a value other than nil, Emacs checks the buffer's attribute line;
otherwise, Emacs checks the value of the apollo: package variable for an
uppercase string representing the package.  If this third variable has the value
nil, Emacs uses the value of the *package* variable in the current inferior lisp
process."

apollo:look-for-attribute-line-package-p
   Default:  t   
  "If true (that is, the variable has a non-nil value), Emacs examines
the attribute lists of lisp buffers while evaluating common lisp expressions
within those buffers.  Consult the description of the apollo:
look-for-in-package-p configuration variable for more information."

apollo:page-size
   Default:  62   
  "The value of this variable determines the largest allowable page
size for the pagify-lisp-buffer command (also described in this section)."

apollo:tmp-dir
   Default:  "/tmp"   
  "The value of this variable is the pathname of the temporary
directory."

apollo:default-printer
   Default:  ""   
  "The value of this variable is the entry directory name (for example,
\"//flasher\") of the print queue used by the print-buffer-apollo and
print-region-apollo commands.

        If the value of the variable is nil or a pair of empty quotation marks,
Emacs prompts for the entry directory name."

apollo:gnuemacs-client-p
   Default:  nil    
"Use client/server protocol to talk to inferior lisp.  Normally,
communication between lisp and emacs is handled by interrupting the
lisp process, eating break messages, sending input to lisp &
continuing from interrupt.  There is also a mechanism for use with
Domain/CommonLISP 3.0 which uses named pipes and a lisp task to do
this communication.  The latter scheme has not been fully tested and
is therefore turned off by default.  The latter scheme though is
potentially faster and more robust.  Another difference with the
latter scheme is that lisp output from all commands not originating
in the lisp listener buffer will go into special history buffers."

apollo:printer-args
   Default:  ""   
  "This string variable contains the /com/prf command arguments (for
example, \"-pr cx -s //flasher\") used by the print-buffer-apollo and the
print-region-apollo commands."

apollo:inferior-lisp-switches
   Default:  nil   
  "List of strings representing starup switches to lisp program."

apollo:update-attribute-list-when-creating-file-p
   Default:  t   
  "If true (that is, the variable has a non-nil value), Emacs updates a
file's attribute list from local variables when creating the file's buffer."

apollo:modes-not-to-update-attribute-list-when-creating-file
   Default:  nil   
  "List of strings representing mode names for modes that don't update
attribute lists when creating file buffers of that mode.  These mode
names are the values returned by executing (apollo:mode) from within
the new buffer."

apollo:*pagify-lisp-buffer-p*
   Default:  't   
  "When printing a Lisp buffer, pagify it first."


ATTRIBUTE LIST COMMANDS:

parse-attribute-list
    Use the buffer's attribute list to set local variables.  (For a
description of attribute lists, see the beginning of this chapter.)

        Emacs parses the attribute list when reading the file into the buffer
and sets the appropriate variables.  If the optional argument UPDATE is non-nil,
Emacs checks the corresponding local variables and, if they vary from those in
the attribute list, queries to update the attribute list.

update-attribute-list
    Compare the buffer's local variables with its attribute list.  If
they disagree, query to update the attribute list.

common-lisp-mode
    Display the package name on the current buffer's mode line.

set-syntax
    Set the buffer's mode to the specified SYNTAX.

        At present, the command only recognizes the syntax "common-lisp" for
the Lisp mode.

set-mode
    Prompt for the MODE of the buffer and set it as specified.

set-package
    Prompt for the default PACKAGE of the buffer and set it as
specified.


PARENTHESIS AND COMMENT COMMANDS:

close-definition
    Add the correct number of right parentheses to close the current
definition.

find-unbalanced-parentheses
    Search the current buffer for unmatched parentheses and move point to
the first occurrence.

comment-out-region
    In the marked region, begin each line with the string in
comment-start and end it with the string in comment-end; in Lisp, these are
";" and "", respectively.  If the command has a negative argument, remove
these comment characters from the beginning and end of lines in the marked
region.

uncomment-out-region
    Remove the comment characters defined in comment-start and
comment-end from the beginning and end of lines in the marked region.


SECTION AND FIND-SOURCE-CODE COMMANDS (LISP AND EMACS LISP ONLY):

sectionize-buffer
    Create a list of section markers for the current buffer for use by
the apollo:find-source-code commands; if ARG exists, create lists for all
buffers.

        The command creates an association list in the form of a name and
marker for each definition.  Many routines (and Emacs commands) use this list to
locate definitions in the buffer.

apollo:mouse-find-file
    Key Binding:    Global [Control-c Control-f]
    When the user presses M3 (the right mouse button), search for a file
with pathname given by the string under the mouse cursor, and load the file into
a buffer.

find-file-no-sectionize
    Move point to the buffer visiting the file FILENAME; create the
buffer if none exists.

        This command inhibits "sectionizing" of the buffer for
find-source-code commands (see the sectionize-buffer command description for
details).  However, Emacs can sectionize the buffer's contents if needed.

list-sections
    Section the contents of the current buffer and list all sections; if
the command has a non-nil argument, simply list the sections.

        The command searches for lines beginning with (def or


(<package_name>::def and lists the associated sections.  Clicking M2 on a
section name in the list loads the section for editing.

apollo:mouse-find-source-code
    Key Binding:    Lisp-Mode [<Mouse Middle Up>]
    Key Binding:    Emacs-Lisp-Mode [<Mouse Middle Up>]
    Key Binding:    Inferior-Lisp-Mode [<Mouse Middle Up>]
    When the user presses M2 (the middle mouse button), search for a
function whose name is given by the string under the mouse cursor, load the
source code for the identified function into a buffer.

        The command is defined for Lisp and Emacs-Lisp modes only.

apollo:key-find-source-code
    Key Binding:    Lisp-Mode [Meta-.]
    Key Binding:    Emacs-Lisp-Mode [Meta-.]
    Key Binding:    Inferior-Lisp-Mode [Meta-.]
    Prompt for a function NAME and load the source code for the specified
function in a buffer.


FILE EVALUATION AND COMPILATION COMMANDS:

compile-file
    Prompt for the name of a Lisp FILE and compile it.

load-file
    Prompt for the name of a Lisp FILE and load it in the current
buffer.

load-compile-file
    Prompt for the name of a Lisp FILE, compile it, and load it in the
current buffer.  A numeric argument will compile the file even if the compiled
version is up-to-date.


EVALUATION AND COMPILATION COMMANDS (LISP AND EMACS LISP ONLY):

evaluate-buffer
    Evaluate the current buffer by parsing all text in the buffer as one
or more Lisp expressions and evaluating them one at a time.

        An ARG of 0 causes the command to query before evaluating the buffer.
All other values of ARG prevent querying and pass the value to the
evaluate-common-lisp function.

        The command is defined in Lisp and Emacs-Lisp modes only.

compile-buffer
    Compile the contents of the current buffer.

        An ARG of 0 causes the command to query before compiling the contents
of the buffer.  All other values of ARG prevent querying and pass the value to
the evaluate-common-lisp function.

        The command is defined in Lisp and Emacs-Lisp modes only.

apollo:evaluate-last-sexp
    Key Binding:    Lisp-Mode [Control-x Control-e]
    Key Binding:    Emacs-Lisp-Mode [Control-x Control-e]
    Key Binding:    Inferior-Lisp-Mode [Control-x Control-e]
    If Common Lisp, send the last s-expression (that is, the one to the
left of point) to the Lisp process invoked by the M-x lisp command for
evaluation.

        If Emacs-Lisp mode, evaluate the last s-expression in Emacs Lisp.

        An ARG of 0 causes the command to query before evaluating the
s-expression.  All other values of ARG prevent querying and pass the value to
the evaluate-common-lisp function.

        The command is defined in Lisp and Emacs-Lisp modes only.

apollo:lisp-send-defun
    Key Binding:    Lisp-Mode [Meta-Control-x]
    Key Binding:    Emacs-Lisp-Mode [Meta-Control-x]
    Key Binding:    Inferior-Lisp-Mode [Meta-Control-x]
    If Common Lisp mode, send the current definition (that is, the top-level
form containing point) to the Lisp process invoked by the M-x lisp command for
evaluation.

        If Emacs-Lisp mode, evaluate the current definition in Emacs Lisp.

        An ARG of 0 causes the command to query before evaluating the
definition.  All other values of ARG prevent querying and pass the value to the
evaluate-common-lisp function.

        The command is defined in Lisp and Emacs-Lisp modes only.

apollo:lisp-compile-defun
    Key Binding:    Lisp-Mode [Meta-Control-c]
    Key Binding:    Emacs-Lisp-Mode [Meta-Control-c]
    Key Binding:    Inferior-Lisp-Mode [Meta-Control-c]
    Send the current defun macro to the Lisp process invoked by the M-x
lisp command for compilation.

        An ARG of 0 causes the command to query before compiling the macro.
All other values of ARG prevent querying and pass the value to the
evaluate-common-lisp function.

        The command is defined in Lisp and Emacs-Lisp modes only.

evaluate-region
    Key Binding:    Lisp-Mode [Control-c x]
    Key Binding:    Emacs-Lisp-Mode [Control-c x]
    Key Binding:    Inferior-Lisp-Mode [Control-c x]
    Key Binding:    Shell-Mode [Control-c x]
    Evaluate the marked region in the current buffer.  The command parses
all text in the region as one or more Lisp expressions and evaluates them one at
a time.

        An ARG of 0 causes the command to query before evaluating the region.
All other values of ARG prevent querying and pass the value to to the
evaluate-common-lisp function.

        The command is defined in Lisp and Emacs-Lisp modes only.

evaluate-region-hack
    Key Binding:    Lisp-Mode [Control-c Control-x]
    Key Binding:    Emacs-Lisp-Mode [Control-c Control-x]
    Key Binding:    Inferior-Lisp-Mode [Control-c Control-x]
    Key Binding:    Shell-Mode [Control-c Control-x]
    Evaluate the marked region in the current buffer using setq rather than
defvar.

        An ARG of 0 causes the command to query before evaluating the region.
All other values of ARG prevent querying and pass the value to the
evaluate-common-lisp function.

        The command is defined in Lisp and Emacs-Lisp modes only.

compile-region
    Compile the marked region in the current buffer.

        An ARG of 0 causes the command to query before compiling the region.
All other values of ARG prevent querying and pass the value to the
evaluate-common-lisp function.

        The command is defined in Lisp and Emacs-Lisp modes only.


COMMON LISP EVALUATION:

evaluate-common-lisp
    Key Binding:    Lisp-Mode [Control-c <Esc>]
    Key Binding:    Inferior-Lisp-Mode [Control-c <Esc>]
    Key Binding:    Shell-Mode [Control-c <Esc>]
    Evaluate a Common Lisp form.


        If ARG is

        nil     Evaluate the form

        1       (Default) Print the results of evaluation in the minibuffer

        2       Display results of evaluation in a buffer named *lisp-output*

        3       Bring up an inferior Lisp process and evaluate the form
there   

        4       Insert the result at point in the current buffer

        5       Replace the current form with the result of its evaluation

        If FORM is specified, evaluate it with an inferior Lisp process
initiated with M-x lisp.  Otherwise, prompt for the form.

evaluate-emacs-lisp
    Key Binding:    Emacs-Lisp-Mode [Control-c <Esc>]
    Evaluate an Emacs Lisp form.


        If ARG is

        nil     Evaluate the form

        1       (Default) Print the results of evaluation in the minibuffer

        2       Display results of evaluation in a buffer named *lisp-output*

        3       Bring up an inferior Lisp process and evaluate the form there

        4       Insert the result at point in the current buffer

        5       Replace the current form with the result of its evaluation

        If FORM is specified, evaluate it.  Otherwise, prompt for the form.

evaluate-and-replace-into-buffer
    Evaluate the current s-expression and replace it with the result.

evaluate-into-buffer
    Prompt for a FORM.  Evaluate the specified form and place the result
at point.


CHANGED DEFINITION COMMANDS (LANGUAGE INDEPENDENT):

list-modifications
    Use the UNIX diff command to list all modifications made to the
contents of the current buffer.


        If ARG is

        0       Display the results of the last call to this command

        1       (Default) List the modifications made since Emacs read the

                file into the buffer

        2       List the modifications made since Emacs last read the file

                into the buffer or saved the file

        All changed-definitions commands call this command.

apollo:list-modifications-dynamic-mouse
    Find and display source of modifications at point.
       This is designed to be used by list modification commands
       to let clicking right on the mouse, find the modification.

edit-next-definition
    Key Binding:    Lisp-Mode [Control-c .]
    Key Binding:    Emacs-Lisp-Mode [Control-c .]
    Key Binding:    Inferior-Lisp-Mode [Control-c .]
    Key Binding:    Shell-Mode [Control-c .]
    Load the source code for the next definition on a list of definitions
into an edit buffer.

        To operate, this command requires lists generated by other commands
such as M-. and M-x edit-changed-definitions.


CHANGED DEFINITION COMMANDS  (LISP AND EMACS LISP ONLY):

apollo:reset-original
    Resets what the editor treats as the original source of a file to the
       current source in the buffer. This impacts further use of any 
       changed definitions command.  Use this command with care!
       With an ARG specified, all buffers of of the lisp type of the
       current-buffer will be reset.

list-buffer-changed-definitions
    In a separate window, list the names of the changed definitions
located in the current buffer.  If the M2 mouse button clicks on a definition in
the list, load the source code of that definition into an edit buffer.

        If ARG is

        0       Use the definitions from the last changed-definition

                command

        1       Use the changes made since Emacs read the file into the

                current buffer

        2       Use the changes made since Emacs read the file into the

                buffer or saved the buffer's contents

        3       (Default) Use the changes made since compiling or evaluat-

                ing the definitions or, if never compiled or evaluated, since

                reading the file into the current buffer


        The command is defined in Lisp and Emacs-Lisp modes only.

evaluate-buffer-changed-definitions
    Evaluate all changed definitions in the current buffer.

        If ARG is

        0       Use the definitions from the last change-definition command

        1       Use the changes made since Emacs read the file into the

                current buffer

        2       Use the changes made since Emacs read the file into the

                buffer or saved the buffer's contents

        3       (Default) Use the changes made since evaluating the defini-

                tions or, if never evaluated, since reading the file into the

                current buffer


        The command is defined in Lisp and Emacs-Lisp modes only.

compile-buffer-changed-definitions
    Compile all changed definitions in the current buffer.

        If ARG is

        0       Use the definitions from the last change-definition command

        1       Use the changes made since Emacs read the file into the

                current buffer

        2       Use the changes made since Emacs read the file into the

                buffer or saved the buffer's contents

        3       (Default) Use the changes made since compiling the defini

                tions or, if never compiled, since reading the file into the

                current buffer


        The command is defined in Lisp and Emacs-Lisp modes only.

edit-buffer-changed-definitions
    Edit all changed definitions in the current buffer.

        If ARG is

        0       Use the definitions from the last change-definition command

        1       Use the changes made since Emacs read the file into the

                current buffer

        2       Use the changes made since Emacs read the file into the

                buffer or saved the buffer's contents

        3       (Default) Use the changes made since compiling or evaluat-

                ing the definitions or, if never compiled or evaluated, since

                reading the file into the current buffer


        The command is defined in Lisp and Emacs-Lisp modes only.

list-changed-definitions
    List all changed definitions in all buffers of the current Lisp type
(Common Lisp or Emacs Lisp).

        If ARG is

        1       Use the changes made since Emacs read the file(s) into the

                buffer(s)

        2       Use the changes made since Emacs read the file(s) into the

                buffer(s) or saved the buffers' contents

        3       (Default) Use the changes made since compiling or evaluat-

                ing the definitions or, if never compiled or evaluated, since

                reading the file(s) into the buffer(s)


        The command is defined in Lisp and Emacs-Lisp modes only.

evaluate-changed-definitions
    Evaluate all changed definitions in all buffers of the current Lisp
type (Common Lisp or Emacs Lisp).

        If ARG is

        1       Use the changes made since Emacs read the file(s) into the

                buffer(s)

        2       Use the changes made since Emacs read the file(s) into the

                buffer(s) or saved the buffers' contents

        3       (Default) Use the changes made since evaluating the defini-

                tions or, if never evaluated, since reading the file(s) into the

                buffer(s)


        The command is defined in Lisp and Emacs-Lisp modes only.

compile-changed-definitions
    Compile all changed definitions in all buffers of the current Lisp
type.

        If ARG is

        1       Use the changes made since Emacs read the file(s) into the

                buffer(s)

        2       Use the changes made since Emacs read the file(s) into the

                buffer(s) or saved the buffers' contents

        3       (Default) Use the changes made since compiling the defini-

                tions or, if never compiled, since reading the file(s) into the

                buffer(s)


        The command is defined in Lisp and Emacs-Lisp modes only.

edit-changed-definitions
    Edit all changed definitions in all buffers of the current Lisp type

(Common Lisp or Emacs Lisp).

        If ARG is

        1       Use the changes made since Emacs read the file(s) into the

                buffer(s)

        2       Use the changes made since Emacs read the file(s) into the

                buffer(s) or saved the buffers' contents

        3       (Default) Use the changes made since compiling or evaluat-

                ing the definitions or, if never compiled or evaluated, since

                reading the file(s) into the buffer(s)


        The command is defined in Lisp and Emacs-Lisp modes only.


CALLERS COMMANDS:

edit-callers
    Key Binding:    Lisp-Mode [Control-c Control-e]
    Key Binding:    Inferior-Lisp-Mode [Control-c Control-e]
    Key Binding:    Shell-Mode [Control-c Control-e]
    Prompt for a Common Lisp symbol name and edit its callers.  If no
argument is specified, look in the current package.


        If ARG is

        4 or C-u        Look in all packages

        16 or C-u C-u   Prompt user for package name

next-caller
    Key Binding:    Lisp-Mode [Control-c n]
    Key Binding:    Emacs-Lisp-Mode [Control-c n]
    Key Binding:    Inferior-Lisp-Mode [Control-c n]
    Key Binding:    Shell-Mode [Control-c n]
    Load the source code for the next caller on a list of definitions
into an edit buffer.


        Commands such as M-x edit-callers sometimes generate lists of
definitions.

list-callers
    Prompt for a Common Lisp symbol name and list its callers.  If no
argument is specified, look in the current package.


        If ARG is

        4 or C-u        Look in all packages

        16 or C-u C-u   Prompt user for package name

who-calls
    (This is another name for the list-callers command.)


DESCRIPTION COMMANDS:

disassemble-lisp-code
    Print disassembled code for OBJECT on optional STREAM.  If necessary,
compile OBJECT if necessary but do not redefine.  For Common Lisp functions,
take the output of (disassemble #'object) and display it in a buffer.

        The OBJECT can be a function name, lambda expression, or any function
object returned by the symbol-function function.

quick-arglist
    Key Binding:    Lisp-Mode [Control-c Control-a]
    Key Binding:    Emacs-Lisp-Mode [Control-c Control-a]
    Key Binding:    Inferior-Lisp-Mode [Control-c Control-a]
    Key Binding:    Shell-Mode [Control-c Control-a]
    Query Common Lisp and display the argument list of the function at
point.  If ARG is not specified, direct the output into a temporary buffer.

macro-expand-last-sexp
    Key Binding:    Lisp-Mode [Control-c Control-m]
    Key Binding:    Emacs-Lisp-Mode [Control-c Control-m]
    Key Binding:    Inferior-Lisp-Mode [Control-c Control-m]
    Key Binding:    Shell-Mode [Control-c Control-m]
    Expand the last s-expression.  If there is no argument, or the
argument is nil, expand all levels of the definitions in the s-expression, and
place the expansion in the temp buffer.  If the argument is 1, expand only the
uppermost level of the last s-expression, and place the expansion in the temp
buffer.

        If the argument is 4, or C-u, the expansion is the same as with a nil
argument, except that the expansion is done in place, in the current buffer
instead of in a temp buffer.  With an argument of 16, or C-u C-u, only the
uppermost level of the macro expansion is substituted in place.

        If Common Lisp, send the s-expression to the Lisp process invoked with
the M-x lisp command.

        If Emacs Lisp, expand the s-expression without sending it to another
Lisp process.

macro-expand-expression
    Key Binding:    Lisp-Mode [Control-c m]
    Key Binding:    Emacs-Lisp-Mode [Control-c m]
    Key Binding:    Inferior-Lisp-Mode [Control-c m]
    Key Binding:    Shell-Mode [Control-c m]
    Expand the current Lisp definition into a temporary buffer. If there
is no argument, or the argument is nil, expand all levels of the definitions in
the s-expression, and place the expansion in the temp buffer.  If the argument
is 1, expand only the uppermost level of the last s-expression, and place the
expansion in the temp buffer.

        If the argument is 4, or C-u, the expansion is the same as with a nil
argument, except that the expansion is done in place, in the current buffer
instead of in a temp buffer.  With an argument of 16, or C-u C-u, only the
uppermost level of the macro expansion is substituted in place.

        This command works with Emacs Lisp and Common Lisp.

where-is-symbol
    Key Binding:    Lisp-Mode [Control-c w]
    Key Binding:    Inferior-Lisp-Mode [Control-c w]
    Key Binding:    Shell-Mode [Control-c w]
    Optional SYMBOL may be a Common Lisp symbol name.  If SYMBOL is nil,
prompt for a Common Lisp symbol name.  List all packages containing the symbol.

apollo:describe-variable-at-point-dynamic-mouse
    Describe Variable Under Mouse.

describe-variable-at-point
    Key Binding:    Lisp-Mode [Control-c v]
    Key Binding:    Inferior-Lisp-Mode [Control-c v]
    Key Binding:    Shell-Mode [Control-c v]
    Use the Common Lisp describe function to exhibit the value,
definition, and properties of the specified symbol and direct the output to a
buffer.  The optional VARIABLE specifies a Common Lisp symbol.  If VARIABLE is
nil, prompt for the symbol.

describe-function-at-point
    Key Binding:    Lisp-Mode [Control-c f]
    Key Binding:    Inferior-Lisp-Mode [Control-c f]
    Key Binding:    Shell-Mode [Control-c f]
    Use the Common Lisp describe function to exhibit the value,
definition, and properties of FUNCTION and direct the output to the current
buffer.

        If FUNCTION is a numeric argument, take the function at the beginning
of the current s-expression as the default and prompt the user.

        If FUNCTION is neither numeric nor nil, then use it as the function
name for describe.  (There's no prompt with this argument.)

        If FUNCTION is nil or not specified, take the symbol at point as the
default and prompt the user.

show-lisp-documentation
    Key Binding:    Lisp-Mode [Control-c d]
    Key Binding:    Inferior-Lisp-Mode [Control-c d]
    Key Binding:    Shell-Mode [Control-c d]
    Query Common Lisp and display documentation for OBJECT at point in a
temporary buffer.

apropos-symbol-at-point
    Use the Common Lisp apropos function to search the package of the
specified variable.  Locate all variables that contain the specified name in
their print names and direct the output to a buffer.

        If VARIABLE is a numeric argument, take the variable at the beginning
of the current s-expression as the default and prompt the user.

        If VARIABLE is neither numeric nor nil, then use it as the name of the
variable for apropos.  (There's no prompt with this argument.)

        If VARIABLE is nil or not specified, take the variable at point as the
default and prompt the user.

what-package
    Print the name of the current package to the minibuffer.


SHELL COMMANDS:

csh
    Start an inferior shell process (default csh).
With numeric ARG
  Create a new shell buffer running shell.
Without numeric ARG
  if shell buffer exists, switch to that buffer
  Otherwise create new shell buffer.
SHELL-NAME is string to use as root name of shell buffer. (default "csh")
SHELL-PROGRAM is string for path to shell program (default "/bin/csh")

sh
    Start an inferior sh shell.
With numeric ARG
  Create a new shell buffer running shell.
Without numeric ARG
  if shell buffer exists, switch to that buffer
  Otherwise create new shell buffer.
On apollo this will start an aegis /com/sh.
On other unix platforms, this will start a /bin/sh


INFERIOR LISP COMMANDS:

run-lisp
    Key Binding:    Lisp-Mode [Control-c Control-l]
    Run an inferior Lisp process in the current buffer.

lisp
    Run the Lisp program specified by the variable inferior-lisp-program
in an inferior Common Lisp process.  If an inferior Lisp process already exists,
and no ARG is given, simply switch to that buffer.  If an ARG is given, create a
new process without regard to whether one exists or not.

apollo:break
    Key Binding:    Inferior-Lisp-Mode [Control-c Control-c]
    Key Binding:    Shell-Mode [Control-c Control-c]
    Interrupt the process owned by the current buffer.

reset-lisp-filter
    Reset an inferior Lisp process but do not return to Lisp's top-level
loop.  (This command regains control when the process fails to respond and
begins to lose Lisp input/output.)


YANK HISTORY COMMANDS:

apollo:yank
    Key Binding:    Global [Control-y ]
    Reinsert the text of the most recent kill (or yank) with mark at the
front and point at the end of the text.


        If ARG is

                0               Display the kill history in a buffer

                n               With numeric argument n, reinsert the text of

                                the nth most recent kill

                C-u     Put point at front and mark at end of rein-

                                serted text

        The following are optional arguments:

        YANK-TYPE       This is a symbol whose name is the yank com

                                mand being performed

        POP                     This is a symbol with a non-nil value if re-

                                peating the yank command for previous items

                                in the kill history

        PATTERN         This is a string specifying the prefix criteria for

                                a match (see yank-prefix-command)

yank-prev-command
    Key Binding:    Global [Meta-Control-y]
    Yank the previous command.


        If ARG is

                0               Display the command history in a buffer

                n               With numeric argument n, retrieve the nth

                                most recent shell command (default = 1).

        Optional arguments are:

                POP     If POP has a non-nil value, replace the previ-

                                ously yanked command with the next most

                                recent one (see apollo:yank-pop)

                PATTERN This is a string specifying the prefix criteria for

                                a match (see yank-prefix-command)


        If the current buffer is in Common-Lisp mode and an inferior lisp
is running, the command yanks strings from the input command history of the
inferior lisp buffer.

yank-prefix-command
    Key Binding:    Global [Meta-Control-p]
    Invoke yank-prev-command and use the current line as a pattern; in
other words, yank commands that match the current command.


        If ARG is n, retrieve the nth matching command.

        If POP has a non-nil value, replace the previously yanked command with
the next most recent one (see apollo:yank-pop).

apollo:yank-pop
    Key Binding:    Global [Meta-p]
    Replace the text of the most recently yanked kill with the specified
text.  If nothing is specified, reinsert the text displaced by the yanked text.

        This command must execute immediately after a yank, apollo:yank,
yank-prev-command, yank-prefix-command, or apollo:yank-pop command; otherwise,
the command performs a yank-prev-command.  Immediately after one of these yank
commands, a marked region exists containing the text of a reinserted kill; the
apollo:yank-pop command deletes the text in the marked region and reinserts an
earlier kill.  Note that the newest kill comes after the oldest kill in the kill
ring.


        If ARG is

        n               With the positive numeric argument n, insert the text of

                        the nth previous kill

        -n              With the negative numeric argument n, insert the nth more

                        recent kill

apollo:yank-pop-negative
    Key Binding:    Global [Meta-n]
    Call apollo:yank-pop with ARG of -n.


COMPLETION COMMANDS:

apollo:shell-complete-symbol
    Key Binding:    Shell-Mode [Meta-Control-i]
    Use the command string in apollo:find-files-shell-command to complete
the shell command located in the buffer whose process name begins with
"shell."

        In a UNIX shell, complete the partial command by comparing it with the
command names in the directories given by the shell variable path.  In an Aegis
shell, complete the partial command by comparing it with the command names in
the directories given by the csr command.

        With an ARG, GNU Emacs searches for a command that contains the string
to be completed anywhere.  Without an ARG, GNU Emacs searches only for commands
that begin with the typed string.

apollo:lisp-complete-symbol
    Key Binding:    Lisp-Mode [Meta-Control-i]
    Key Binding:    Inferior-Lisp-Mode [Meta-Control-i]
    Complete the partially typed Lisp symbol preceding point.

        If the incomplete symbol immediately follows an open parenthesis,
consider only existing symbols with function definitions.  Otherwise, consider
all existing symbols regardless of function definitions, values, or properties.

        If the buffer is in Lisp or Inferior-Lisp mode, query the Common Lisp
process for completion using the apropos command.

        Use a package name preceding the incomplete symbol name as the package
name for Common Lisp symbols.  If no preceding package name exists, search
backwards in the current buffer for "in-package" at the beginning of a line.
If the search fails, use the package name from the buffer's mode line.

        With ARG, a match can occur anywhere within the symbol's name.  Without
ARG, a match can occur only at the beginning of the name of an existing symbol.

        When calling from Emacs Lisp, you can substitute an optional SYMBOL for
the one at point.


DOCUMENT PROCESSING AND PRINT COMMANDS:

delete-all-font-info
    Remove all font information (such as lisp-machine font control
characters) from the current buffer.

fix-man-output
    Adjust the output from the UNIX man command to improve readability.
The man command must be the last command executed.

insert-date
    Insert the current date and time at point in UNIX format (for
example, "Thu Dec 8 00:29:46 EST 1988").

pagify-lisp-buffer
    Insert a formfeed into the current buffer at line intervals
specified by the configuration variable apollo:page-size.  If ARG is specified
as the numeric argument n, place the formfeeds at line intervals of n.  Remove
lines consisting only of formfeeds.

        Create a new page wherever the characters ";;;" appear at the
beginning of a line.  However, when the characters ";;;" appear at the
beginning of subsequent and consecutive lines, then paginate according to the
prevailing page size.

print-buffer-apollo
    Send the contents of the current buffer to the last printer used or
as specified by ARG.


        If ARG is

        1       Prompt for the printer's name and change the default printer

                accordingly

        2       Print the document in 2-column format on the default

                printer

        Pass the arguments, if any, in the variable apollo:printer-args to the
printer.  Use the default printer specified in the variable
apollo:default-printer.

print-region-apollo
    If ARG is not specified or is nil, send the text in the marked
region to the last printer used.

        If ARG is

        1       Prompt for the printer's name and change the default

                printer accordingly

        2       Print the document in 2-column format on the default

                printer

        Pass the arguments, if any, in the variable apollo:printer-args to the
printer.  Use the default printer specified in the variable
apollo:default-printer.


MISCELLANEOUS COMMANDS:

list-notifications
    Display a buffer containing all messages from the error and message
functions.  If ARG is the numeric argument n, redisplay the first line of the
nth message and set apollo:last-notification to that string.

apollo:redisplay-function
    Key Binding:    Global [Meta-Control-r]
    Move the beginning of the current definition to the top of the
window.

apollo:switch-to-buffer
    Key Binding:    Global [Control-x b]
    Select BUFFER (or its name) for display in the current window.  If
the value of the optional argument NORECORD is non-nil, do not put this buffer
at the front of the list of recently selected buffers.


NOTE:   Use set-buffer to temporarily work on another buffer within a
Lisp program.  Using the apollo:switch-to-buffer command can disrupt
window/buffer correspondence.


        If no BUFFER is nil, the default action is to switch to the other
buffer designated by other-buffer.

        If ARG is

        0       Display a buffer list

        1       Put the name of the current buffer at the bottom of the

                buffer list

        n       With other numeric argument n, switch to the nth buffer in

                the history

        Because the argument 0 does not complete the buffer name upon return,
it's useful for creating new buffers with names that partially match the names
of existing buffers.

        If no argument, or an argument other than 0, is specified, try to
switch to existing buffers.  Prompt for the name of the buffer to select.  If a
partial buffer name is specified and it matches only one buffer, then select
that buffer.  If a partial buffer name is specified and it matches multiple
buffer names, then display a completion menu of the buffer names, or create a
buffer with the partial name when <RETURN> is pressed.

        If creating a Common-Lisp or Emacs-Lisp buffer (.lisp or .el
extension), prompt for an attribute list for the file.

        With C-y command, bring the default buffer name temporarily inserted
into the kill ring onto the prompt line.

grep-to-temp-buffer
    Prompt for the Emacs regular expression regexp and copy any matching
lines to a temporary buffer.

apollo:beginning-of-line
    Key Binding:    Inferior-Lisp-Mode [Control-a ]
    Key Binding:    Shell-Mode [Control-a ]
    Go to the beginning-of-line.  If used in an inferior Lisp or shell
process, this command goes to the prompt if the line starts with a prompt
instead of the beginning-of-line.

apollo:mouse-insert-thing
    Key Binding:    Global [Meta-<Mouse Middle Down>]
    Take the s-expression under the mouse cursor and insert it at point.
If the mouse is between two s-expressions, the one on the left of point always
prevails over one to the right.

apollo:mouse-move-mark
    Key Binding:    Global [<Mouse Left Up>]
    Pressing M-<M1> (holding the Meta key down while pressing the left
mouse button) sets a mark; releasing the button sets point.  In this way, you
can use the mouse to mark the beginning of a region and set point at the
region's end.

apollo:grab-thing-dynamic-mouse
    Insert completion at point.
       This is designed to be used by some completion commands
       to let clicking right on the mouse, grab the completion.
       If pointing is at end of thing to be completed, the partial
       string will be replaced with the full completion clicked on.

