Power-Programmierung/CD1.mdf/mutt/me.doc

Text File | 1988-10-24 | 35KB | 742 lines

========================================================================
==        ME Documentation          Craig Durland  8/88 ==
========================================================================

  ME is a small, portable, extendable Emacs like editor.  This document
describes how individual commands work - it is light on general usage.
If you need to learn Emacs, look at the GNU, Goslings or Unipress Emacs
manuals.

DOC FILE        What it covers
--------        ------------------------------------------
CMDS.DOC        Keys and what they are bound to.
ME.DOC (this file)    ME built in commands.
MEMUTT.DOC        The ME extensions to Mutt and ME system variables.
MUTT.DOC        The Mutt programming language and Mutt compiler.
ERRATA.DOC        Errata, machine specifics and philosophy.
REGEXP.DOC        Regular expressions.

========================================================================
==        What ME does NOT have that Emacs does                       ==
========================================================================
* Undo
* File name completion
* Command history (mini buffer editing)
* Multiple key macros, named macros, macros bound to keys
* Recursive editing
* Local syntax tables
a few others

========================================================================
==        Soft keys and Function keys                           ==
========================================================================

  When describing characters or keys, the character itself is used if it
is printable.  Unprintable characters are made printable using 3 or more
printable characters.  For example, the letter "A" is printable but
control-A is not and so the code "C-A" is used to describe it.  The
table below shows the various codes needed to map the unprintable keys.

Prefix    Meaning
  C-    Control key.
  F-    Function or soft key such as f1, Home, etc.
  M-    Meta key.  See META in the GLOSSARY.
  S-    Shift.  This only applies to function keys.

   This is a list of  "extended"  keys - those not covered by ASCII.  ME
maps  these keys to 3 or more  ASCII  codes.  Ignore  the ME key  column
unless  you are  binding  keys.  The  keyboard  column is the key on the
keyboard you press to generate the ME key which (unless  rebound)  fires
off the function listed in the Bound to column.

keyboard      ME key    Bound to
   F1        F-1
   F2        F-2
   F3        F-3
   F4        F-4
   F5        F-5
   F6        F-6
   F7        F-7
   F8        F-8
   F9        F-9
   F10        F-0
  home        F-A    (beginning-of-buffer)
  end        F-B    (end-of-buffer)
  up arrow    F-C    (previous-line)
  down arrow    F-D    (next-line)
  right arrow   F-E    (next-character)
  left arrow    F-F    (previous-character)
  insert    F-G
  delete    F-H    (delete-character)
  page up    F-I    (previous-page)
  page down    F-J    (next-page)
  clear line    F-K    (kill-line)
  delete line    F-L
  insert line    F-M
  select    F-N    (set-mark)
  roll up     F-O    (scroll-down)
  roll down     F-P    (scroll-up)
  DEL        ^?    (delete-character)
  ESC        ^[
  shift tab    M-I

  ALT 0..9A..Z!    mapped to META 0..9A..Z!
  Use the ALT key like the control key (ie hold it down while you press the
    next key).

========================================================================
========================================================================

Anytime you are being queried on the message line the softkeys return
their internal value.  So if you want to bind F1, you can press F1
when bind-to-key asks for a key.

Case of letters:
  Meta keys and Control X commands: next letter is ALWAYS uppercase.
  Softkeys are case sensitive.

========================================================================
==            GLOSSARY                      ==
========================================================================
^[  See META
args
  Parameters or arguments that will be requested by the command.  If
   [] surround the arg, then it will only be requested in certain cases.
binding    See bound.
bound
  A key is attached or bound to a command or program.
  If the key is pressed, whatever it is bound to is invoked.
  Keys can be bound locally or globally.  If a key has a local  binding,
    pressing  the key in the  buffer  it was bound in causes  action.  A
    global  binding  covers all buffers.  Note that local  bindings take
    precedence over global ones.
buffer
  A buffer is the  internal  workspace.  If a buffer is  visible,  it is
    shown through one or more windows.  It is usually attached to a file
    (ie  contains  the contents of the file).  If the buffer was created
    by reading in a file, the  buffer  name is created by  removing  the
    path from the file name (and leaving only the name and extension).
command or cmd
  A ME built in command such as (search-forward).
  These can be bound to a key to make executing them easier.
  Documented  under  COMMANDS  (in  ME.DOC).  These are  different  from
    functions  in  that  they  can be  bound  to  keys  or  executed  by
    (ME-command).
Command  completion
  ME will  attempt to complete a command if the space bar is pressed and
    completion is on.  The only time you can use command  completion  is
    when you are being queried in the  minibuffer.  For example, when ME
    is requesting a buffer name for  (use-existing-buffer) and foobar is
    a buffer,  typing  "foo" and hitting  space will fill in the rest of
    the name.  ME also trys to fix typos.  If you had typed  "fooie" and
    hit the space bar, you still get "foobar".  Sometimes,  you will hit
    space and only part of the command  name will  appear.  This is ME's
    way of  telling  you there is some  ambiguity  as to the full  name.
    Type some more of the name and hit space  again or press ?  to get a
    list of possible names.
  See also: complete in MEMUTT.DOC.
dot
  The place between two  characters.  It is  immediately  to the left of
    the cursor.  Also known as point.  One per window or buffer.
ESCAPE  See META
  The escape key (usally marked ESC on keyboards) acts like the META key
    for those keyboards that don't have a META key.
file
   For MS-DOS, you can use forward slashes "/" as part of the path name.
function or fcn
  The commands that comprise the Mutt programming  language.  Documented
    in MUTT.DOC and MEMUTT.DOC.  These differ from commands in that they
    cannot be bound to keys and cannot be executed by (ME-command).
help
   Help is pretty much limited to reading manuals or asking gurus.
   Limited  forms of online help are  command  completion  (see  above),
     typing a ?  when  being  asked a  question  (see "If you are  being
     asked a question" below) and (describe-bindings).
keys
  Keys are used to enter text and invoke commands.  The keys used to
    invoke can be one or two keys where each key can have one or more
    modifiers.
    modifier meaning    notes
       M-    META    See META and ESCAPE.  Cannot be prefixed.
       C-    CONTROL
       S-    SHIFT    Only used with nonASCII keys
       F-    FUNCTION    NonASCII keys
  See also: prefix-key in MEMUTT.DOC
Kill buffer
  An invisible buffer that holds things created by deletion commands
    such as (kill-region) and (copy-region).  Used to cut and paste, or
    just cut, text.
  If you want to move a block of text about: 1. set the mark at one end
    and then move the dot to the other end.  2. kill the region. 3. move
    the dot to the start of where you want the text to begin and 4. yank
    the kill buffer.  Bingo.
  Copy and kill append to the kill buffer if last command was also a
    kill or copy, otherwise the kill buffer is cleared before the new text
    is entered.
  The killbuffer is also used by (filter-region).
macro
  A sequence of  keystrokes  that can be replayed on command.  Used when
    you don't  want to spend  the time  writing a  program.  Created  by
    going through the motions (which are actually done so you can verify
    that  what  you  want  to  happen  is   actually   happening)   (see
    (start-macro)  and (end-macro)).  When replayed by  (execute-macro),
    the exact sequence you typed in is reentered.
mark
  A user settable dot.  Ten per buffer.
  Unless stated otherwise, "the mark" refers to mark 0.
  A mark is  remembered  for the life of the buffer and stays  where you
    set it until  you or ME moves it.  (exchange-dot-and-mark)  will get
    you to the mark from anywhere in the buffer.
  If the dot is at a mark and you do something  (like  insert text, yank
    text, etc), it is done  between  the dot and mark, that is, the mark
    is before the change and the dot after.
  Advanced  note:  The marks are  associated  with a buffer NOT with the
    windows  attached  to the buffer.  Thus all  windows  attached  to a
    buffer have the same marks.
ME
  The Mutt Editor.  An editor that is extendable using the Mutt
    programming langauge.
message line or
minibuffer
  The bottom line of the screen.  This is the place where all  questions
    are asked, error messages sent, etc.
META key
  This is a modifier key that works like the control key.  Your keyboard
    may or may not have  one.  On IBM PCs, this is the ALT key.  To use,
    hold  down the META key and  press  the key you want to  modify.  If
    your  keyboard does not have a META key, use ESCAPE  instead - press
    the ESCAPE key, let it up and then press the key you want to modify.
  In the ME documents, the META key will be refered to by M-x where x is
    the key being modified.
Mutt
  The built in programming language.  Refer to the Mutt documentation in
    MUTT.DOC and MEMUTT.DOC.
n nth
  Argument prefix (set by  (universal-argument)).  This means repeat the
    key   (or   what   its   bound   to)   or   command   n   times.  If
    (universal-argument) is not used then n defaults to 1.
pgm    See program.
point    See dot.
program
  A program created by (defun).
  These are created by the user to make its editing easier.
  See MUTT.DOC and MEMUTT.DOC.
region
  The area between dot and mark.
syntax tables are used to determine word boundaries, etc.  All commands
   work with words use these tables (eg (next-word) and
   (re-search-forward)).  Use (modify-syntax-entry) to change what it means
   to be a word.
sysvar or system variable
   These are a collection of user changable variables that effect the way
     ME does certain things.
   Documented in MEMUTT.DOC.
window
  A portion of the screen.  A window provides a view of a buffer.  There
    can be more than one window showing a buffer.  Windows are separated
    from each by a mode line.  Mode lines look like:
    -* ME -- buffer_name -- file_name -------------------------------
    The  * is  present  only  if  the  buffer  has  been  modified.  The
    file_name is present only if a file is associated with the buffer.
word
  A string of letters, digits, "$", "'" or "_".  By modifying the syntax
    tables, you can change the definition of a word.
  See syntax tables, (modify-syntax-entry).
Word wrap
  When you are typing at the end of a line and cross the fill column the
    last  "word" is  wrapped  to the next  line.  If you have some  left
    margin  you  wish  to  preserve,   bind  CR  to   newline-and-indent
    (bind-to-key "newline-and-indent" "C-M").
  Setting the system var  word-wrap  to 0 turns it off,  setting it to n
    causes wrapping to occur at column n.

========================================================================
==        If you are being asked a question              ==
========================================================================
Key bindings are not in effect.  This means if a normal key has been bound
  to something wrong by accident, you can unbind it without undo grief.
"Special" keys:
    ^H, DEL or backspace    Delete character left of the cursor.
    ^G    Abort out of the question.  Also causes the command to be aborted.
    ^I    Tab.
    ^J    Returns the code for newline.  Handy for searches. Same as ^Q^M.
    ^L  Redraw the screen.  Handy if you messed it up with help and want
    to see the original contents.
    ^M or return (enter)    End the question and return your answer.
    ^Q    Quote the next character.
    ^U    Erase everything and start over.
     ?  Show help (if available).  This shows the possible responses
    for this command.  This is available whenever command
    completion is.
    Control keys in general return the code for the key.
    Function keys return the function key itself, NOT what its bound to.

  If you answer the question by hitting <return or enter> and the line is
    empty, you have entered the null line zone.  This can be interpreted as:
    1.  An empty line.  It will then be ignored or complained about or
      stop the command.
    2.  A ^M.  (bind-to-key) does this.
    3.  A request to use the default.  This is usually the current
      thing being manipulated (where thing is buffer, file, etc).
      eg (write-file) defaults to current file name and (kill-buffer)
      defaults to current buffer name.

========================================================================
==            NOTES                          ==
========================================================================
In this  document, you will see command  names  surrounded by parens (eg
  (beginning-of-line)).  If the  command is bound, you can  execute  the
  command  by   pressing   the  keys  it  is  bound  to.  For   example,
  (beginning-of-line)  is bound to C-A, so holding  down the control  key
  and pressing A will move the cursor the the beginning of the line.  If
  the  command  is not bound (or you don't  remember  or want to use the
  binding),    you   can   also    execute    the   command   by   using
  (ME-command).

========================================================================
==            COMMANDS                      ==
========================================================================
COMMAND    name, default binding, args and comments
  These all return a BOOLEAN.
(abort)        C-G
  Back out of anything.
  If remembering a macro, forget it.
  If executing a program, stop it.
  This only works when ME is waiting for a key press (ie it won't halt
    pgms in a infinite loop or runaway pgms that aren't looking at the
    keyboard).
(apropos)    M-?    args: keyword
  List all commands and programs that have a keyword in them.  For example,
    if you apropos commands with "mark" in them you might get something like:
    PROGRAMS:
    mark-and-end               F-B
    mark-and-home              F-A
    COMMANDS:
    exchange-dot-and-mark      C-XC-X
    set-mark                   C-@ M-  F-N
    On the left is the command  name.  On the right are the key(s) bound
      to  the  command.  So,  in  this  case,  (set-mark)  is  bound  to
      control-@, meta-space and softkey-N.
  Command completion is on.
  See also: (describe-bindings).

(beginning-of-buffer)    M-<
  Move the dot to the top of the buffer.
  See also: (end-of-buffer).
(beginning-of-line)    C-A
  Move the dot to the start of the line.
  See also: (end-of-line).
(bind-local-key)    Not bound.    args: command name, keystroke(s)
  Same as (bind-to-key) but the binding is in effect only in the buffer it
    was bound in.
  Note that local bindings take precedence over global ones.
(bind-to-key)        Not bound.    args: command name, keystroke(s)
  Attach a key to a command or  program.  When ever the key is  pressed,
    the command or program will be executed  (except  when a question is
    being asked).
  Possible keys are single key strokes and combo keystrokes.
    Combo keys are prefixed keys, softkeys or modified keys.
  When asked for the key just press the key(s).
  If  programming,  use the keycode.  Keycodes  are ASCII (ie no control
    characters and such)  representations of a key.  For example, META-D
    is represented by the 3 characters  M-D,  control-C by ^C or C-C and
    function  key 1 (aka  soft key 1) by F-1.  Keycodes  should  be used
    when programming to avoid screwing up things like printers (when you
    print out the file).  eg (bind-to-key "foo" "F-1").
  To unbind a key, bind it to "".  (bind-to-key "" "F-1") will remove
    anything bound to F-1 and make F-1 self insert.
  Note: Always use uppercase for control keys if you use the ^ notation.
  Command completion is on.
  See also: (bind-local-key), (defun), keys (in the glossary above).

(case-region-lower)    C-XC-L
  Convert a region to lower case.
(case-region-upper)    C-XC-U
  Convert a region to upper case.
(case-word-capitalize)    M-C
  Capitalize word after dot.
  If dot is between words, searches forward to the start of the next word
    and capitalizes that one.
  If the dot is in the middle of a word, the letter after the dot is
    capitalized.
  See also: (modify-syntax-entry).
(case-word-lower)    M-L
  Convert word to lower case.
  See (case-word-capitalize) for edge conditions.
  See also: (modify-syntax-entry).
(case-word-upper)    M-U
  Convert word to upper case.
  See (case-word-capitalize) for edge conditions.
  See also: (modify-syntax-entry).
(copy-region)        M-W
  Copy a region to the kill buffer.  If the last command was
    a kill command, append to the kill buffer.  The region is unaffected.
  Returns TRUE if region copied, FALSE if no region, ABORT if the kill
    buffer runs out of space.
  See also: (kill-region), (yank).

(delete-character)        C-D or F-H (delete)
  Delete the character after the dot (visually under the cursor).  If at
    the end of the line, the next line is joined to the current line.  If
    given an argument, deleted characters are put into the kill buffer.
(delete-other-windows)    C-X1
  Make the current window the only window on the screen.
  See also: (split-window).
(delete-previous-character)    C-H or DEL
  Delete  the  character  before  the dot  (visually  to the left of the
    cursor).  If at the  beginning  of the  line,  the  current  line is
    joined  to the end of the  previous  line.  If  given  an  argument,
    deleted characters are put into the kill buffer.
(delete-previous-word)    M-DEL or M-C-H
  Delete the previous word.  Save them in the kill buffer.
  See also: (modify-syntax-entry).
(delete-word)        M-D
  Delete a word.  Save them in the kill buffer.
  See also: (modify-syntax-entry).
(describe-bindings)    Not bound
  List all commands and programs along with their key bindings in the same
    format as (apropos).
  See also: (apropos).

(end-macro)    C-X)
  Stop remembering keystrokes.  The keystrokes are stored in the macro
    buffer ready to be replayed by (execute-macro).
  See also: (execute-macro), (start-macro).
(end-of-buffer)    M->
  Move the dot to the bottom of the buffer.
  See also: (beginning-of-buffer).
(end-of-line)    C-E
  Move the dot to the end of the line.
  See also: (beginning-of-line).
(enlarge-window)    C-XZ
  Enlarge the current window by a line.
  See also: (shrink-window).
(erase-region)        Not bound
  Delete a region.  The region is NOT saved.
  See also: (kill-region).
(exchange-dot-and-mark)    C-XC-X
  Move the dot to the mark and set the mark to old dot value.  Visually,
    move to where the mark was set.  Repeating this command will undo it.
  With an argument, goes to the nth mark.
  See also: (set-mark).
(execute-macro)        C-XE
  Replay the keystrokes saved in the macro buffer.
  See also: (start-macro), (end-macro).
(exit)            C-C or C-XC-C    args: [yes or no]
  Exit ME.  If there is a modified buffer (one that has changed since it
    was last saved), you are asked about it.
  If n, quit no matter what and without making any noise.

(filter-region)        Not bound    args: filter name
  Take a region and feed it to a filter as standard input.
  Take the output of the filter and use it to replace the region.
  For example:  If the region is a paragraph and adjust is a program that
    formats text then (filter-region "adjust") will replace the paragraph
    with a formatted copy.
  If you don't want to remove anything, just make a null region (set the
    mark at the dot).  eg (set-mark)(filter-region "ls") will insert a
    directory listing at the dot.
  The region is put into the kill buffer so if the filter dies or screws
    up, just (yank) to restore the region.
  filter-region uses 2 files to hold the input and output of the filter.
    On UNIX, these are put in /tmp.  On other systems, they are put in
    the current directory.  You can change the directory with a
    environment variable.
      UNIX : TMP is used to hold the directory.  eg /v0/users/craig
        Note that ME adds a trailing "/" to the name.
      others : TMP is used.  eg in MS-DOS, if you have a RAM disk
        configured as drive D and want the files put in the root:
    SET TMP=D:\
    Note:  A trailing slash is required if you have a path in
    addition to the drive.

(goto-line)        M-G
  Goto the beginning of the nth line of the buffer.
  If an arg  prefix is  provided,  goto that  line.  Otherwise  the line
    number is prompted for.
  Line 0 and line 1 are both the first line.
  Returns: FALSE if n>number of lines in the buffer.

(insert-file)        C-XC-I    args: file name
  Insert a file into the buffer at the dot.  The file is unaffected.
  See also: (read-file), (visit-file), (write-file).

(kill-buffer)        C-XK    args: buffer name, [yes or no]
  Remove a buffer.  It disappears into ness-ness land.  Ask if the
    buffer has been modified.  If the buffer is on the screen, replace
    it with the (next-buffer).  If it is the only buffer, replace it
    with "*scratch*".
  Defaults to the current buffer.
  Buffer name completion is on.
  See also: (delete-other-windows).
(kill-line)        C-K or F-K (clear line)
  Delete text from dot to the end of the line.
    If an argument is given:
    If n = 0: kill from beginning of line to dot.
    If n > 0: kill forward over n newlines.
    If n < 0: error.
  The deleted text is put into the kill buffer or appended to the kill
    buffer if the last command was also a kill command.
  See also: (delete-word), (delete-previous-word), (kill-region),
    (yank).
(kill-region)        C-W
  Delete a region and save it in the kill buffer.  If the last command was
    a kill command, append to the kill buffer.
  See also: (copy-region), (erase-region), (kill-line),
    (yank).

(load)        Not bound    args: file name
  Load a Mutt executable file compiled with the Mutt compiler (MC).
  The file "init.mco" is loaded when ME is fired up (unless it does not
    exist).
  If the file is not in the current directory, it is looked
    for in ME directory (pointed to by the ME environment variable).  Note
    that the ME var must end with a slash (eg ME=A:/foo/).
  Notes:
    The extension MUST be ".mco" and is optional (ie you don't have to
      include it and if you do, I'll change it to ".mco").
    With an arg prefix (ie ^U) there is no error message if the file
      can't be found.
  Warning:  A pgm should NOT try to load it self or the file it is
    defined in (eg if foo is defined in bar.mut, foo should not try to
    (load "bar").  This is because the old bar is discarded (to make
    room for the new code) before foo finishes running (ie foo is thrown
    away).  Depending on the OS, this may work but your asking for
    trouble if you do it.
  See also: documents on Mutt programming (MUTT.DOC and MEMUTT.DOC).

(ME-command)    M-X    args: command or program name
  Execute a command or program.  ie one of the things listed in this
    document.  When asked what to Execute: use the name as listed here
    (without the "()"'s).  eg Execute: describe-bindings
  Command completion is in effect.

(newline)        C-M
  Insert a newline before the dot (visually before the cursor).
  See also: (newline-and-indent), (open-line).
(newline-and-indent)    C-J
  Insert a newline before the dot and duplicate the indentation of the
    previous line (the one the dot just left).
  Note:  if  tab-stops==0,  tabs  are  used  where  possible.  Otherwise
    only blanks are used.
  See also: (newline), (open-line).
(next-buffer)        Not bound
  Replace the current  buffer  with the next buffer in the buffer  list,
    skipping  the hidden  buffers.  The buffer  list is in  alphabetical
    order.  The buffer is  circular,  ie, the last buffer is followed by
    the first buffer.
  See also:  (list-buffers), (switch-to-buffer), (use-existing-buffer).
(next-character)    C-F or F-E (right arrow)
  Move right a character.
  See also: (previous-character).
(next-line)        C-N or F-D (down arrow)
  Move the dot vertically down the screen.  Trys to stay in the same
    column.
  Note:
    Don't use this in a pgm unless you want column tracking (for example
      binding an arrow key).  In most cases the column tracking gets in
      the way and will confuse your pgm.  Use forward-line instead.
      (see MEMUTT.DOC).
  See also: (forward-line), (previous-line).
(next-page)        C-V or F-J (page down)
  Scroll forwards a page (window size -2).
  See also: (previous-page).
(next-window)        C-XN
  Move to the next window down the screen and make it the current window.
  See also: (previous-window)
(next-word)        M-F
  Move forwards until dot is after the end of a word or end of buffer.
  See also: glossary, (previous-word), (delete-previous-word),
    (delete-word), (modify-syntax-entry).

(open-line)        C-O (oh, not zero)
  Insert a newline after the dot.  The dot does not move.
  See also: (newline), (newline-and-indent).

(previous-character)    C-B F-F (left arrow)
  Move the dot backwards by a character.
  See also: (next-character).
(previous-line)        C-P or F-C (up arrow)
  Move the dot vertically up the screen.  Tries to stay in the same
    column.
  Note:
    Don't use this in a pgm unless you want column tracking (for example
      binding an arrow key).  In most cases the column tracking gets in
      the way and will confuse your pgm.  Use forward-line instead.
      (see MEMUTT.DOC).
  See also: (forward-line), (next-line).
(previous-page)        M-V or F-I (page up)
  Scroll backwards a page (window size -2).
  See also: (next-page).
(previous-window)    C-XP
  Move to the window immediately above the current window and make it the
  current window.
  See also: (next-window).
(previous-word)        M-B
  Move backwards until dot is at the beginning of a word or beginning of
    buffer.
  See also: (delete-previous-word), (delete-word), (next-word),
    (modify-syntax-entry).

(query-replace)        M-Q    args: search string, replace string
  Interactively search and replace strings.
  If the replacements are successful, the cursor is left where the
    replace started and the mark is after the last replacement.
  If aborted, the cursor is left where the abort occurred and the mark is
    where the replace started.
  <ESC>,n,N : No, don't replace.  Go on to next match.
  <SPACE>,y,Y : Yes, replace and go to next match.
  ! : Replace all the rest without asking.
  ^G : Abort.  The command stops and the cursor is left where it is.  To
      get to the start of the query-replace, use (exchange-dot-and-mark).
  Patterns are saved across searches.  See (search-forward).
  If called from a pgm, the user is not prompted (unless told to).  This
    is the same as "!".
  See also: (search-xxx), (re-query-replace),
    (re-search-forward), case-fold-search (in MUTT.DOC)
(quote)            C-Q or C-^ (control-^)
  Insert the next character typed into the buffer.  This is how to get
    control characters and the like into the buffer.
  Note: If you quote ALT keys or softkeys it will be pretty boring.

(re-search-forward)    Not bound    args: regular expression
  Same as (search-forward) but using regular expressions.
  See REGEXP.DOC for regular expression syntax.
  See also: (query-replace), (search-forward), (re-search-forward)
   in MEMUTT.DOC: case-fold-search, get-matched, looking-at
(re-query-replace)    Not bound
  args: regular expression search string, replace string
  Same as (query-replace) but using regular expressions.
  See REGEXP.DOC for regular expression syntax.
  See also: (query-replace), (search-forward),
    (re-search-forward), case-fold-search (in MEMUTT.DOC)
(read-file)        C-XC-R    args: file name, [yes or no]
  Clear the current buffer (asking if the buffer has been modified) and read
    in a file.
  The file name defaults to the file name of the current buffer.
  See also: (insert-file), (visit-file), (write-file).
(refresh-screen)    C-L
  Repaint the screen.  If n, then center the dot vertically in the window.
  See also: (center-cursor), (reposition-window).
(reposition-window)    M-!
  Move the current window so that the line the dot is on is n lines
    from the top of the window.
  If n<0, move the dot so that it is n lines from the bottom.
  If n==0, the dot is centered vertically centered in the window.
  See also: (center-cursor), (refresh-screen).

(save-buffer)        C-XC-S
  Write the current buffer to the file associated with it.  Does not
    do anything if the buffer is unmodified.  If you want to force a write,
    use (write-file).
  See also:  (write-file).
(scroll-down)        C-XC-N or F-O (oh) (roll up)
  Move the current window down by a line.  Visually, the dot moves up the
    screen.
(scroll-up)        C-XC-P or F-P (roll down)
  Move the current window up by a line.  Visually, the dot moves down the
    screen.
(search-forward)    C-\ or C-S    args: search string
(search-reverse)    C-R        args: search string
  Search for a string.
  CR ends patterns, LF (^J) => start of line.
    The pattern is saved across searches.  The pattern is also the
    default search pattern for the replace commands.  Whenever the
    search pattern changes, the replace pattern is cleared (this is so
    you can replace something with nothing).
  (search-forward) The dot is after the last character matched.
  (search-reverse) The dot is before the last character matched, or put
    another way, to the left of the first character of the search string.
  See also: (query-replace), (re-query-replace),
    (re-search-forward), case-fold-search (in MUTT.DOC)
(set-mark)        C-@ or M-SPACE or F-N (select)
  Set the mark at the dot.  Visually, under the cursor.
  With an argument, sets the nth mark.
  See also: (exchange-dot-and-mark).
(shell-command)    C-X!    args: op sys command
  Call the operating system to perform a command or run a program and then
    return to editing.
  MS-DOS example:  To copy a file: (shell-command "copy foo bar")
    To get a directory listing: (shell-command "ls").
  See also: (filter-region), (spawn-shell).
(shrink-window)        C-XC-Z
  Shrink the current window by a line.
  See also: (enlarge-window).
(spawn-shell)        C-_
  Jump to the  operating  system  shell for a while.  ME is still loaded
    and will sit in the background  until you exit the shell (via "exit"
    in MS-DOS).
  In UNIX and MS-DOS, you can specify your shell with the SHELL
    environment variable (eg set SHELL=MUSH.EXE).
  See also: (shell-command), (filter-region).
(split-window)        C-X2
  Make 2 windows out of the  current  window.  A window with less than 3
    lines cannot be split.
  See also: (delete-other-windows).
(start-macro)        C-X(
  Start remembering keystrokes until (end-macro).
  (abort) will terminate and back out of the macro.
  See also: (end-macro), (execute-macro).
(switch-to-buffer)    C-XB    args: buffer name
  Replace the current window with another buffer.  The buffer name has a
    max length of 15 characters.
  Buffer name completion is on.
  See also: (list-buffers), (next-buffer), (use-existing-buffer).

(tab)            C-I or the tab key
  Insert tab(s).
  Move to the next tab stop.  With argument, move n tabs.
  To set the tab stops, see tab-stops in MEMUTT.DOC.

(universal-argument)    C-U
  Get a numeric count for the next command.  The next command or program
    is performed count times.  If the command is a self-insert, count
    copies of the character are inserted.
  Count starts at 4 (except as noted below).  If the first key pressed
    after ^U is "-", count becomes negative.  Pressing ^U multiplies
    count by 4.  If a non digit is pressed, whatever is bound to that
    key is performed count times.  Otherwise, count becomes the next
    digits pressed.
  For example, ^U^F will move forward 4 characters, ^U^U^F 16
    characters, ^U123 123 characters.  ^U5@ will insert "@@@@@".
  If (universal-argument) is given an argument, the count starts there.
    For example, in some Emacses, META digit starts the count at digit.
    See arg-prefix in MEMUTT.DOC for how to implement this.
  (universal-argument) ignores running programs and will read from the
    keyboard.  Use arg-prefix if you wish pass an argument to something.
  See also: arg-prefix (in MEMUTT.DOC).
(use-existing-buffer)    ^XC-O (oh)    args: name of existing buffer
  Replace the current window with a buffer that already exists.
  Buffer name completion is on.
  See also: (list-buffers), (switch-to-buffer).

(version)        Not bound
  Show the version of ME.
(visit-file)    C-XC-F or C-XC-V  args: file name
  Split the current buffer.  If the file is already loaded, switch to
    it.  Otherwise, read in the file.  A buffer name is created from the
    file name by stripping off the directory info and keeping the name
    and extension.  The dot is set to the beginning of the buffer and
    the marks are erased.
  If the buffer already exists and the filenames are different (eg "foo"
    and "../foo" both generate the buffer name "foo"), a unique buffer
    name is constructed by appending "<1>", "<2>", etc, using the lowest
    number that makes a name not already in use.
  See also: (insert-file), (read-file), (write-file).

(write-file)        C-XC-W    args: file-name
  Write the current buffer to a file.  If the file exists, it is
    overwritten.  If the file does not already exist, it is created.
  file-name defaults to the file name of the current buffer.
  Note that the buffer name and file name do NOT change.  Some Emacses
    change the file name to file-name.  If you like this behavior, try:
    (defun write-named-file
    {(rename-buffer (ask "Write named file: "))(write-file "")})
  See also: (insert-file), (read-file), (save-buffer), (visit-file).

(yank)    C-Y
  Insert the contents of the killbuffer before the dot (visually before the
    cursor).  Does not affect the kill buffer.
  The dot is left after the yanked text.  The mark does not move.
  See also: (copy-region), (kill-line), (kill-region).