Fmake-abbrev-table
Create a new, empty abbrev table object.

arguments: ()Fclear-abbrev-table
Undefine all abbrevs in abbrev table TABLE, leaving it empty.

arguments: (table)Fdefine-abbrev
Define an abbrev in TABLE named NAME, to expand to EXPANSION and call HOOK.
NAME and EXPANSION are strings.
To undefine an abbrev, define it with EXPANSION = nil.
If HOOK is non-nil, it should be a function of no arguments;
it is called after EXPANSION is inserted.

arguments: (table name expansion &optional hook count)Fdefine-global-abbrev
Define ABBREV as a global abbreviation for EXPANSION.

arguments: (name expansion)Fdefine-mode-abbrev
Define ABBREV as a mode-specific abbreviation for EXPANSION.

arguments: (name expansion)Fabbrev-symbol
Return the symbol representing abbrev named ABBREV.
This symbol's name is ABBREV, but it is not the canonical symbol of that name;
it is interned in an abbrev-table rather than the normal obarray.
The value is nil if that abbrev is not defined.
Optional second arg TABLE is abbrev table to look it up in.
The default is to try buffer's mode-specific abbrev table, then global table.

arguments: (abbrev &optional table)Fabbrev-expansion
Return the string that ABBREV expands into in the current buffer.
Optionally specify an abbrev table as second arg;
then ABBREV is looked up in that table only.

arguments: (abbrev &optional table)Fexpand-abbrev
Expand the abbrev before point, if there is an abbrev there.
Effective when explicitly called even when `abbrev-mode' is nil.
Returns t if expansion took place.

arguments: ()Funexpand-abbrev
Undo the expansion of the last abbrev that expanded.
This differs from ordinary undo in that other editing done since then
is not undone.

arguments: ()Finsert-abbrev-table-description
Insert before point a full description of abbrev table named NAME.
NAME is a symbol whose value is an abbrev table.
If optional 2nd arg HUMAN is non-nil, a human-readable description is inserted.
Otherwise the description is an expression,
a call to `define-abbrev-table', which would
define the abbrev table NAME exactly as it is currently defined.

arguments: (name &optional readable)Fdefine-abbrev-table
Define TABNAME (a symbol) as an abbrev table name.
Define abbrevs in it according to DEFINITIONS, which is a list of elements
of the form (ABBREVNAME EXPANSION HOOK USECOUNT).

arguments: (tabname defns)Vabbrev-table-name-list
List of symbols whose values are abbrev tables.Vglobal-abbrev-table
The abbrev table whose abbrevs affect all buffers.
Each buffer may also have a local abbrev table.
If it does, the local table overrides the global one
for any particular abbrev defined in both.Vfundamental-mode-abbrev-table
The abbrev table of mode-specific abbrevs for Fundamental Mode.Vlast-abbrev
The abbrev-symbol of the last abbrev expanded.  See `abbrev-symbol'.Vlast-abbrev-text
The exact text of the last abbrev expanded.
nil if the abbrev has already been unexpanded.Vlast-abbrev-location
The location of the start of the last abbrev expanded.Vabbrev-start-location
Buffer position for `expand-abbrev' to use as the start of the abbrev.
nil means use the word before point as the abbrev.
Calling `expand-abbrev' sets this to nil.Vabbrev-start-location-buffer
Buffer that `abbrev-start-location' has been set for.
Trying to expand an abbrev in any other buffer clears `abbrev-start-location'.Vlocal-abbrev-table
Local (mode-specific) abbrev table of current buffer.Vabbrevs-changed
Set non-nil by defining or altering any word abbrevs.
This causes `save-some-buffers' to offer to save the abbrevs.Vabbrev-all-caps
*Set non-nil means expand multi-word abbrevs all caps if abbrev was so.Vpre-abbrev-expand-hook
Function or functions to be called before abbrev expansion is done.
This is the first thing that `expand-abbrev' does, and so this may change
the current abbrev table before abbrev lookup happens.Fcons
Create a new cons, give it CAR and CDR as components, and return it.

arguments: (car cdr)Flist
Return a newly created list with specified arguments as elements.
Any number of arguments, even zero arguments, are allowed.Fmake-list
Return a newly created list of length LENGTH, with each element being INIT.

arguments: (length init)Fmake-vector
Return a newly created vector of length LENGTH, with each element being INIT.
See also the function `vector'.

arguments: (length init)Fvector
Return a newly created vector with specified arguments as elements.
Any number of arguments, even zero arguments, are allowed.Fmake-byte-code
Create a byte-code object with specified arguments as elements.
The arguments should be the arglist, bytecode-string, constant vector,
stack size, (optional) doc string, and (optional) interactive spec.
The first four arguments are required; at most six have any
significance.Fmake-symbol
Return a newly allocated uninterned symbol whose name is NAME.
Its value and function definition are void, and its property list is nil.

arguments: (str)Fmake-marker
Return a newly allocated marker which does not point at any place.

arguments: ()Fmake-string
Return a newly created string of length LENGTH, with each element being INIT.
Both LENGTH and INIT must be numbers.

arguments: (length init)Fpurecopy
Make a copy of OBJECT in pure storage.
Recursively copies contents of vectors and cons cells.
Does not copy symbols.

arguments: (obj)Fgarbage-collect
Reclaim storage for Lisp objects no longer needed.
Returns info on amount of space in use:
 ((USED-CONSES . FREE-CONSES) (USED-SYMS . FREE-SYMS)
  (USED-MARKERS . FREE-MARKERS) USED-STRING-CHARS USED-VECTOR-SLOTS
  (USED-FLOATS . FREE-FLOATS))
Garbage collection happens automatically if you cons more than
`gc-cons-threshold' bytes of Lisp data since previous garbage collection.

arguments: ()Fmemory-limit
Return the address of the last byte Emacs has allocated, divided by 1024.
This may be helpful in debugging Emacs's memory usage.
We divide the value by 1024 to make sure it fits in a Lisp integer.

arguments: ()Vgc-cons-threshold
*Number of bytes of consing between garbage collections.
Garbage collection can happen automatically once this many bytes have been
allocated since the last garbage collection.  All data types count.

Garbage collection happens automatically only when `eval' is called.

By binding this temporarily to a large number, you can effectively
prevent garbage collection during a part of the program.Vpure-bytes-used
Number of bytes of sharable Lisp data allocated so far.Vdata-bytes-used
Number of bytes of unshared memory allocated in this session.Vdata-bytes-free
Number of bytes of unshared memory remaining available in this session.Vpurify-flag
Non-nil means loading Lisp code in order to dump an executable.
This means that certain objects should be allocated in shared (pure) space.Vundo-limit
Keep no more undo information once it exceeds this size.
This limit is applied when garbage collection happens.
The size is counted as the number of bytes occupied,
which includes both saved text and other data.Vundo-strong-limit
Don't keep more than this much size of undo information.
A command which pushes past this size is itself forgotten.
This limit is applied when garbage collection happens.
The size is counted as the number of bytes occupied,
which includes both saved text and other data.Fbuffer-list
Return a list of all existing live buffers.

arguments: ()Fget-buffer
Return the buffer named NAME (a string).
If there is no live buffer named NAME, return nil.
NAME may also be a buffer; if so, the value is that buffer.

arguments: (name)Fget-file-buffer
Return the buffer visiting file FILENAME (a string).
If there is no such live buffer, return nil.

arguments: (filename)Fget-buffer-create
Return the buffer named NAME, or create such a buffer and return it.
A new buffer is created if there is no live buffer named NAME.
If NAME starts with a space, the new buffer does not keep undo information.
If NAME is a buffer instead of a string, then it is the value returned.
The value is never nil.

arguments: (name)Fgenerate-new-buffer-name
Return a string that is the name of no existing buffer based on NAME.
If there is no live buffer named NAME, then return NAME.
Otherwise modify name by appending `<NUMBER>', incrementing NUMBER
until an unused name is found, and then return that name.
Optional second argument IGNORE specifies a name that is okay to use
(if it is in the sequence to be tried)
even if a buffer with that name exists.

arguments: (name &optional ignore)Fbuffer-name
Return the name of BUFFER, as a string.
With no argument or nil as argument, return the name of the current buffer.

arguments: (&optional buffer)Fbuffer-file-name
Return name of file BUFFER is visiting, or nil if none.
No argument or nil as argument means use the current buffer.

arguments: (&optional buffer)Fbuffer-local-variables
Return an alist of variables that are buffer-local in BUFFER.
Most elements look like (SYMBOL . VALUE), describing one variable.
For a symbol that is locally unbound, just the symbol appears in the value.
Note that storing new VALUEs in these elements doesn't change the variables.
No argument or nil as argument means use current buffer as BUFFER.

arguments: (&optional buffer)Fbuffer-modified-p
Return t if BUFFER was modified since its file was last read or saved.
No argument or nil as argument means use current buffer as BUFFER.

arguments: (&optional buffer)Fset-buffer-modified-p
Mark current buffer as modified or unmodified according to FLAG.
A non-nil FLAG means mark the buffer modified.

arguments: (flag)Fbuffer-modified-tick
Return BUFFER's tick counter, incremented for each change in text.
Each buffer has a tick counter which is incremented each time the text in
that buffer is changed.  It wraps around occasionally.
No argument or nil as argument means use current buffer as BUFFER.

arguments: (&optional buffer)Frename-buffer
Change current buffer's name to NEWNAME (a string).
If second arg UNIQUE is nil or omitted, it is an error if a
buffer named NEWNAME already exists.
If UNIQUE is non-nil, come up with a new name using
`generate-new-buffer-name'.
Interactively, you can set UNIQUE with a prefix argument.
We return the name we actually gave the buffer.
This does not change the name of the visited file (if any).

arguments: (name &optional unique)Fother-buffer
Return most recently selected buffer other than BUFFER.
Buffers not visible in windows are preferred to visible buffers,
unless optional second argument VISIBLE-OK is non-nil.
If no other buffer exists, the buffer `*scratch*' is returned.
If BUFFER is omitted or nil, some interesting buffer is returned.

arguments: (&optional buffer visible-ok)Fbuffer-disable-undo
Make BUFFER stop keeping undo information.

arguments: (buffer)Fbuffer-enable-undo
Start keeping undo information for buffer BUFFER.
No argument or nil as argument means do this for the current buffer.

arguments: (&optional buffer)Vkill-buffer-hook
Hook to be run (by `run-hooks', which see) when a buffer is killed.
The buffer being killed will be current while the hook is running.
See `kill-buffer'.Fkill-buffer
Kill the buffer BUFFER.
The argument may be a buffer or may be the name of a buffer.
An argument of nil means kill the current buffer.

Value is t if the buffer is actually killed, nil if user says no.

The value of `kill-buffer-hook' (which may be local to that buffer),
if not void, is a list of functions to be called, with no arguments,
before the buffer is actually killed.  The buffer to be killed is current
when the hook functions are called.

Any processes that have this buffer as the `process-buffer' are killed
with `delete-process'.

arguments: (bufname)Fswitch-to-buffer
Select buffer BUFFER in the current window.
BUFFER may be a buffer or a buffer name.
Optional second arg NORECORD non-nil means
do not put this buffer at the front of the list of recently selected ones.

WARNING: This is NOT the way to work on another buffer temporarily
within a Lisp program!  Use `set-buffer' instead.  That avoids messing with
the window-buffer correspondences.

arguments: (bufname &optional norecord)Fpop-to-buffer
Select buffer BUFFER in some window, preferably a different one.
If BUFFER is nil, then some other buffer is chosen.
If `pop-up-windows' is non-nil, windows can be split to do this.
If optional second arg OTHER-WINDOW is non-nil, insist on finding another
window even if BUFFER is already visible in the selected window.

arguments: (bufname &optional other)Fcurrent-buffer
Return the current buffer as a Lisp object.

arguments: ()Fset-buffer
Make the buffer BUFFER current for editing operations.
BUFFER may be a buffer or the name of an existing buffer.
See also `save-excursion' when you want to make a buffer current temporarily.
This function does not display the buffer, so its effect ends
when the current command terminates.
Use `switch-to-buffer' or `pop-to-buffer' to switch buffers permanently.

arguments: (bufname)Fbarf-if-buffer-read-only
Signal a `buffer-read-only' error if the current buffer is read-only.

arguments: ()Fbury-buffer
Put BUFFER at the end of the list of all buffers.
There it is the least likely candidate for `other-buffer' to return;
thus, the least likely buffer for \[switch-to-buffer] to select by default.
If BUFFER is nil or omitted, bury the current buffer.
Also, if BUFFER is nil or omitted, remove the current buffer from the
selected window if it is displayed there.

arguments: (&optional buf)Ferase-buffer
Delete the entire contents of the current buffer.
Any clipping restriction in effect (see `narrow-to-region') is removed,
so the buffer is truly empty after this.

arguments: ()Flist-buffers
Display a list of names of existing buffers.
The list is displayed in a buffer named `*Buffer List*'.
Note that buffers with names starting with spaces are omitted.
Non-null optional arg FILES-ONLY means mention only file buffers.

The M column contains a * for buffers that are modified.
The R column contains a % for buffers that are read-only.

arguments: (&optional files)Fkill-all-local-variables
Switch to Fundamental mode by killing current buffer's local variables.
Most local variable bindings are eliminated so that the default values
become effective once more.  Also, the syntax table is set from
`standard-syntax-table', the local keymap is set to nil,
and the abbrev table from `fundamental-mode-abbrev-table'.
This function also forces redisplay of the mode line.

Every function to select a new major mode starts by
calling this function.

As a special exception, local variables whose names have
a non-nil `permanent-local' property are not eliminated by this function.

arguments: ()Foverlayp
Return t if OBJECT is an overlay.

arguments: (object)Fmake-overlay
Create a new overlay with range BEG to END in BUFFER.
If omitted, BUFFER defaults to the current buffer.
BEG and END may be integers or markers.

arguments: (beg end &optional buffer)Fmove-overlay
Set the endpoints of OVERLAY to BEG and END in BUFFER.
If BUFFER is omitted, leave OVERLAY in the same buffer it inhabits now.
If BUFFER is omitted, and OVERLAY is in no buffer, put it in the current
buffer.

arguments: (overlay beg end &optional buffer)Fdelete-overlay
Delete the overlay OVERLAY from its buffer.

arguments: (overlay)Foverlay-start
Return the position at which OVERLAY starts.

arguments: (overlay)Foverlay-end
Return the position at which OVERLAY ends.

arguments: (overlay)Foverlay-buffer
Return the buffer OVERLAY belongs to.

arguments: (overlay)Foverlay-properties
Return a list of the properties on OVERLAY.
This is a copy of OVERLAY's plist; modifying its conses has no effect on
OVERLAY.

arguments: (overlay)Foverlays-at
Return a list of the overlays that contain position POS.

arguments: (pos)Fnext-overlay-change
Return the next position after POS where an overlay starts or ends.

arguments: (pos)Foverlay-lists
Return a pair of lists giving all the overlays of the current buffer.
The car has all the overlays before the overlay center;
the cdr has all the overlays before the overlay center.
Recentering overlays moves overlays between these lists.
The lists you get are copies, so that changing them has no effect.
However, the overlays you get are the real objects that the buffer uses.

arguments: ()Foverlay-recenter
Recenter the overlays of the current buffer around position POS.

arguments: (pos)Foverlay-get
Get the property of overlay OVERLAY with property name NAME.

arguments: (overlay prop)Foverlay-put
Set one property of overlay OVERLAY: give property PROP value VALUE.

arguments: (overlay prop value)Vdefault-mode-line-format
Default value of `mode-line-format' for buffers that don't override it.
This is the same as (default-value 'mode-line-format).Vdefault-abbrev-mode
Default value of `abbrev-mode' for buffers that do not override it.
This is the same as (default-value 'abbrev-mode).Vdefault-ctl-arrow
Default value of `ctl-arrow' for buffers that do not override it.
This is the same as (default-value 'ctl-arrow).Vdefault-truncate-lines
Default value of `truncate-lines' for buffers that do not override it.
This is the same as (default-value 'truncate-lines).Vdefault-fill-column
Default value of `fill-column' for buffers that do not override it.
This is the same as (default-value 'fill-column).Vdefault-left-margin
Default value of `left-margin' for buffers that do not override it.
This is the same as (default-value 'left-margin).Vdefault-tab-width
Default value of `tab-width' for buffers that do not override it.
This is the same as (default-value 'tab-width).Vdefault-case-fold-search
Default value of `case-fold-search' for buffers that don't override it.
This is the same as (default-value 'case-fold-search).Vmode-line-format
Template for displaying mode line for current buffer.
Each buffer has its own value of this variable.
Value may be a string, a symbol or a list or cons cell.
For a symbol, its value is used (but it is ignored if t or nil).
 A string appearing directly as the value of a symbol is processed verbatim
 in that the %-constructs below are not recognized.
For a list whose car is a symbol, the symbol's value is taken,
 and if that is non-nil, the cadr of the list is processed recursively.
 Otherwise, the caddr of the list (if there is one) is processed.
For a list whose car is a string or list, each element is processed
 recursively and the results are effectively concatenated.
For a list whose car is an integer, the cdr of the list is processed
  and padded (if the number is positive) or truncated (if negative)
  to the width specified by that number.
A string is printed verbatim in the mode line except for %-constructs:
  (%-constructs are allowed when the string is the entire mode-line-format
   or when it is found in a cons-cell or a list)
  %b -- print buffer name.      %f -- print visited file name.
  %* -- print *, % or hyphen.   %m -- print value of mode-name (obsolete).
  %s -- print process status.   %l -- print the current line number.
  %p -- print percent of buffer above top of window, or top, bot or all.
  %n -- print Narrow if appropriate.
  %[ -- print one [ for each recursive editing level.  %] similar.
  %% -- print %.   %- -- print infinitely many dashes.
Decimal digits after the % specify field width to which to pad.Vdefault-major-mode
*Major mode for new buffers.  Defaults to `fundamental-mode'.
nil here means use current buffer's major mode.Vmajor-mode
Symbol for current buffer's major mode.Vmode-name
Pretty name of current buffer's major mode (a string).Vabbrev-mode
Non-nil turns on automatic expansion of abbrevs as they are inserted.
Automatically becomes buffer-local when set in any fashion.Vcase-fold-search
*Non-nil if searches should ignore case.
Automatically becomes buffer-local when set in any fashion.Vfill-column
*Column beyond which automatic line-wrapping should happen.
Automatically becomes buffer-local when set in any fashion.Vleft-margin
*Column for the default indent-line-function to indent to.
Linefeed indents to this column in Fundamental mode.
Automatically becomes buffer-local when set in any fashion.Vtab-width
*Distance between tab stops (for display of tab characters), in columns.
Automatically becomes buffer-local when set in any fashion.Vctl-arrow
*Non-nil means display control chars with uparrow.
Nil means use backslash and octal digits.
Automatically becomes buffer-local when set in any fashion.
This variable does not apply to characters whose display is specified
in the current display table (if there is one).Vtruncate-lines
*Non-nil means do not display continuation lines;
give each line of text one screen line.
Automatically becomes buffer-local when set in any fashion.

Note that this is overridden by the variable
`truncate-partial-width-windows' if that variable is non-nil
and this buffer is not full-frame width.Vdefault-directory
Name of default directory of current buffer.  Should end with slash.
Each buffer has its own value of this variable.Vauto-fill-function
Function called (if non-nil) to perform auto-fill.
It is called after self-inserting a space at a column beyond `fill-column'.
Each buffer has its own value of this variable.
NOTE: This variable is not an ordinary hook;
It may not be a list of functions.Vbuffer-file-name
Name of file visited in current buffer, or nil if not visiting a file.
Each buffer has its own value of this variable.Vbuffer-auto-save-file-name
Name of file for auto-saving current buffer,
or nil if buffer should not be auto-saved.
Each buffer has its own value of this variable.Vbuffer-read-only
Non-nil if this buffer is read-only.
Each buffer has its own value of this variable.Vbuffer-backed-up
Non-nil if this buffer's file has been backed up.
Backing up is done before the first time the file is saved.
Each buffer has its own value of this variable.Vbuffer-saved-size
Length of current buffer when last read in, saved or auto-saved.
0 initially.
Each buffer has its own value of this variable.Vselective-display
Non-nil enables selective display:
Integer N as value means display only lines
 that start with less than n columns of space.
A value of t means, after a ^M, all the rest of the line is invisible.
 Then ^M's in the file are written into files as newlines.

Automatically becomes buffer-local when set in any fashion.Vselective-display-ellipses
t means display ... on previous line when a line is invisible.
Automatically becomes buffer-local when set in any fashion.Voverwrite-mode
Non-nil if self-insertion should replace existing text.
If non-nil and not `overwrite-mode-binary', self-insertion still
inserts at the end of a line, and inserts when point is before a tab,
until the tab is filled in.
If `overwrite-mode-binary', self-insertion replaces newlines and tabs too.
Automatically becomes buffer-local when set in any fashion.Vbuffer-display-table
Display table that controls display of the contents of current buffer.
Automatically becomes buffer-local when set in any fashion.
The display table is a vector created with `make-display-table'.
The first 256 elements control how to display each possible text character.
Each value should be a vector of characters or nil;
nil means display the character in the default fashion.
The remaining five elements control the display of
  the end of a truncated screen line (element 256, a single character);
  the end of a continued line (element 257, a single character);
  the escape character used to display character codes in octal
    (element 258, a single character);
  the character used as an arrow for control characters (element 259,
    a single character);
  the decoration indicating the presence of invisible lines (element 260,
    a vector of characters).
If this variable is nil, the value of `standard-display-table' is used.
Each window can have its own, overriding display table.Vbefore-change-function
Function to call before each text change.
Two arguments are passed to the function: the positions of
the beginning and end of the range of old text to be changed.
(For an insertion, the beginning and end are at the same place.)
No information is given about the length of the text after the change.
position of the change

While executing the `before-change-function', changes to buffers do not
cause calls to any `before-change-function' or `after-change-function'.Vafter-change-function
Function to call after each text change.
Three arguments are passed to the function: the positions of
the beginning and end of the range of changed text,
and the length of the pre-change text replaced by that range.
(For an insertion, the pre-change length is zero;
for a deletion, that length is the number of characters deleted,
and the post-change beginning and end are at the same place.)

While executing the `after-change-function', changes to buffers do not
cause calls to any `before-change-function' or `after-change-function'.Vfirst-change-hook
A list of functions to call before changing a buffer which is unmodified.
The functions are run using the `run-hooks' function.Vbuffer-undo-list
List of undo entries in current buffer.
Recent changes come first; older changes follow newer.

An entry (START . END) represents an insertion which begins at
position START and ends at position END.

An entry (TEXT . POSITION) represents the deletion of the string TEXT
from (abs POSITION).  If POSITION is positive, point was at the front
of the text being deleted; if negative, point was at the end.

An entry (t HIGHWORD LOWWORD) indicates that the buffer had been
previously unmodified.  HIGHWORD and LOWWORD are the high and low
16-bit words of the buffer's modification count at the time.  If the
modification count of the most recent save is different, this entry is
obsolete.

An entry (nil PROP VAL BEG . END) indicates that a text property
was modified between BEG and END.  PROP is the property name,
and VAL is the old value.

An entry of the form POSITION indicates that point was at the buffer
location given by the integer.  Undoing an entry of this form places
point at POSITION.

nil marks undo boundaries.  The undo command treats the changes
between two undo boundaries as a single step to be undone.

If the value of the variable is t, undo information is not recorded.Vmark-active
Non-nil means the mark and region are currently active in this buffer.
Automatically local in all buffers.Vtransient-mark-mode
*Non-nil means deactivate the mark when the buffer contents change.Vinhibit-read-only
*Non-nil means disregard read-only status of buffers or characters.
If the value is t, disregard `buffer-read-only' and all `read-only'
text properties.  If the value is a list, disregard `buffer-read-only'
and disregard a `read-only' text property if the property value
is a member of the list.Fbyte-code
Function used internally in byte-compiled code.
The first argument is a string of byte code; the second, a vector of constants;
the third, the maximum stack depth used in this function.
If the third argument is incorrect, Emacs may crash.

arguments: (bytestr vector maxdepth)Vbyte-code-meter
A vector of vectors which holds a histogram of byte-code usage.
(aref (aref byte-code-meter 0) CODE) indicates how many times the byte
opcode CODE has been executed.
(aref (aref byte-code-meter CODE1) CODE2), where CODE1 is not 0,
indicates how many times the byte opcodes CODE1 and CODE2 have been
executed in succession.Vbyte-metering-on
If non-nil, keep profiling information on byte code usage.
The variable byte-code-meter indicates how often each byte opcode is used.
If a symbol has a property named `byte-code-meter' whose value is an
integer, it is incremented each time that symbol's function is called.Finteractive
Specify a way of parsing arguments for interactive use of a function.
For example, write
  (defun foo (arg) "Doc string" (interactive "p") ...use arg...)
to make ARG be the prefix argument when `foo' is called as a command.
The "call" to `interactive' is actually a declaration rather than a function;
 it tells `call-interactively' how to read arguments
 to pass to the function.
When actually called, `interactive' just returns nil.

The argument of `interactive' is usually a string containing a code letter
 followed by a prompt.  (Some code letters do not use I/O to get
 the argument and do not need prompts.)  To prompt for multiple arguments,
 give a code letter, its prompt, a newline, and another code letter, etc.
 Prompts are passed to format, and may use % escapes to print the
 arguments that have already been read.
If the argument is not a string, it is evaluated to get a list of
 arguments to pass to the function.
Just `(interactive)' means pass no args when calling interactively.

Code letters available are:
a -- Function name: symbol with a function definition.
b -- Name of existing buffer.
B -- Name of buffer, possibly nonexistent.
c -- Character.
C -- Command name: symbol with interactive function definition.
d -- Value of point as number.  Does not do I/O.
D -- Directory name.
e -- Parametrized event (i.e., one that's a list) that invoked this command.
     If used more than once, the Nth `e' returns the Nth parameterized event.
     This skips events that are integers or symbols.
f -- Existing file name.
F -- Possibly nonexistent file name.
k -- Key sequence (string).
m -- Value of mark as number.  Does not do I/O.
n -- Number read using minibuffer.
N -- Prefix arg converted to number, or if none, do like code `n'.
p -- Prefix arg converted to number.  Does not do I/O.
P -- Prefix arg in raw form.  Does not do I/O.
r -- Region: point and mark as 2 numeric args, smallest first.  Does no I/O.
s -- Any string.
S -- Any symbol.
v -- Variable name: symbol that is user-variable-p.
x -- Lisp expression read but not evaluated.
X -- Lisp expression read and evaluated.
In addition, if the string begins with `*'
 then an error is signaled if the buffer is read-only.
 This happens before reading any arguments.
If the string begins with `@', then Emacs searches the key sequence
 which invoked the command for its first mouse click (or any other
 event which specifies a window), and selects that window before
 reading any arguments.  You may use both `@' and `*'; they are
 processed in the order that they appear.

arguments: (args)Fcall-interactively
Call FUNCTION, reading args according to its interactive calling specs.
The function contains a specification of how to do the argument reading.
In the case of user-defined functions, this is specified by placing a call
to the function `interactive' at the top level of the function body.
See `interactive'.

Optional second arg RECORD-FLAG non-nil
means unconditionally put this command in the command-history.
Otherwise, this is done only if an arg is read using the minibuffer.

arguments: (function &optional record)Fprefix-numeric-value
Return numeric meaning of raw prefix argument ARG.
A raw prefix argument is what you get from `(interactive "P")'.
Its numeric meaning is what you would get from `(interactive "p")'.

arguments: (raw)Vprefix-arg
The value of the prefix argument for the next editing command.
It may be a number, or the symbol `-' for just a minus sign as arg,
or a list whose car is a number for just one or more C-U's
or nil if no argument has been specified.

You cannot examine this variable to find the argument for this command
since it has been set to nil by the time you can look.
Instead, you should use the variable `current-prefix-arg', although
normally commands can get this prefix argument with (interactive "P").Vcurrent-prefix-arg
The value of the prefix argument for this editing command.
It may be a number, or the symbol `-' for just a minus sign as arg,
or a list whose car is a number for just one or more C-U's
or nil if no argument has been specified.
This is what `(interactive "P")' returns.Vcommand-history
List of recent commands that read arguments from terminal.
Each command is represented as a form to evaluate.Vcommand-debug-status
Debugging status of current interactive command.
Bound each time `call-interactively' is called;
may be set by the debugger as a reminder for itself.Vmark-even-if-inactive
*Non-nil means you can use the mark even when inactive.
This option makes a difference in Transient Mark mode.
When the option is non-nil, deactivation of the mark
turns off region highlighting, but commands that use the mark
behave as if the mark were still active.Fcall-process
Call PROGRAM synchronously in separate process.
The program's input comes from file INFILE (nil means `/dev/null').
Insert output in BUFFER before point; t means current buffer;
 nil for BUFFER means discard it; 0 means discard and don't wait.
Fourth arg DISPLAY non-nil means redisplay buffer as output is inserted.
Remaining arguments are strings passed as command arguments to PROGRAM.
If BUFFER is 0, returns immediately with value nil.
Otherwise waits for PROGRAM to terminate
and returns a numeric exit status or a signal description string.
If you quit, the process is killed with SIGINT, or SIGKILL if you quit again.Fcall-process-region
Send text from START to END to a synchronous process running PROGRAM.
Delete the text if fourth arg DELETE is non-nil.
Insert output in BUFFER before point; t means current buffer;
 nil for BUFFER means discard it; 0 means discard and don't wait.
Sixth arg DISPLAY non-nil means redisplay buffer as output is inserted.
Remaining args are passed to PROGRAM at startup as command args.
If BUFFER is nil, returns immediately with value nil.
Otherwise waits for PROGRAM to terminate
and returns a numeric exit status or a signal description string.
If you quit, the process is killed with SIGINT, or SIGKILL if you quit again.Fgetenv
Return the value of environment variable VAR, as a string.
VAR should be a string.  Value is nil if VAR is undefined in the environment.
This function consults the variable ``process-environment'' for its value.

arguments: (var)Vshell-file-name
*File name to load inferior shells from.
Initialized from the SHELL environment variable.Vexec-path
*List of directories to search programs to run in subprocesses.
Each element is a string (directory name) or nil (try default directory).Vexec-directory
Directory of architecture-dependent files that come with GNU Emacs,
especially executable programs intended for Emacs to invoke.Vdata-directory
Directory of architecture-independent files that come with GNU Emacs,
intended for Emacs to use.Vconfigure-info-directory
For internal use by the build procedure only.
This is the name of the directory in which the build procedure installed
Emacs's info files; the default value for Info-default-directory-list
includes this.Vprocess-environment
List of environment variables for subprocesses to inherit.
Each element should be a string of the form ENVVARNAME=VALUE.
The environment which Emacs inherits is placed in this variable
when Emacs starts.Fupcase
Convert argument to upper case and return that.
The argument may be a character or string.  The result has the same type.
The argument object is not altered.  See also `capitalize'.

arguments: (obj)Fdowncase
Convert argument to lower case and return that.
The argument may be a character or string.  The result has the same type.
The argument object is not altered.

arguments: (obj)Fcapitalize
Convert argument to capitalized form and return that.
This means that each word's first character is upper case
and the rest is lower case.
The argument may be a character or string.  The result has the same type.
The argument object is not altered.

arguments: (obj)Fupcase-region
Convert the region to upper case.  In programs, wants two arguments.
These arguments specify the starting and ending character numbers of
the region to operate on.  When used as a command, the text between
point and the mark is operated on.
See also `capitalize-region'.

arguments: (b e)Fdowncase-region
Convert the region to lower case.  In programs, wants two arguments.
These arguments specify the starting and ending character numbers of
the region to operate on.  When used as a command, the text between
point and the mark is operated on.

arguments: (b e)Fcapitalize-region
Convert the region to capitalized form.
Capitalized form means each word's first character is upper case
and the rest of it is lower case.
In programs, give two arguments, the starting and ending
character positions to operate on.

arguments: (b e)Fupcase-word
Convert following word (or ARG words) to upper case, moving over.
With negative argument, convert previous words but do not move.
See also `capitalize-word'.

arguments: (arg)Fdowncase-word
Convert following word (or ARG words) to lower case, moving over.
With negative argument, convert previous words but do not move.

arguments: (arg)Fcapitalize-word
Capitalize the following word (or ARG words), moving over.
This gives the word(s) a first character in upper case
and the rest lower case.
With negative argument, capitalize previous words but do not move.

arguments: (arg)Fcase-table-p
Return t iff ARG is a case table.
See `set-case-table' for more information on these data structures.

arguments: (table)Fcurrent-case-table
Return the case table of the current buffer.

arguments: ()Fstandard-case-table
Return the standard case table.
This is the one used for new buffers.

arguments: ()Fset-case-table
Select a new case table for the current buffer.
A case table is a list (DOWNCASE UPCASE CANONICALIZE EQUIVALENCES)
 where each element is either nil or a string of length 256.
DOWNCASE maps each character to its lower-case equivalent.
UPCASE maps each character to its upper-case equivalent;
 if lower and upper case characters are in 1-1 correspondence,
 you may use nil and the upcase table will be deduced from DOWNCASE.
CANONICALIZE maps each character to a canonical equivalent;
 any two characters that are related by case-conversion have the same
 canonical equivalent character.
EQUIVALENCES is a map that cyclicly permutes each equivalence class
 (of characters with the same canonical equivalent).
Both CANONICALIZE and EQUIVALENCES may be nil, in which case
 both are deduced from DOWNCASE and UPCASE.

arguments: (table)Fset-standard-case-table
Select a new standard case table for new buffers.
See `set-case-table' for more info on case tables.

arguments: (table)Vascii-downcase-table
String mapping ASCII characters to lowercase equivalents.Vascii-upcase-table
String mapping ASCII characters to uppercase equivalents.Fforward-char
Move point right ARG characters (left if ARG negative).
On reaching end of buffer, stop and signal error.

arguments: (&optional n)Fbackward-char
Move point left ARG characters (right if ARG negative).
On attempt to pass beginning or end of buffer, stop and signal error.

arguments: (&optional n)Fforward-line
Move ARG lines forward (backward if ARG is negative).
Precisely, if point is on line I, move to the start of line I + ARG.
If there isn't room, go as far as possible (no error).
Returns the count of lines left to move.  If moving forward,
that is ARG - number of lines moved; if backward, ARG + number moved.
With positive ARG, a non-empty line at the end counts as one line
  successfully moved (for the return value).

arguments: (&optional n)Fbeginning-of-line
Move point to beginning of current line.
With argument ARG not nil or 1, move forward ARG - 1 lines first.
If scan reaches end of buffer, stop there without error.

arguments: (&optional n)Fend-of-line
Move point to end of current line.
With argument ARG not nil or 1, move forward ARG - 1 lines first.
If scan reaches end of buffer, stop there without error.

arguments: (&optional n)Fdelete-char
Delete the following ARG characters (previous, with negative arg).
Optional second arg KILLFLAG non-nil means kill instead (save in kill ring).
Interactively, ARG is the prefix arg, and KILLFLAG is set if
ARG was explicitly specified.

arguments: (n &optional killflag)Fdelete-backward-char
Delete the previous ARG characters (following, with negative ARG).
Optional second arg KILLFLAG non-nil means kill instead (save in kill ring).
Interactively, ARG is the prefix arg, and KILLFLAG is set if
ARG was explicitly specified.

arguments: (n &optional killflag)Fself-insert-command
Insert the character you type.
Whichever character you type to run this command is inserted.

arguments: (arg)Fnewline
Insert a newline.  With arg, insert that many newlines.
In Auto Fill mode, if no numeric arg, break the preceding line if it's long.

arguments: (&optional arg1)Vblink-paren-function
Function called, if non-nil, whenever a close parenthesis is inserted.
More precisely, a char with closeparen syntax is self-inserted.Feq
T if the two args are the same Lisp object.

arguments: (obj1 obj2)Fnull
T if OBJECT is nil.

arguments: (obj)Fconsp
T if OBJECT is a cons cell.

arguments: (obj)Fatom
T if OBJECT is not a cons cell.  This includes nil.

arguments: (obj)Flistp
T if OBJECT is a list.  This includes nil.

arguments: (obj)Fnlistp
T if OBJECT is not a list.  Lists include nil.

arguments: (obj)Fsymbolp
T if OBJECT is a symbol.

arguments: (obj)Fvectorp
T if OBJECT is a vector.

arguments: (obj)Fstringp
T if OBJECT is a string.

arguments: (obj)Farrayp
T if OBJECT is an array (string or vector).

arguments: (obj)Fsequencep
T if OBJECT is a sequence (list or array).

arguments: (obj)Fbufferp
T if OBJECT is an editor buffer.

arguments: (obj)Fmarkerp
T if OBJECT is a marker (editor pointer).

arguments: (obj)Fsubrp
T if OBJECT is a built-in function.

arguments: (obj)Fbyte-code-function-p
T if OBJECT is a byte-compiled function object.

arguments: (obj)Fchar-or-string-p
T if OBJECT is a character (a number) or a string.

arguments: (obj)Fintegerp
T if OBJECT is a number.

arguments: (obj)Finteger-or-marker-p
T if OBJECT is an integer or a marker (editor pointer).

arguments: (obj)Fnatnump
T if OBJECT is a nonnegative number.

arguments: (obj)Fnumberp
T if OBJECT is a number (floating point or integer).

arguments: (obj)Fnumber-or-marker-p
T if OBJECT is a number or a marker.

arguments: (obj)Ffloatp
T if OBJECT is a floating point number.

arguments: (obj)Fcar
Return the car of CONSCELL.  If arg is nil, return nil.
Error if arg is not nil and not a cons cell.  See also `car-safe'.

arguments: (list)Fcar-safe
Return the car of OBJECT if it is a cons cell, or else nil.

arguments: (object)Fcdr
Return the cdr of CONSCELL.  If arg is nil, return nil.
Error if arg is not nil and not a cons cell.  See also `cdr-safe'.

arguments: (list)Fcdr-safe
Return the cdr of OBJECT if it is a cons cell, or else  nil.

arguments: (object)Fsetcar
Set the car of CONSCELL to be NEWCAR.  Returns NEWCAR.

arguments: (cell newcar)Fsetcdr
Set the cdr of CONSCELL to be NEWCDR.  Returns NEWCDR.

arguments: (cell newcdr)Fboundp
T if SYMBOL's value is not void.

arguments: (sym)Ffboundp
T if SYMBOL's function definition is not void.

arguments: (sym)Fmakunbound
Make SYMBOL's value be void.

arguments: (sym)Ffmakunbound
Make SYMBOL's function definition be void.

arguments: (sym)Fsymbol-function
Return SYMBOL's function definition.  Error if that is void.

arguments: (symbol)Fsymbol-plist
Return SYMBOL's property list.

arguments: (sym)Fsymbol-name
Return SYMBOL's name, a string.

arguments: (sym)Ffset
Set SYMBOL's function definition to NEWVAL, and return NEWVAL.

arguments: (sym newdef)Fdefalias
Set SYMBOL's function definition to NEWVAL, and return NEWVAL.
Associates the function with the current load file, if any.

arguments: (sym newdef)Fdefine-function
Set SYMBOL's function definition to NEWVAL, and return NEWVAL.
Associates the function with the current load file, if any.

arguments: (sym newdef)Fsetplist
Set SYMBOL's property list to NEWVAL, and return NEWVAL.

arguments: (sym newplist)Fsymbol-value
Return SYMBOL's value.  Error if that is void.

arguments: (sym)Fset
Set SYMBOL's value to NEWVAL, and return NEWVAL.

arguments: (sym newval)Fdefault-boundp
Return T if SYMBOL has a non-void default value.
This is the value that is seen in buffers that do not have their own values
for this variable.

arguments: (sym)Fdefault-value
Return SYMBOL's default value.
This is the value that is seen in buffers that do not have their own values
for this variable.  The default value is meaningful for variables with
local bindings in certain buffers.

arguments: (sym)Fset-default
Set SYMBOL's default value to VAL.  SYMBOL and VAL are evaluated.
The default value is seen in buffers that do not have their own values
for this variable.

arguments: (sym value)Fsetq-default
(setq-default SYM VAL SYM VAL ...): set each SYM's default value to its VAL.
VAL is evaluated; SYM is not.  The default value is seen in buffers that do
not have their own values for this variable.Fmake-variable-buffer-local
Make VARIABLE have a separate value for each buffer.
At any time, the value for the current buffer is in effect.
There is also a default value which is seen in any buffer which has not yet
set its own value.
Using `set' or `setq' to set the variable causes it to have a separate value
for the current buffer if it was previously using the default value.
The function `default-value' gets the default value and `set-default' sets it.

arguments: (sym)Fmake-local-variable
Make VARIABLE have a separate value in the current buffer.
Other buffers will continue to share a common default value.
See also `make-variable-buffer-local'.

If the variable is already arranged to become local when set,
this function causes a local value to exist for this buffer,
just as if the variable were set.

arguments: (sym)Fkill-local-variable
Make VARIABLE no longer have a separate value in the current buffer.
From now on the default value will apply in this buffer.

arguments: (sym)Findirect-function
Return the function at the end of OBJECT's function chain.
If OBJECT is a symbol, follow all function indirections and return the final
function binding.
If OBJECT is not a symbol, just return it.
Signal a void-function error if the final symbol is unbound.
Signal a cyclic-function-indirection error if there is a loop in the
function chain of symbols.

arguments: (object)Faref
Return the element of ARRAY at index INDEX.
ARRAY may be a vector or a string, or a byte-code object.  INDEX starts at 0.

arguments: (array idx)Faset
Store into the element of ARRAY at index INDEX the value NEWVAL.
ARRAY may be a vector or a string.  INDEX starts at 0.

arguments: (array idx newelt)F=
T if two args, both numbers or markers, are equal.

arguments: (num1 num2)F<
T if first arg is less than second arg.  Both must be numbers or markers.

arguments: (num1 num2)F>
T if first arg is greater than second arg.  Both must be numbers or markers.

arguments: (num1 num2)F<=
T if first arg is less than or equal to second arg.
Both must be numbers or markers.

arguments: (num1 num2)F>=
T if first arg is greater than or equal to second arg.
Both must be numbers or markers.

arguments: (num1 num2)F/=
T if first arg is not equal to second arg.  Both must be numbers or markers.

arguments: (num1 num2)Fzerop
T if NUMBER is zero.

arguments: (num)Fnumber-to-string
Convert NUM to a string by printing it in decimal.
Uses a minus sign if negative.
NUM may be an integer or a floating point number.

arguments: (num)Fstring-to-number
Convert STRING to a number by parsing it as a decimal number.
This parses both integers and floating point numbers.

arguments: (str)F+
Return sum of any number of arguments, which are numbers or markers.F-
Negate number or subtract numbers or markers.
With one arg, negates it.  With more than one arg,
subtracts all but the first from the first.F*
Returns product of any number of arguments, which are numbers or markers.F/
Returns first argument divided by all the remaining arguments.
The arguments must be numbers or markers.F%
Returns remainder of first arg divided by second.
Both must be numbers or markers.

arguments: (num1 num2)Fmax
Return largest of all the arguments (which must be numbers or markers).
The value is always a number; markers are converted to numbers.Fmin
Return smallest of all the arguments (which must be numbers or markers).
The value is always a number; markers are converted to numbers.Flogand
Return bitwise-and of all the arguments.
Arguments may be integers, or markers converted to integers.Flogior
Return bitwise-or of all the arguments.
Arguments may be integers, or markers converted to integers.Flogxor
Return bitwise-exclusive-or of all the arguments.
Arguments may be integers, or markers converted to integers.Fash
Return VALUE with its bits shifted left by COUNT.
If COUNT is negative, shifting is actually to the right.
In this case, the sign bit is duplicated.

arguments: (num1 num2)Flsh
Return VALUE with its bits shifted left by COUNT.
If COUNT is negative, shifting is actually to the right.
In this case,  zeros are shifted in on the left.

arguments: (num1 num2)F1+
Return NUMBER plus one.  NUMBER may be a number or a marker.
Markers are converted to integers.

arguments: (num)F1-
Return NUMBER minus one.  NUMBER may be a number or a marker.
Markers are converted to integers.

arguments: (num)Flognot
Return the bitwise complement of ARG.  ARG must be an integer.

arguments: (num)Fdirectory-files
Return a list of names of files in DIRECTORY.
There are three optional arguments:
If FULL is non-nil, absolute pathnames of the files are returned.
If MATCH is non-nil, only pathnames containing that regexp are returned.
If NOSORT is non-nil, the list is not sorted--its order is unpredictable.
 NOSORT is useful if you plan to sort the result yourself.

arguments: (dirname &optional full match nosort)Ffile-name-completion
Complete file name FILE in directory DIR.
Returns the longest string
common to all filenames in DIR that start with FILE.
If there is only one and FILE matches it exactly, returns t.
Returns nil if DIR contains no name starting with FILE.

arguments: (file dirname)Ffile-name-all-completions
Return a list of all completions of file name FILE in directory DIR.
These are all file names in directory DIR which begin with FILE.

arguments: (file dirname)Ffile-name-all-versions
Return a list of all versions of file name FILE in directory DIR.

arguments: (file dirname)Ffile-version-limit
Return the maximum number of versions allowed for FILE.
Returns nil if the file cannot be opened or if there is no version limit.

arguments: (filename)Ffile-attributes
Return a list of attributes of file FILENAME.
Value is nil if specified file cannot be opened.
Otherwise, list elements are:
 0. t for directory, string (name linked to) for symbolic link, or nil.
 1. Number of links to file.
 2. File uid.
 3. File gid.
 4. Last access time, as a list of two integers.
  First integer has high-order 16 bits of time, second has low 16 bits.
 5. Last modification time, likewise.
 6. Last status change time, likewise.
 7. Size in bytes (-1, if number is out of range).
 8. File modes, as a string of ten letters or dashes as in ls -l.
 9. t iff file's gid would change if file were deleted and recreated.
10. inode number.
11. Device number.

If file does not exist, returns nil.

arguments: (filename)Vcompletion-ignored-extensions
*Completion ignores filenames ending in any string in this list.
This variable does not affect lists of possible completions,
but does affect the commands that actually do completions.Fredraw-frame
Clear frame FRAME and output again what is supposed to appear on it.

arguments: (frame)Fredraw-frame
Clear frame FRAME and output again what is supposed to appear on it.

arguments: (frame)Fredraw-display
Clear and redisplay all visible frames.

arguments: ()Fopen-termscript
Start writing all terminal output to FILE as well as the terminal.
FILE = nil means just close any termscript file currently open.

arguments: (file)Fsend-string-to-terminal
Send STRING to the terminal without alteration.
Control characters in STRING will have terminal-dependent effects.

arguments: (str)Fding
Beep, or flash the screen.
Also, unless an argument is given,
terminate any keyboard macro currently executing.

arguments: (&optional arg)Fsleep-for
Pause, without updating display, for SECONDS seconds.
SECONDS may be a floating-point value, meaning that you can wait for a
fraction of a second.  Optional second arg MILLISECONDS specifies an
additional wait period, in milliseconds; this may be useful if your
Emacs was built without floating point support.
(Not all operating systems support waiting for a fraction of a second.)

arguments: (seconds &optional milliseconds)Fsit-for
Perform redisplay, then wait for SECONDS seconds or until input is available.
SECONDS may be a floating-point value, meaning that you can wait for a
fraction of a second.  Optional second arg MILLISECONDS specifies an
additional wait period, in milliseconds; this may be useful if your
Emacs was built without floating point support.
(Not all operating systems support waiting for a fraction of a second.)
Optional third arg non-nil means don't redisplay, just wait for input.
Redisplay is preempted as always if input arrives, and does not happen
if input is available before it starts.
Value is t if waited the full time with no input arriving.

arguments: (seconds &optional milliseconds nodisp)Vbaud-rate
The output baud rate of the terminal.
On most systems, changing this value will affect the amount of padding
and the other strategic decisions made during redisplay.Vinverse-video
*Non-nil means invert the entire frame display.
This means everything is in inverse video which otherwise would not be.Vvisible-bell
*Non-nil means try to flash the frame to represent a bell.Vno-redraw-on-reenter
*Non-nil means no need to redraw entire frame after suspending.
A non-nil value is useful if the terminal can automatically preserve
Emacs's frame display when you reenter Emacs.
It is up to you to set this variable if your terminal can do that.Vwindow-system
A symbol naming the window-system under which Emacs is running
(such as `x'), or nil if emacs is running on an ordinary terminal.Vwindow-system-version
The version number of the window system in use.
For X windows, this is 10 or 11.Vcursor-in-echo-area
Non-nil means put cursor in minibuffer, at end of any message there.Vglyph-table
Table defining how to output a glyph code to the frame.
If not nil, this is a vector indexed by glyph code to define the glyph.
Each element can be:
 integer: a glyph code which this glyph is an alias for.
 string: output this glyph using that string (not impl. in X windows).
 nil: this glyph mod 256 is char code to output,
    and this glyph / 256 is face code for X windows (see `x-set-face').Vstandard-display-table
Display table to use for buffers that specify none.
See `buffer-display-table' for more information.Vmin-skip-run
Minimum run length required for skipping matching characters in output.
This is used for tuning output.Fdocumentation
Return the documentation string of FUNCTION.
Unless a non-nil second argument is given, the
string is passed through `substitute-command-keys'.

arguments: (function &optional raw)Fdocumentation-property
Return the documentation string that is SYMBOL's PROP property.
This is like `get', but it can refer to strings stored in the
`etc/DOC' file; and if the value is a string, it is passed through
`substitute-command-keys'.  A non-nil third argument avoids this
translation.

arguments: (sym prop raw)FSnarf-documentation
Used during Emacs initialization, before dumping runnable Emacs,
to find pointers to doc strings stored in `etc/DOC...' and
record them in function definitions.
One arg, FILENAME, a string which does not include a directory.
The file is found in `../etc' now; found in the `data-directory'
when doc strings are referred to later in the dumped Emacs.

arguments: (filename)Fsubstitute-command-keys
Substitute key descriptions for command names in STRING.
Return a new string which is STRING with substrings of the form \=\[COMMAND]
replaced by either:  a keystroke sequence that will invoke COMMAND,
or "M-x COMMAND" if COMMAND is not on any keys.
Substrings of the form \=\{MAPVAR} are replaced by summaries
(made by describe-bindings) of the value of MAPVAR, taken as a keymap.
Substrings of the form \=\<MAPVAR> specify to use the value of MAPVAR
as the keymap for future \=\[COMMAND] substrings.
\=\= quotes the following character and is discarded;
thus, \=\=\=\= puts \=\= into the output, and \=\=\=\[ puts \=\[ into the output.

arguments: (str)Vinternal-doc-file-name
Name of file containing documentation strings of built-in symbols.Fchar-to-string
Convert arg CHAR to a one-character string containing that character.

arguments: (n)Fstring-to-char
Convert arg STRING to a character, the first character of that string.

arguments: (str)Fpoint
Return value of point, as an integer.
Beginning of buffer is position (point-min)

arguments: ()Fpoint-marker
Return value of point, as a marker object.

arguments: ()Fgoto-char
Set point to POSITION, a number or marker.
Beginning of buffer is position (point-min), end is (point-max).

arguments: (n)Fregion-beginning
Return position of beginning of region, as an integer.

arguments: ()Fregion-end
Return position of end of region, as an integer.

arguments: ()Fmark
Return this buffer's mark value as integer, or nil if no mark.
If you are using this in an editing command, you are most likely making
a mistake; see the documentation of `set-mark'.

arguments: ()Fmark-marker
Return this buffer's mark, as a marker object.
Watch out!  Moving this marker changes the mark position.
If you set the marker not to point anywhere, the buffer will have no mark.

arguments: ()Fset-mark
Set this buffer's mark to POS.  Don't use this function!
That is to say, don't use this function unless you want
the user to see that the mark has moved, and you want the previous
mark position to be lost.

Normally, when a new mark is set, the old one should go on the stack.
This is why most applications should use push-mark, not set-mark.

Novice programmers often try to use the mark for the wrong purposes.
The mark saves a location for the user's convenience.
Most editing commands should not alter the mark.
To remember a location for internal use in the Lisp program,
store it in a Lisp variable.  Example:

   (let ((beg (point))) (forward-line 1) (delete-region beg (point))).

arguments: (pos)Fsave-excursion
Save point, mark, and current buffer; execute BODY; restore those things.
Executes BODY just like `progn'.
The values of point, mark and the current buffer are restored
even in case of abnormal exit (throw or error).
The state of activation of the mark is also restored.Fbuffer-size
Return the number of characters in the current buffer.

arguments: ()Fpoint-min
Return the minimum permissible value of point in the current buffer.
This is 1, unless a clipping restriction is in effect.

arguments: ()Fpoint-min-marker
Return a marker to the minimum permissible value of point in this buffer.
This is the beginning, unless a clipping restriction is in effect.

arguments: ()Fpoint-max
Return the maximum permissible value of point in the current buffer.
This is (1+ (buffer-size)), unless a clipping restriction is in effect,
in which case it is less.

arguments: ()Fpoint-max-marker
Return a marker to the maximum permissible value of point in this buffer.
This is (1+ (buffer-size)), unless a clipping restriction is in effect,
in which case it is less.

arguments: ()Ffollowing-char
Return the character following point, as a number.
At the end of the buffer or accessible region, return 0.

arguments: ()Fpreceding-char
Return the character preceding point, as a number.
At the beginning of the buffer or accessible region, return 0.

arguments: ()Fbobp
Return T if point is at the beginning of the buffer.
If the buffer is narrowed, this means the beginning of the narrowed part.

arguments: ()Feobp
Return T if point is at the end of the buffer.
If the buffer is narrowed, this means the end of the narrowed part.

arguments: ()Fbolp
Return T if point is at the beginning of a line.

arguments: ()Feolp
Return T if point is at the end of a line.
`End of a line' includes point being at the end of the buffer.

arguments: ()Fchar-after
Return character in current buffer at position POS.
POS is an integer or a buffer pointer.
If POS is out of range, the value is nil.

arguments: (pos)Fuser-login-name
Return the name under which the user logged in, as a string.
This is based on the effective uid, not the real uid.
Also, if the environment variable USER or LOGNAME is set,
that determines the value of this function.

arguments: ()Fuser-real-login-name
Return the name of the user's real uid, as a string.
Differs from `user-login-name' when running under `su'.

arguments: ()Fuser-uid
Return the effective uid of Emacs, as an integer.

arguments: ()Fuser-real-uid
Return the real uid of Emacs, as an integer.

arguments: ()Fuser-full-name
Return the full name of the user logged in, as a string.

arguments: ()Fsystem-name
Return the name of the machine you are running on, as a string.

arguments: ()Fcurrent-time
Return the current time, as the number of seconds since 12:00 AM January 1970.
The time is returned as a list of three integers.  The first has the
most significant 16 bits of the seconds, while the second has the
least significant 16 bits.  The third integer gives the microsecond
count.

The microsecond count is zero on systems that do not provide
resolution finer than a second.

arguments: ()Fcurrent-time-string
Return the current time, as a human-readable string.
Programs can use this function to decode a time,
since the number of columns in each field is fixed.
The format is `Sun Sep 16 01:03:52 1973'.
If an argument is given, it specifies a time to format
instead of the current time.  The argument should have the form:
  (HIGH . LOW)
or the form:
  (HIGH LOW . IGNORED).
Thus, you can use times obtained from `current-time'
and from `file-attributes'.

arguments: (&optional specified-time)Fcurrent-time-zone
Return the offset and name for the local time zone.
This returns a list of the form (OFFSET NAME).
OFFSET is an integer number of seconds ahead of UTC (east of Greenwich).
    A negative value means west of Greenwich.
NAME is a string giving the name of the time zone.
If an argument is given, it specifies when the time zone offset is determined
instead of using the current time.  The argument should have the form:
  (HIGH . LOW)
or the form:
  (HIGH LOW . IGNORED).
Thus, you can use times obtained from `current-time'
and from `file-attributes'.

Some operating systems cannot provide all this information to Emacs;
in this case, `current-time-zone' returns a list containing nil for
the data it can't find.

arguments: (&optional specified-time)Finsert
Insert the arguments, either strings or characters, at point.
Point moves forward so that it ends up after the inserted text.
Any other markers at the point of insertion remain before the text.Finsert-before-markers
Insert strings or characters at point, relocating markers after the text.
Point moves forward so that it ends up after the inserted text.
Any other markers at the point of insertion also end up after the text.Finsert-char
Insert COUNT (second arg) copies of CHAR (first arg).
Point and all markers are affected as in the function `insert'.
Both arguments are required.

arguments: (chr count)Fbuffer-substring
Return the contents of part of the current buffer as a string.
The two arguments START and END are character positions;
they can be in either order.

arguments: (b e)Fbuffer-string
Return the contents of the current buffer as a string.

arguments: ()Finsert-buffer-substring
Insert before point a substring of the contents of buffer BUFFER.
BUFFER may be a buffer or a buffer name.
Arguments START and END are character numbers specifying the substring.
They default to the beginning and the end of BUFFER.

arguments: (buf &optional b e)Fcompare-buffer-substrings
Compare two substrings of two buffers; return result as number.
the value is -N if first string is less after N-1 chars,
+N if first string is greater after N-1 chars, or 0 if strings match.
Each substring is represented as three arguments: BUFFER, START and END.
That makes six args in all, three for each substring.

The value of `case-fold-search' in the current buffer
determines whether case is significant or ignored.

arguments: (buffer1 start1 end1 buffer2 start2 end2)Fsubst-char-in-region
From START to END, replace FROMCHAR with TOCHAR each time it occurs.
If optional arg NOUNDO is non-nil, don't record this change for undo
and don't mark the buffer as really changed.

arguments: (start end fromchar tochar &optional noundo)Ftranslate-region
From START to END, translate characters according to TABLE.
TABLE is a string; the Nth character in it is the mapping
for the character with code N.  Returns the number of characters changed.

arguments: (start end table)Fdelete-region
Delete the text between point and mark.
When called from a program, expects two arguments,
positions (integers or markers) specifying the stretch to be deleted.

arguments: (b e)Fwiden
Remove restrictions (narrowing) from current buffer.
This allows the buffer's full text to be seen and edited.

arguments: ()Fnarrow-to-region
Restrict editing in this buffer to the current region.
The rest of the text becomes temporarily invisible and untouchable
but is not deleted; if you save the buffer in a file, the invisible
text is included in the file.  \[widen] makes all visible again.
See also `save-restriction'.

When calling from a program, pass two arguments; positions (integers
or markers) bounding the text that should remain visible.

arguments: (b e)Fsave-restriction
Execute BODY, saving and restoring current buffer's restrictions.
The buffer's restrictions make parts of the beginning and end invisible.
(They are set up with `narrow-to-region' and eliminated with `widen'.)
This special form, `save-restriction', saves the current buffer's restrictions
when it is entered, and restores them when it is exited.
So any `narrow-to-region' within BODY lasts only until the end of the form.
The old restrictions settings are restored
even in case of abnormal exit (throw or error).

The value returned is the value of the last form in BODY.

`save-restriction' can get confused if, within the BODY, you widen
and then make changes outside the area within the saved restrictions.

Note: if you are using both `save-excursion' and `save-restriction',
use `save-excursion' outermost:
    (save-excursion (save-restriction ...))Fmessage
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.
If the first argument is nil, clear any existing message; let the
minibuffer contents show.Fformat
Format a string out of a control-string and arguments.
The first argument is a control string.
The other arguments are substituted into it to make the result, a string.
It may contain %-sequences meaning to substitute the next argument.
%s means print a string argument.  Actually, prints any object, with `princ'.
%d means print as number in decimal (%o octal, %x hex).
%c means print a number as a single character.
%S means print any object as an s-expression (using prin1).
  The argument used for %d, %o, %x or %c must be a number.
Use %% to put a single % into the output.Fchar-equal
Return t if two characters match, optionally ignoring case.
Both arguments must be characters (i.e. integers).
Case is ignored if `case-fold-search' is non-nil in the current buffer.

arguments: (c1 c2)Vsystem-name
The name of the machine Emacs is running on.Vuser-full-name
The full name of the user logged in.Vuser-name
The user's name, based on the effective uid.Vuser-real-name
The user's name, base upon the real uid.Finvocation-name
Return the program name that was used to run Emacs.
Any directory names are omitted.

arguments: ()Fkill-emacs
Exit the Emacs job and kill it.
If ARG is an integer, return ARG as the exit program code.
If ARG is a  string, stuff it as keyboard input.

The value of `kill-emacs-hook', if not void,
is a list of functions (of no args),
all of which are called before Emacs is actually killed.

arguments: (&optional arg)Fdump-emacs-data
Dump current state of Emacs into data file FILENAME.
This function exists on systems that use HAVE_SHM.

arguments: (intoname)Fdump-emacs
Dump current state of Emacs into executable file FILENAME.
Take symbols from SYMFILE (presumably the file you executed to run Emacs).
This is used in the file `loadup.el' when building Emacs.

Bind `command-line-processed' to nil before dumping,
if you want the dumped Emacs to process its command line
and announce itself normally when it is run.

arguments: (intoname symname)Vcommand-line-args
Args passed by shell to Emacs, as a list of strings.Vsystem-type
Value is symbol indicating type of operating system you are using.Vnoninteractive
Non-nil means Emacs is running without interactive terminal.Vkill-emacs-hook
Hook to be run whenever kill-emacs is called.
Since kill-emacs may be invoked when the terminal is disconnected (or
in other similar situations), functions placed on this hook should not
expect to be able to interact with the user.Vemacs-priority
Priority for Emacs to run at.
This value is effective only if set before Emacs is dumped,
and only if the Emacs executable is installed with setuid to permit
it to change priority.  (Emacs sets its uid back to the real uid.)Ffilesystem-type
Return a string identifying the filesystem type of PATH.
Filesystem types include FAT, HPFS, LAN, CDFS and NFS.

arguments: (string)Ffile-name-valid-p
Return t if STRING is a valid file name.
Whether a file name is valid or not depends on the file system.
This is a special feature of GNU Emacs for emx.

arguments: (string)Fkeyboard-type
Return information about the keyboard.
The value is a list of the form (COUNTRY SUBCOUNTRY CODEPAGE), where
  COUNTRY is the country code of the keyboard layout (a string),
    for instance "US".
  SUBCOUNTRY is the subcountry code (a string), for instance "103 ".
  CODEPAGE is the codepage (a number), on which the current keyboard
    translation table is based, for instance 437.
This function is currently implemented under OS/2 only.
If the keyboard information cannot be retrieved (because Emacs is
running under MS-DOS, for instance), nil is returned.

arguments: ()Femacs-priority
Set the priority of the Emacs process.
PCLASS selects the priority class.  Possible values are
  nil (no change),
  regular (regular priority class -- this is the OS/2 default,
    a priority boost is applied if the process is in the foreground), and
  foreground-server (fixed-high priority class -- use with care).
PLEVEL is nil (same as 0) or a number between 0 and 31 which indicates
  the priority level within the priority class.  Level 31 has the highest
  priority in each class, the default value assigned by OS/2 is 0.
The priority is inherited by child processes!
This function is implemented under OS/2 only.

arguments: (pclass &optional plevel)Vemx-shell-regexp
*Regular expression for detecting OS/2 shells which require
conversion of command line options.  If this regular expression
matches the command passed to call-process, a first argument of
-c is translated to /c.For
Eval args until one of them yields non-nil, then return that value.
The remaining args are not evalled at all.
If all args return nil, return nil.Fand
Eval args until one of them yields nil, then return nil.
The remaining args are not evalled at all.
If no arg yields nil, return the last arg's value.Fif
(if COND THEN ELSE...): if COND yields non-nil, do THEN, else do ELSE...
Returns the value of THEN or the value of the last of the ELSE's.
THEN must be one expression, but ELSE... can be zero or more expressions.
If COND yields nil, and there are no ELSE's, the value is nil.Fcond
(cond CLAUSES...): try each clause until one succeeds.
Each clause looks like (CONDITION BODY...).  CONDITION is evaluated
and, if the value is non-nil, this clause succeeds:
then the expressions in BODY are evaluated and the last one's
value is the value of the cond-form.
If no clause succeeds, cond returns nil.
If a clause has one element, as in (CONDITION),
CONDITION's value if non-nil is returned from the cond-form.Fprogn
(progn BODY...): eval BODY forms sequentially and return value of last one.Fprog1
(prog1 FIRST BODY...): eval FIRST and BODY sequentially; value from FIRST.
The value of FIRST is saved during the evaluation of the remaining args,
whose values are discarded.Fprog2
(prog1 X Y BODY...): eval X, Y and BODY sequentially; value from Y.
The value of Y is saved during the evaluation of the remaining args,
whose values are discarded.Fsetq
(setq SYM VAL SYM VAL ...): set each SYM to the value of its VAL.
The SYMs are not evaluated.  Thus (setq x y) sets x to the value of y.
Each SYM is set before the next VAL is computed.Fquote
Return the argument, without evaluating it.  `(quote x)' yields `x'.Ffunction
Like `quote', but preferred for objects which are functions.
In byte compilation, `function' causes its argument to be compiled.
`quote' cannot do that.Finteractive-p
Return t if function in which this appears was called interactively.
This means that the function was called with call-interactively (which
includes being called as the binding of a key)
and input is currently coming from the keyboard (not in keyboard macro).

arguments: ()Fdefun
(defun NAME ARGLIST [DOCSTRING] BODY...): define NAME as a function.
The definition is (lambda ARGLIST [DOCSTRING] BODY...).
See also the function `interactive'.Fdefmacro
(defmacro NAME ARGLIST [DOCSTRING] BODY...): define NAME as a macro.
The definition is (macro lambda ARGLIST [DOCSTRING] BODY...).
When the macro is called, as in (NAME ARGS...),
the function (lambda ARGLIST BODY...) is applied to
the list ARGS... as it appears in the expression,
and the result should be a form to be evaluated instead of the original.Fdefvar
(defvar SYMBOL INITVALUE DOCSTRING): define SYMBOL as a variable.
You are not required to define a variable in order to use it,
but the definition can supply documentation and an initial value
in a way that tags can recognize.

INITVALUE is evaluated, and used to set SYMBOL, only if SYMBOL's value is void.
If SYMBOL is buffer-local, its default value is what is set;
 buffer-local values are not affected.
INITVALUE and DOCSTRING are optional.
If DOCSTRING starts with *, this variable is identified as a user option.
 This means that M-x set-variable and M-x edit-options recognize it.
If INITVALUE is missing, SYMBOL's value is not set.Fdefconst
(defconst SYMBOL INITVALUE DOCSTRING): define SYMBOL as a constant variable.
The intent is that programs do not change this value, but users may.
Always sets the value of SYMBOL to the result of evalling INITVALUE.
If SYMBOL is buffer-local, its default value is what is set;
 buffer-local values are not affected.
DOCSTRING is optional.
If DOCSTRING starts with *, this variable is identified as a user option.
 This means that M-x set-variable and M-x edit-options recognize it.

Note: do not use `defconst' for user options in libraries that are not
normally loaded, since it is useful for users to be able to specify
their own values for such variables before loading the library.
Since `defconst' unconditionally assigns the variable,
it would override the user's choice.Fuser-variable-p
Returns t if VARIABLE is intended to be set and modified by users.
(The alternative is a variable used internally in a Lisp program.)
Determined by whether the first character of the documentation
for the variable is "*"

arguments: (variable)Flet*
(let* VARLIST BODY...): bind variables according to VARLIST then eval BODY.
The value of the last form in BODY is returned.
Each element of VARLIST is a symbol (which is bound to nil)
or a list (SYMBOL VALUEFORM) (which binds SYMBOL to the value of VALUEFORM).
Each VALUEFORM can refer to the symbols already bound by this VARLIST.Flet
(let VARLIST BODY...): bind variables according to VARLIST then eval BODY.
The value of the last form in BODY is returned.
Each element of VARLIST is a symbol (which is bound to nil)
or a list (SYMBOL VALUEFORM) (which binds SYMBOL to the value of VALUEFORM).
All the VALUEFORMs are evalled before any symbols are bound.Fwhile
(while TEST BODY...): if TEST yields non-nil, eval BODY... and repeat.
The order of execution is thus TEST, BODY, TEST, BODY and so on
until TEST returns nil.Fmacroexpand
Return result of expanding macros at top level of FORM.
If FORM is not a macro call, it is returned unchanged.
Otherwise, the macro is expanded and the expansion is considered
in place of FORM.  When a non-macro-call results, it is returned.

The second optional arg ENVIRONMENT species an environment of macro
definitions to shadow the loaded ones for use in file byte-compilation.

arguments: (form &optional env)Fcatch
(catch TAG BODY...): eval BODY allowing nonlocal exits using `throw'.
TAG is evalled to get the tag to use.  Then the BODY is executed.
Within BODY, (throw TAG) with same tag exits BODY and exits this `catch'.
If no throw happens, `catch' returns the value of the last BODY form.
If a throw happens, it specifies the value to return from `catch'.Fthrow
(throw TAG VALUE): throw to the catch for TAG and return VALUE from it.
Both TAG and VALUE are evalled.

arguments: (tag val)Funwind-protect
Do BODYFORM, protecting with UNWINDFORMS.
Usage looks like (unwind-protect BODYFORM UNWINDFORMS...).
If BODYFORM completes normally, its value is returned
after executing the UNWINDFORMS.
If BODYFORM exits nonlocally, the UNWINDFORMS are executed anyway.Fcondition-case
Regain control when an error is signaled.
Usage looks like (condition-case VAR BODYFORM HANDLERS...).
executes BODYFORM and returns its value if no error happens.
Each element of HANDLERS looks like (CONDITION-NAME BODY...)
where the BODY is made of Lisp expressions.

A handler is applicable to an error
if CONDITION-NAME is one of the error's condition names.
If an error happens, the first applicable handler is run.

When a handler handles an error,
control returns to the condition-case and the handler BODY... is executed
with VAR bound to (SIGNALED-CONDITIONS . SIGNAL-DATA).
VAR may be nil; then you do not get access to the signal information.

The value of the last BODY form is returned from the condition-case.
See also the function `signal' for more info.Fsignal
Signal an error.  Args are SIGNAL-NAME, and associated DATA.
This function does not return.

A signal name is a symbol with an `error-conditions' property
that is a list of condition names.
A handler for any of those names will get to handle this signal.
The symbol `error' should normally be one of them.

DATA should be a list.  Its elements are printed as part of the error message.
If the signal is handled, DATA is made available to the handler.
See also the function `condition-case'.

arguments: (sig data)Fcommandp
T if FUNCTION makes provisions for interactive calling.
This means it contains a description for how to read arguments to give it.
The value is nil for an invalid function or a symbol with no function
definition.

Interactively callable functions include strings and vectors (treated
as keyboard macros), lambda-expressions that contain a top-level call
to `interactive', autoload definitions made by `autoload' with non-nil
fourth argument, and some of the built-in functions of Lisp.

Also, a symbol satisfies `commandp' if its function definition does so.

arguments: (function)Fautoload
Define FUNCTION to autoload from FILE.
FUNCTION is a symbol; FILE is a file name string to pass to `load'.
Third arg DOCSTRING is documentation for the function.
Fourth arg INTERACTIVE if non-nil says function can be called interactively.
Fifth arg TYPE indicates the type of the object:
   nil or omitted says FUNCTION is a function,
   `keymap' says FUNCTION is really a keymap, and
   `macro' or t says FUNCTION is really a macro.
Third through fifth args give info about the real definition.
They default to nil.
If FUNCTION is already defined other than as an autoload,
this does nothing and returns nil.

arguments: (function file &optional docstring interactive type)Feval
Evaluate FORM and return its value.

arguments: (form)Fapply
Call FUNCTION with our remaining args, using our last arg as list of args.
Thus, (apply '+ 1 2 '(3 4)) returns 10.Ffuncall
Call first argument as a function, passing remaining arguments to it.
Thus, (funcall 'cons 'x 'y) returns (x . y).Fbacktrace-debug
Set the debug-on-exit flag of eval frame LEVEL levels down to FLAG.
The debugger is entered when that frame exits, if the flag is non-nil.

arguments: (level flag)Fbacktrace
Print a trace of Lisp function calls currently active.
Output stream used is value of `standard-output'.

arguments: ()Fbacktrace-frame
Return the function and arguments N frames up from current execution point.
If that frame has not evaluated the arguments yet (or is a special form),
the value is (nil FUNCTION ARG-FORMS...).
If that frame has evaluated its arguments and called its function already,
the value is (t FUNCTION ARG-VALUES...).
A &rest arg is represented as the tail of the list ARG-VALUES.
FUNCTION is whatever was supplied as car of evaluated list,
or a lambda expression for macro calls.
If N is more than the number of frames, the value is nil.

arguments: (nframes)Vmax-specpdl-size
Limit on number of Lisp variable bindings & unwind-protects before error.Vmax-lisp-eval-depth
Limit on depth in `eval', `apply' and `funcall' before error.
This limit is to catch infinite recursions for you before they cause
actual stack overflow in C, which would be fatal for Emacs.
You can safely make it considerably larger than its default value,
if that proves inconveniently small.Vquit-flag
Non-nil causes `eval' to abort, unless `inhibit-quit' is non-nil.
Typing C-G sets `quit-flag' non-nil, regardless of `inhibit-quit'.Vinhibit-quit
Non-nil inhibits C-g quitting from happening immediately.
Note that `quit-flag' will still be set by typing C-g,
so a quit will be signalled as soon as `inhibit-quit' is nil.
To prevent this happening, set `quit-flag' to nil
before making `inhibit-quit' nil.Vstack-trace-on-error
*Non-nil means automatically display a backtrace buffer
after any error that is handled by the editor command loop.
If the value is a list, an error only means to display a backtrace
if one of its condition symbols appears in the list.Vdebug-on-error
*Non-nil means enter debugger if an error is signaled.
Does not apply to errors handled by `condition-case'.
If the value is a list, an error only means to enter the debugger
if one of its condition symbols appears in the list.
See also variable `debug-on-quit'.Vdebug-on-quit
*Non-nil means enter debugger if quit is signaled (C-G, for example).
Does not apply if quit is handled by a `condition-case'.Vdebug-on-next-call
Non-nil means enter debugger before next `eval', `apply' or `funcall'.Vdebugger
Function to call to invoke debugger.
If due to frame exit, args are `exit' and the value being returned;
 this function's value will be returned instead of that.
If due to error, args are `error' and a list of the args to `signal'.
If due to `apply' or `funcall' entry, one arg, `lambda'.
If due to `eval' entry, one arg, t.Vmocklisp-arguments
While in a mocklisp function, the list of its unevaluated args.Vrun-hooks
Set to the function `run-hooks', if that function has been defined.
Otherwise, nil (in a bare Emacs without preloaded Lisp code).Ffind-file-name-handler
Return FILENAME's handler function, if its syntax is handled specially.
Otherwise, return nil.
A file name is handled if one of the regular expressions in
`file-name-handler-alist' matches it.

arguments: (filename)Ffile-name-directory
Return the directory component in file name NAME.
Return nil if NAME does not include a directory.
Otherwise return a directory spec.
Given a Unix syntax file name, returns a string ending in slash;
on VMS, perhaps instead a string ending in `:', `]' or `>'.

arguments: (file)Ffile-name-nondirectory
Return file name NAME sans its directory.
For example, in a Unix-syntax file name,
this is everything after the last slash,
or the entire name if it contains no slash.

arguments: (file)Funhandled-file-name-directory
Return a directly usable directory name somehow associated with FILENAME.
A `directly usable' directory name is one that may be used without the
intervention of any file handler.
If FILENAME is a directly usable file itself, return
(file-name-directory FILENAME).
The `call-process' and `start-process' functions use this function to
get a current directory to run processes in.

arguments: (filename)Ffile-name-as-directory
Return a string representing file FILENAME interpreted as a directory.
This operation exists because a directory is also a file, but its name as
a directory is different from its name as a file.
The result can be used as the value of `default-directory'
or passed as second argument to `expand-file-name'.
For a Unix-syntax file name, just appends a slash.
On VMS, converts "[X]FOO.DIR" to "[X.FOO]", etc.

arguments: (file)Fdirectory-file-name
Returns the file name of the directory named DIR.
This is the name of the file that holds the data for the directory DIR.
This operation exists because a directory is also a file, but its name as
a directory is different from its name as a file.
In Unix-syntax, this function just removes the final slash.
On VMS, given a VMS-syntax directory name such as "[X.Y]",
it returns a file name such as "[X]Y.DIR.1".

arguments: (directory)Fmake-temp-name
Generate temporary file name (string) starting with PREFIX (a string).
The Emacs process number forms part of the result,
so there is no danger of generating a name being used by another process.

arguments: (prefix)Fexpand-file-name
Convert FILENAME to absolute, and canonicalize it.
Second arg DEFAULT is directory to start with if FILENAME is relative
 (does not start with slash); if DEFAULT is nil or missing,
the current buffer's value of default-directory is used.
Path components that are `.' are removed, and 
path components followed by `..' are removed, along with the `..' itself;
note that these simplifications are done without checking the resulting
paths in the file system.
An initial `~/' expands to your home directory.
An initial `~USER/' expands to USER's home directory.
See also the function `substitute-in-file-name'.

arguments: (name &optional default)Fsubstitute-in-file-name
Substitute environment variables referred to in FILENAME.
`$FOO' where FOO is an environment variable name means to substitute
the value of that variable.  The variable name should be terminated
with a character not a letter, digit or underscore; otherwise, enclose
the entire variable name in braces.
If `/~' appears, all of FILENAME through that `/' is discarded.

On VMS, `$' substitution is not done; this function does little and only
duplicates what `expand-file-name' does.

arguments: (string)Fcopy-file
Copy FILE to NEWNAME.  Both args must be strings.
Signals a `file-already-exists' error if file NEWNAME already exists,
unless a third argument OK-IF-ALREADY-EXISTS is supplied and non-nil.
A number as third arg means request confirmation if NEWNAME already exists.
This is what happens in interactive use with M-x.
Fourth arg KEEP-TIME non-nil means give the new file the same
last-modified time as the old one.  (This works on only some systems.)
A prefix arg makes KEEP-TIME non-nil.

arguments: (filename newname &optional ok-if-already-exists keep-date)Fmake-directory-internal
Create a directory.  One argument, a file name string.

arguments: (dirname)Fdelete-directory
Delete a directory.  One argument, a file name string.

arguments: (dirname)Fdelete-file
Delete specified file.  One argument, a file name string.
If file has multiple names, it continues to exist with the other names.

arguments: (filename)Frename-file
Rename FILE as NEWNAME.  Both args strings.
If file has names other than FILE, it continues to have those names.
Signals a `file-already-exists' error if a file NEWNAME already exists
unless optional third argument OK-IF-ALREADY-EXISTS is non-nil.
A number as third arg means request confirmation if NEWNAME already exists.
This is what happens in interactive use with M-x.

arguments: (filename newname &optional ok-if-already-exists)Fadd-name-to-file
Give FILE additional name NEWNAME.  Both args strings.
Signals a `file-already-exists' error if a file NEWNAME already exists
unless optional third argument OK-IF-ALREADY-EXISTS is non-nil.
A number as third arg means request confirmation if NEWNAME already exists.
This is what happens in interactive use with M-x.

arguments: (filename newname &optional ok-if-already-exists)Fmake-symbolic-link
Make a symbolic link to FILENAME, named LINKNAME.  Both args strings.
Signals a `file-already-exists' error if a file NEWNAME already exists
unless optional third argument OK-IF-ALREADY-EXISTS is non-nil.
A number as third arg means request confirmation if NEWNAME already exists.
This happens for interactive use with M-x.

arguments: (filename linkname &optional ok-if-already-exists)Fdefine-logical-name
Define the job-wide logical name NAME to have the value STRING.
If STRING is nil or a null string, the logical name NAME is deleted.

arguments: (varname string)Fsysnetunam
Open a network connection to PATH using LOGIN as the login string.

arguments: (path login)Ffile-name-absolute-p
Return t if file FILENAME specifies an absolute path name.
On Unix, this is a name starting with a `/' or a `~'.

arguments: (filename)Ffile-exists-p
Return t if file FILENAME exists.  (This does not mean you can read it.)
See also `file-readable-p' and `file-attributes'.

arguments: (filename)Ffile-executable-p
Return t if FILENAME can be executed by you.
For a directory, this means you can access files in that directory.

arguments: (filename)Ffile-readable-p
Return t if file FILENAME exists and you can read it.
See also `file-exists-p' and `file-attributes'.

arguments: (filename)Ffile-symlink-p
If file FILENAME is the name of a symbolic link
returns the name of the file to which it is linked.
Otherwise returns NIL.

arguments: (filename)Ffile-writable-p
Return t if file FILENAME can be written or created by you.

arguments: (filename)Ffile-directory-p
Return t if file FILENAME is the name of a directory as a file.
A directory name spec may be given instead; then the value is t
if the directory so specified exists and really is a directory.

arguments: (filename)Ffile-accessible-directory-p
Return t if file FILENAME is the name of a directory as a file,
and files in that directory can be opened by you.  In order to use a
directory as a buffer's current directory, this predicate must return true.
A directory name spec may be given instead; then the value is t
if the directory so specified exists and really is a readable and
searchable directory.

arguments: (filename)Ffile-modes
Return mode bits of FILE, as an integer.

arguments: (filename)Fset-file-modes
Set mode bits of FILE to MODE (an integer).
Only the 12 low bits of MODE are used.

arguments: (filename mode)Fset-default-file-modes
Set the file permission bits for newly created files.
The argument MODE should be an integer; only the low 9 bits are used.
This setting is inherited by subprocesses.

arguments: (mode)Fdefault-file-modes
Return the default file protection for created files.
The value is an integer.

arguments: ()Funix-sync
Tell Unix to finish all pending disk updates.

arguments: ()Ffile-newer-than-file-p
Return t if file FILE1 is newer than file FILE2.
If FILE1 does not exist, the answer is nil;
otherwise, if FILE2 does not exist, the answer is t.

arguments: (file1 file2)Finsert-file-contents
Insert contents of file FILENAME after point.
Returns list of absolute file name and length of data inserted.
If second argument VISIT is non-nil, the buffer's visited filename
and last save file modtime are set, and it is marked unmodified.
If visiting and the file does not exist, visiting is completed
before the error is signaled.

The optional third and fourth arguments BEG and END
specify what portion of the file to insert.
If VISIT is non-nil, BEG and END must be nil.

arguments: (filename &optional visit beg end)Fwrite-region
Write current region into specified file.
When called from a program, takes three arguments:
START, END and FILENAME.  START and END are buffer positions.
Optional fourth argument APPEND if non-nil means
  append to existing file contents (if any).
Optional fifth argument VISIT if t means
  set the last-save-file-modtime of buffer to this file's modtime
  and mark buffer not modified.
If VISIT is a string, it is a second file name;
  the output goes to FILENAME, but the buffer is marked as visiting VISIT.
  VISIT is also the file name to lock and unlock for clash detection.
If VISIT is neither t nor nil nor a string,
  that means do not print the "Wrote file" message.
Kludgy feature: if START is a string, then that string is written
to the file, instead of any buffer contents, and END is ignored.

arguments: (start end filename &optional append visit)Fverify-visited-file-modtime
Return t if last mod time of BUF's visited file matches what BUF records.
This means that the file has not been changed since it was visited or saved.

arguments: (buf)Fclear-visited-file-modtime
Clear out records of last mod time of visited file.
Next attempt to save will certainly not complain of a discrepancy.

arguments: ()Fvisited-file-modtime
Return the current buffer's recorded visited file modification time.
The value is a list of the form (HIGH . LOW), like the time values
that `file-attributes' returns.

arguments: ()Fset-visited-file-modtime
Update buffer's recorded modification time from the visited file's time.
Useful if the buffer was not read from the file normally
or if the file itself has been changed for some known benign reason.
An argument specifies the modification time value to use
(instead of that of the visited file), in the form of a list
(HIGH . LOW) or (HIGH LOW).

arguments: (&optional time-list)Fdo-auto-save
Auto-save all buffers that need it.
This is all buffers that have auto-saving enabled
and are changed since last auto-saved.
Auto-saving writes the buffer into a file
so that your editing is not lost if the system crashes.
This file is not the file you visited; that changes only when you save.

Non-nil first argument means do not print any message if successful.
Non-nil second argument means save only current buffer.

arguments: (&optional no-message current-only)Fset-buffer-auto-saved
Mark current buffer as auto-saved with its current text.
No auto-save file will be written until the buffer changes again.

arguments: ()Frecent-auto-save-p
Return t if buffer has been auto-saved since last read in or saved.

arguments: ()Fread-file-name-internal
Internal subroutine for read-file-name.  Do not call this.

arguments: (string dir action)Fread-file-name
Read file name, prompting with PROMPT and completing in directory DIR.
Value is not expanded---you must call `expand-file-name' yourself.
Default name to DEFAULT if user enters a null string.
 (If DEFAULT is omitted, the visited file name is used.)
Fourth arg MUSTMATCH non-nil means require existing file's name.
 Non-nil and non-t means also require confirmation after completion.
Fifth arg INITIAL specifies text to start with.
DIR defaults to current buffer's directory default.

arguments: (prompt &optional dir default mustmatch initial)Fread-file-name
Read file name, prompting with PROMPT and completing in directory DIR.
Value is not expanded---you must call `expand-file-name' yourself.
Default name to DEFAULT if user enters a null string.
 (If DEFAULT is omitted, the visited file name is used.)
Fourth arg MUSTMATCH non-nil means require existing file's name.
 Non-nil and non-t means also require confirmation after completion.
Fifth arg INITIAL specifies text to start with.
DIR defaults to current buffer's directory default.

arguments: (prompt &optional dir default mustmatch initial)Vinsert-default-directory
*Non-nil means when reading a filename start with default dir in minibuffer.Vvms-stmlf-recfm
*Non-nil means write new files with record format `stmlf'.
nil means use format `var'.  This variable is meaningful only on VMS.Vemx-binary-mode
Non-nil means read and write files in `binary mode'.
nil means use `text mode'.  This variable is meaningful only on emx.Vfile-name-handler-alist
*Alist of elements (REGEXP . HANDLER) for file names handled specially.
If a file name matches REGEXP, then all I/O on that file is done by calling
HANDLER.

The first argument given to HANDLER is the name of the I/O primitive
to be handled; the remaining arguments are the arguments that were
passed to that primitive.  For example, if you do
    (file-exists-p FILENAME)
and FILENAME is handled by HANDLER, then HANDLER is called like this:
    (funcall HANDLER 'file-exists-p FILENAME)
The function `find-file-name-handler' checks this list for a handler
for its argument.Flock-buffer
Lock FILE, if current buffer is modified.
FILE defaults to current buffer's visited file,
or else nothing is done if current buffer isn't visiting a file.

arguments: (&optional fn)Funlock-buffer
Unlock the file visited in the current buffer,
if it should normally be locked.

arguments: ()Ffile-locked-p
Return nil if the FILENAME is not locked,
t if it is locked by you, else a string of the name of the locker.

arguments: (&optional fn)Facos
Return the inverse cosine of ARG.

arguments: (arg)Fasin
Return the inverse sine of ARG.

arguments: (arg)Fatan
Return the inverse tangent of ARG.

arguments: (arg)Fcos
Return the cosine of ARG.

arguments: (arg)Fsin
Return the sine of ARG.

arguments: (arg)Ftan
Return the tangent of ARG.

arguments: (arg)Fbessel-j0
Return the bessel function j0 of ARG.

arguments: (arg)Fbessel-j1
Return the bessel function j1 of ARG.

arguments: (arg)Fbessel-jn
Return the order N bessel function output jn of ARG.
The first arg (the order) is truncated to an integer.

arguments: (arg1 arg2)Fbessel-y0
Return the bessel function y0 of ARG.

arguments: (arg)Fbessel-y1
Return the bessel function y1 of ARG.

arguments: (arg)Fbessel-yn
Return the order N bessel function output yn of ARG.
The first arg (the order) is truncated to an integer.

arguments: (arg1 arg2)Ferf
Return the mathematical error function of ARG.

arguments: (arg)Ferfc
Return the complementary error function of ARG.

arguments: (arg)Flog-gamma
Return the log gamma of ARG.

arguments: (arg)Fcube-root
Return the cube root of ARG.

arguments: (arg)Fexp
Return the exponential base e of ARG.

arguments: (arg)Fexpt
Return the exponential X ** Y.

arguments: (arg1 arg2)Flog
Return the natural logarithm of ARG.
If second optional argument BASE is given, return log ARG using that base.

arguments: (arg &optional base)Flog10
Return the logarithm base 10 of ARG.

arguments: (arg)Fsqrt
Return the square root of ARG.

arguments: (arg)Facosh
Return the inverse hyperbolic cosine of ARG.

arguments: (arg)Fasinh
Return the inverse hyperbolic sine of ARG.

arguments: (arg)Fatanh
Return the inverse hyperbolic tangent of ARG.

arguments: (arg)Fcosh
Return the hyperbolic cosine of ARG.

arguments: (arg)Fsinh
Return the hyperbolic sine of ARG.

arguments: (arg)Ftanh
Return the hyperbolic tangent of ARG.

arguments: (arg)Fabs
Return the absolute value of ARG.

arguments: (arg)Ffloat
Return the floating point number equal to ARG.

arguments: (arg)Flogb
Returns the integer not greater than the base 2 log of the magnitude of ARG.
This is the same as the exponent of a float.

arguments: (arg)Fceiling
Return the smallest integer no less than ARG.  (Round toward +inf.)

arguments: (arg)Ffloor
Return the largest integer no greater than ARG.  (Round towards -inf.)

arguments: (arg)Fround
Return the nearest integer to ARG.

arguments: (arg)Ftruncate
Truncate a floating point number to an int.
Rounds the value toward zero.

arguments: (arg)Ffceiling
Return the smallest integer no less than ARG, as a float.
(Round toward +inf.)

arguments: (arg)Fffloor
Return the largest integer no greater than ARG, as a float.
(Round towards -inf.)

arguments: (arg)Ffround
Return the nearest integer to ARG, as a float.

arguments: (arg)Fftruncate
Truncate a floating point number to an integral float value.
Rounds the value toward zero.

arguments: (arg)Fidentity
Return the argument unchanged.

arguments: (arg)Frandom
Return a pseudo-random number.
On most systems all integers representable in Lisp are equally likely.
  This is 24 bits' worth.
With argument N, return random number in interval [0,N).
With argument t, set the random number seed from the current time and pid.

arguments: (&optional limit)Flength
Return the length of vector, list or string SEQUENCE.
A byte-code function object is also allowed.

arguments: (obj)Fstring-equal
T if two strings have identical contents.
Case is significant.
Symbols are also allowed; their print names are used instead.

arguments: (s1 s2)Fstring-lessp
T if first arg string is less than second in lexicographic order.
Case is significant.
Symbols are also allowed; their print names are used instead.

arguments: (s1 s2)Fappend
Concatenate all the arguments and make the result a list.
The result is a list whose elements are the elements of all the arguments.
Each argument may be a list, vector or string.
The last argument is not copied, just used as the tail of the new list.Fconcat
Concatenate all the arguments and make the result a string.
The result is a string whose elements are the elements of all the arguments.
Each argument may be a string, a list of numbers, or a vector of numbers.Fvconcat
Concatenate all the arguments and make the result a vector.
The result is a vector whose elements are the elements of all the arguments.
Each argument may be a list, vector or string.Fcopy-sequence
Return a copy of a list, vector or string.
The elements of a list or vector are not copied; they are shared
with the original.

arguments: (arg)Fcopy-alist
Return a copy of ALIST.
This is an alist which represents the same mapping from objects to objects,
but does not share the alist structure with ALIST.
The objects mapped (cars and cdrs of elements of the alist)
are shared, however.
Elements of ALIST that are not conses are also shared.

arguments: (alist)Fsubstring
Return a substring of STRING, starting at index FROM and ending before TO.
TO may be nil or omitted; then the substring runs to the end of STRING.
If FROM or TO is negative, it counts from the end.

arguments: (string from &optional to)Fnthcdr
Take cdr N times on LIST, returns the result.

arguments: (n list)Fnth
Return the Nth element of LIST.
N counts from zero.  If LIST is not that long, nil is returned.

arguments: (n list)Felt
Return element of SEQUENCE at index N.

arguments: (seq n)Fmember
Return non-nil if ELT is an element of LIST.  Comparison done with EQUAL.
The value is actually the tail of LIST whose car is ELT.

arguments: (elt list)Fmemq
Return non-nil if ELT is an element of LIST.  Comparison done with EQ.
The value is actually the tail of LIST whose car is ELT.

arguments: (elt list)Fassq
Return non-nil if ELT is `eq' to the car of an element of LIST.
The value is actually the element of LIST whose car is ELT.
Elements of LIST that are not conses are ignored.

arguments: (key list)Fassoc
Return non-nil if ELT is `equal' to the car of an element of LIST.
The value is actually the element of LIST whose car is ELT.

arguments: (key list)Frassq
Return non-nil if ELT is `eq' to the cdr of an element of LIST.
The value is actually the element of LIST whose cdr is ELT.

arguments: (key list)Fdelq
Delete by side effect any occurrences of ELT as a member of LIST.
The modified LIST is returned.  Comparison is done with `eq'.
If the first member of LIST is ELT, there is no way to remove it by side effect;
therefore, write `(setq foo (delq element foo))'
to be sure of changing the value of `foo'.

arguments: (elt list)Fdelete
Delete by side effect any occurrences of ELT as a member of LIST.
The modified LIST is returned.  Comparison is done with `equal'.
If the first member of LIST is ELT, there is no way to remove it by side effect;
therefore, write `(setq foo (delete element foo))'
to be sure of changing the value of `foo'.

arguments: (elt list)Fnreverse
Reverse LIST by modifying cdr pointers.
Returns the beginning of the reversed list.

arguments: (list)Freverse
Reverse LIST, copying.  Returns the beginning of the reversed list.
See also the function `nreverse', which is used more often.

arguments: (list)Fsort
Sort LIST, stably, comparing elements using PREDICATE.
Returns the sorted list.  LIST is modified by side effects.
PREDICATE is called with two elements of LIST, and should return T
if the first element is "less" than the second.

arguments: (list pred)Fget
Return the value of SYMBOL's PROPNAME property.
This is the last VALUE stored with `(put SYMBOL PROPNAME VALUE)'.

arguments: (sym prop)Fput
Store SYMBOL's PROPNAME property with value VALUE.
It can be retrieved with `(get SYMBOL PROPNAME)'.

arguments: (sym prop val)Fequal
T if two Lisp objects have similar structure and contents.
They must have the same data type.
Conses are compared by comparing the cars and the cdrs.
Vectors and strings are compared element by element.
Numbers are compared by value, but integers cannot equal floats.
 (Use `=' if you want integers and floats to be able to be equal.)
Symbols must match exactly.

arguments: (o1 o2)Ffillarray
Store each element of ARRAY with ITEM.  ARRAY is a vector or string.

arguments: (array item)Fnconc
Concatenate any number of lists by altering them.
Only the last argument is not altered, and need not be a list.Fmapconcat
Apply FN to each element of SEQ, and concat the results as strings.
In between each pair of results, stick in SEP.
Thus, " " as SEP results in spaces between the values return by FN.

arguments: (fn seq sep)Fmapcar
Apply FUNCTION to each element of SEQUENCE, and make a list of the results.
The result is a list just as long as SEQUENCE.
SEQUENCE may be a list, a vector or a string.

arguments: (fn seq)Fy-or-n-p
Ask user a "y or n" question.  Return t if answer is "y".
Takes one argument, which is the string to display to ask the question.
It should end in a space; `y-or-n-p' adds `(y or n) ' to it.
No confirmation of the answer is requested; a single character is enough.
Also accepts Space to mean yes, or Delete to mean no.

arguments: (prompt)Fyes-or-no-p
Ask user a yes-or-no question.  Return t if answer is yes.
Takes one argument, which is the string to display to ask the question.
It should end in a space; `yes-or-no-p' adds `(yes or no) ' to it.
The user must confirm the answer with RET,
and can edit it until it as been confirmed.

arguments: (prompt)Fload-average
Return list of 1 minute, 5 minute and 15 minute load averages.
Each of the three load averages is multiplied by 100,
then converted to integer.
If the 5-minute or 15-minute load averages are not available, return a
shortened list, containing only those averages which are available.

arguments: ()Ffeaturep
Returns t if FEATURE is present in this Emacs.
Use this to conditionalize execution of lisp code based on the presence or
absence of emacs or environment extensions.
Use `provide' to declare that a feature is available.
This function looks at the value of the variable `features'.

arguments: (feature)Fprovide
Announce that FEATURE is a feature of the current Emacs.

arguments: (feature)Frequire
If feature FEATURE is not loaded, load it from FILENAME.
If FEATURE is not a member of the list `features', then the feature
is not loaded; so load the file FILENAME.
If FILENAME is omitted, the printname of FEATURE is used as the file name.

arguments: (feature &optional file-name)Vfeatures
A list of symbols which are the features of the executing emacs.
Used by `featurep' and `require', and altered by `provide'.Fframep
Return non-nil if OBJECT is a frame.
Value is t for a termcap frame (a character-only terminal),
`x' for an Emacs frame that is really an X window.
Also see `live-frame-p'.

arguments: (object)Fframe-live-p
Return non-nil if OBJECT is a frame which has not been deleted.
Value is nil if OBJECT is not a live frame.  If object is a live
frame, the return value indicates what sort of output device it is
displayed on.  Value is t for a termcap frame (a character-only
terminal), `x' for an Emacs frame being displayed in an X window.

arguments: (object)Fselect-frame
Select the frame FRAME.
Subsequent editing commands apply to its selected window.
The selection of FRAME lasts until the next time the user does
something to select a different frame, or until the next time this
function is called.

arguments: (frame &optional no-enter)Fhandle-switch-frame
Handle a switch-frame event EVENT.
Switch-frame events is usually bound to this function.
A switch-frame event tells Emacs that the window manager has requested
that the user's events be directed to the frame mentioned in the event.
This function selects the selected window of the frame of EVENT.

If EVENT is frame object, handle it as if it were a switch-frame event
to that frame.

arguments: (frame &optional no-enter)Fselected-frame
Return the frame that is now selected.

arguments: ()Fwindow-frame
Return the frame object that window WINDOW is on.

arguments: (window)Fframe-root-window
Returns the root-window of FRAME.
If omitted, FRAME defaults to the currently selected frame.

arguments: (&optional frame)Fframe-selected-window
Return the selected window of frame object FRAME.
If omitted, FRAME defaults to the currently selected frame.

arguments: (&optional frame)Fframe-list
Return a list of all frames.

arguments: ()Fnext-frame
Return the next frame in the frame list after FRAME.
By default, skip minibuffer-only frames.
If omitted, FRAME defaults to the selected frame.
If optional argument MINIFRAME is non-nil, include minibuffer-only frames.
If MINIFRAME is a window, include only frames using that window for their
minibuffer.
If MINIFRAME is non-nil and not a window, include all frames.

arguments: (&optional frame miniframe)Fdelete-frame
Delete FRAME, permanently eliminating it from use.
If omitted, FRAME defaults to the selected frame.
A frame may not be deleted if its minibuffer is used by other frames.

arguments: (&optional frame)Fmouse-position
Return a list (FRAME X . Y) giving the current mouse frame and position.
The position is given in character cells, where (0, 0) is the
upper-left corner.
If Emacs is running on a mouseless terminal or hasn't been programmed
to read the mouse position, it returns the selected frame for FRAME
and nil for X and Y.

arguments: ()Fset-mouse-position
Move the mouse pointer to the center of character cell (X,Y) in FRAME.
WARNING:  If you use this under X, you should do `unfocus-frame' afterwards.

arguments: (frame x y)Fmake-frame-visible
Make the frame FRAME visible (assuming it is an X-window).
Also raises the frame so that nothing obscures it.
If omitted, FRAME defaults to the currently selected frame.

arguments: (&optional frame)Fmake-frame-invisible
Make the frame FRAME invisible (assuming it is an X-window).
If omitted, FRAME defaults to the currently selected frame.

arguments: (&optional frame)Ficonify-frame
Make the frame FRAME into an icon.
If omitted, FRAME defaults to the currently selected frame.

arguments: (&optional frame)Fframe-visible-p
Return t if FRAME is now "visible" (actually in use for display).
A frame that is not "visible" is not updated and, if it works through
a window system, it may not show at all.
Return the symbol `icon' if frame is visible only as an icon.

arguments: (frame)Fvisible-frame-list
Return a list of all frames now "visible" (being updated).

arguments: ()Fraise-frame
Bring FRAME to the front, so it occludes any frames it overlaps.
If FRAME is invisible, make it visible.
If Emacs is displaying on an ordinary terminal or some other device which
doesn't support multiple overlapping frames, this function does nothing.

arguments: (frame)Flower-frame
Send FRAME to the back, so it is occluded by any frames that overlap it.
If Emacs is displaying on an ordinary terminal or some other device which
doesn't support multiple overlapping frames, this function does nothing.

arguments: (frame)Fredirect-frame-focus
Arrange for keystrokes typed at FRAME to be sent to FOCUS-FRAME.
In other words, switch-frame events caused by events in FRAME will
request a switch to FOCUS-FRAME, and `last-event-frame' will be
FOCUS-FRAME after reading an event typed at FRAME.

If FOCUS-FRAME is omitted or nil, any existing redirection is
cancelled, and the frame again receives its own keystrokes.

Focus redirection is useful for temporarily redirecting keystrokes to
a surrogate minibuffer frame when a frame doesn't have its own
minibuffer window.

A frame's focus redirection can be changed by select-frame.  If frame
FOO is selected, and then a different frame BAR is selected, any
frames redirecting their focus to FOO are shifted to redirect their
focus to BAR.  This allows focus redirection to work properly when the
user switches from one frame to another using `select-window'.

This means that a frame whose focus is redirected to itself is treated
differently from a frame whose focus is redirected to nil; the former
is affected by select-frame, while the latter is not.

The redirection lasts until `redirect-frame-focus' is called to change it.

arguments: (frame &optional focus-frame)Fframe-focus
Return the frame to which FRAME's keystrokes are currently being sent.
This returns nil if FRAME's focus is not redirected.
See `redirect-frame-focus'.

arguments: (frame)Fframe-parameters
Return the parameters-alist of frame FRAME.
It is a list of elements of the form (PARM . VALUE), where PARM is a symbol.
The meaningful PARMs depend on the kind of frame.
If FRAME is omitted, return information on the currently selected frame.

arguments: (&optional frame)Fmodify-frame-parameters
Modify the parameters of frame FRAME according to ALIST.
ALIST is an alist of parameters to change and their new values.
Each element of ALIST has the form (PARM . VALUE), where PARM is a symbol.
The meaningful PARMs depend on the kind of frame; undefined PARMs are ignored.

arguments: (frame alist)Fframe-char-height
Height in pixels of a line in the font in frame FRAME.
If FRAME is omitted, the selected frame is used.
For a terminal frame, the value is always 1.

arguments: (&optional frame)Fframe-char-width
Width in pixels of characters in the font in frame FRAME.
If FRAME is omitted, the selected frame is used.
The width is the same for all characters, because
currently Emacs supports only fixed-width fonts.
For a terminal screen, the value is always 1.

arguments: (&optional frame)Fframe-pixel-height
Return a FRAME's height in pixels.
For a terminal frame, the result really gives the height in characters.
If FRAME is omitted, the selected frame is used.

arguments: (&optional frame)Fframe-pixel-width
Return FRAME's width in pixels.
For a terminal frame, the result really gives the width in characters.
If FRAME is omitted, the selected frame is used.

arguments: (&optional frame)Fset-frame-height
Specify that the frame FRAME has LINES lines.
Optional third arg non-nil means that redisplay should use LINES lines
but that the idea of the actual height of the frame should not be changed.

arguments: (frame rows &optional pretend)Fset-frame-width
Specify that the frame FRAME has COLS columns.
Optional third arg non-nil means that redisplay should use COLS columns
but that the idea of the actual width of the frame should not be changed.

arguments: (frame cols &optional pretend)Fset-frame-size
Sets size of FRAME to COLS by ROWS, measured in characters.

arguments: (frame cols rows)Fset-frame-position
Sets position of FRAME in pixels to XOFFSET by YOFFSET.
If XOFFSET or YOFFSET are negative, they are interpreted relative to
the leftmost or bottommost position FRAME could occupy without going
off the screen.

arguments: (frame xoffset yoffset)Vterminal-frame
The initial frame-object, which represents Emacs's stdout.Vemacs-iconified
Non-nil if all of emacs is iconified and frame updates are not needed.Vdefault-minibuffer-frame
Minibufferless frames use this frame's minibuffer.

Emacs cannot create minibufferless frames unless this is set to an
appropriate surrogate.

Emacs consults this variable only when creating minibufferless
frames; once the frame is created, it sticks with its assigned
minibuffer, no matter what this variable is set to.  This means that
this variable doesn't necessarily say anything meaningful about the
current set of frames, or where the minibuffer is currently being
displayed.Vdefault-frame-alist
Alist of default values for frame creation.
These may be set in your init file, like this:
  (setq default-frame-alist '((width . 80) (height . 55)))
These override values given in window system configuration data, like
X Windows' defaults database.
For values specific to the first Emacs frame, see `initial-frame-alist'.
For values specific to the separate minibuffer frame, see
`minibuffer-frame-alist'.Fselected-frame
Return the frame that is now selected.

arguments: ()Fframep
Return non-nil if OBJECT is a frame.
Value is t for a termcap frame (a character-only terminal),
`x' for an Emacs frame that is really an X window.
Also see `live-frame-p'.

arguments: (object)Fset-frame-height
Specify that the frame FRAME has LINES lines.
Optional third arg non-nil means that redisplay should use LINES lines
but that the idea of the actual height of the frame should not be changed.

arguments: (frame rows &optional pretend)Fset-frame-width
Specify that the frame FRAME has COLS columns.
Optional third arg non-nil means that redisplay should use COLS columns
but that the idea of the actual width of the frame should not be changed.

arguments: (frame cols &optional pretend)Fset-frame-size
Sets size of FRAME to COLS by ROWS, measured in characters.

arguments: (frame cols rows)Fframe-height
Return number of lines available for display on FRAME.
If FRAME is omitted, describe the currently selected frame.

arguments: (&optional frame)Fframe-width
Return number of columns available for display on FRAME.
If FRAME is omitted, describe the currently selected frame.

arguments: (&optional frame)Fframe-char-height
Height in pixels of a line in the font in frame FRAME.
If FRAME is omitted, the selected frame is used.
For a terminal frame, the value is always 1.

arguments: (&optional frame)Fframe-char-width
Width in pixels of characters in the font in frame FRAME.
If FRAME is omitted, the selected frame is used.
The width is the same for all characters, because
currently Emacs supports only fixed-width fonts.
For a terminal screen, the value is always 1.

arguments: (&optional frame)Fframe-pixel-height
Return FRAME's height in pixels.
For a terminal frame, the result really gives the height in characters.
If FRAME is omitted, the selected frame is used.

arguments: (&optional frame)Fframe-pixel-width
Return FRAME's width in pixels.
For a terminal frame, the result really gives the width in characters.
If FRAME is omitted, the selected frame is used.

arguments: (&optional frame)Fset-screen-height
Tell redisplay that the screen has LINES lines.
Optional second arg non-nil means that redisplay should use LINES lines
but that the idea of the actual height of the screen should not be changed.

arguments: (lines &optional pretend)Fset-screen-width
Tell redisplay that the screen has COLS columns.
Optional second arg non-nil means that redisplay should use COLS columns
but that the idea of the actual width of the screen should not be changed.

arguments: (cols &optional pretend)Fcurrent-column
Return the horizontal position of point.  Beginning of line is column 0.
This is calculated by adding together the widths of all the displayed
representations of the character between the start of the previous line
and point.  (eg control characters will have a width of 2 or 4, tabs
will have a variable width)
Ignores finite width of frame, which means that this function may return
values greater than (frame-width).
Whether the line is visible (if `selective-display' is t) has no effect;
however, ^M is treated as end of line when `selective-display' is t.

arguments: ()Findent-to
Indent from point with tabs and spaces until COLUMN is reached.
Optional second argument MIN says always do at least MIN spaces
even if that goes past COLUMN; by default, MIN is zero.

arguments: (col &optional minimum)Fcurrent-indentation
Return the indentation of the current line.
This is the horizontal position of the character
following any initial whitespace.

arguments: ()Fmove-to-column
Move point to column COLUMN in the current line.
The column of a character is calculated by adding together the widths
as displayed of the previous characters in the line.
This function ignores line-continuation;
there is no upper limit on the column number a character can have
and horizontal scrolling has no effect.

If specified column is within a character, point goes after that character.
If it's past end of line, point goes to end of line.

A non-nil second (optional) argument FORCE means, if the line
is too short to reach column COLUMN then add spaces/tabs to get there,
and if COLUMN is in the middle of a tab character, change it to spaces.

arguments: (column &optional force)Fvertical-motion
Move to start of screen line LINES lines down.
If LINES is negative, this is moving up.
Sets point to position found; this may be start of line
 or just the start of a continuation line.
Returns number of lines moved; may be closer to zero than LINES
 if beginning or end of buffer was reached.

arguments: (lines)Vindent-tabs-mode
*Indentation can insert tabs if this is non-nil.
Setting this variable automatically makes it local to the current buffer.Frecursive-edit
Invoke the editor command loop recursively.
To get out of the recursive edit, a command can do `(throw 'exit nil)';
that tells this function to return.
Alternately, `(throw 'exit t)' makes this function signal an error.
This function is called by the editor initialization to begin editing.

arguments: ()Ftop-level
Exit all recursive editing levels.

arguments: ()Fexit-recursive-edit
Exit from the innermost recursive edit or minibuffer.

arguments: ()Fabort-recursive-edit
Abort the command that requested this recursive edit or minibuffer input.

arguments: ()Ftrack-mouse
Evaluate BODY with mouse movement events enabled.
Within a `track-mouse' form, mouse motion generates input events that
you can read with `read-event'.
Normally, mouse motion is ignored.Fread-key-sequence
Read a sequence of keystrokes and return as a string or vector.
The sequence is sufficient to specify a non-prefix command in the
current local and global maps.

First arg PROMPT is a prompt string.  If nil, do not prompt specially.
Second (optional) arg CONTINUE-ECHO, if non-nil, means this key echos
as a continuation of the previous key.

A C-g typed while in this function is treated like any other character,
and `quit-flag' is not set.

If the key sequence starts with a mouse click, then the sequence is read
using the keymaps of the buffer of the window clicked in, not the buffer
of the selected window as normal.

`read-key-sequence' drops unbound button-down events, since you normally
only care about the click or drag events which follow them.  If a drag
or multi-click event is unbound, but the corresponding click event would
be bound, `read-key-sequence' turns the event into a click event at the
drag's starting position.  This means that you don't have to distinguish
between click and drag, double, or triple events unless you want to.

`read-key-sequence' prefixes mouse events on mode lines, the vertical
lines separating windows, and scroll bars with imaginary keys
`mode-line', `vertical-line', and `vertical-scroll-bar'.

If the user switches frames in the middle of a key sequence, the
frame-switch event is put off until after the current key sequence.

`read-key-sequence' checks `function-key-map' for function key
sequences, where they wouldn't conflict with ordinary bindings.  See
`function-key-map' for more details.

arguments: (prompt &optional continue-echo)Fcommand-execute
Execute CMD as an editor command.
CMD must be a symbol that satisfies the `commandp' predicate.
Optional second arg RECORD-FLAG non-nil
means unconditionally put this command in `command-history'.
Otherwise, that is done only if an arg is read using the minibuffer.

arguments: (cmd &optional record)Fexecute-extended-command
Read function name, then read its arguments and call it.

arguments: (prefixarg)Finput-pending-p
T if command input is currently available with no waiting.
Actually, the value is nil only if we can be sure that no input is available.

arguments: ()Frecent-keys
Return vector of last 100 events, not counting those from keyboard macros.

arguments: ()Fthis-command-keys
Return the key sequence that invoked this command.
The value is a string or a vector.

arguments: ()Frecursion-depth
Return the current depth in recursive edits.

arguments: ()Fopen-dribble-file
Start writing all keyboard characters to a dribble file called FILE.
If FILE is nil, close any open dribble file.

arguments: (file)Fdiscard-input
Discard the contents of the terminal input buffer.
Also cancel any kbd macro being defined.

arguments: ()Fsuspend-emacs
Stop Emacs and return to superior process.  You can resume later.
On systems that don't have job control, run a subshell instead.

If optional arg STUFFSTRING is non-nil, its characters are stuffed
to be read as terminal input by Emacs's parent, after suspension.

Before suspending, call the functions in `suspend-hook' with no args.
If any of them returns nil, don't call the rest and don't suspend.
Otherwise, suspend normally and after resumption run the normal hook
`suspend-resume-hook' if that is bound and non-nil.

Some operating systems cannot stop the Emacs process and resume it later.
On such systems, Emacs starts a subshell instead of suspending.

arguments: (&optional stuffstring)Fset-input-mode
Set mode of reading keyboard input.
First arg INTERRUPT non-nil means use input interrupts;
 nil means use CBREAK mode.
Second arg FLOW non-nil means use ^S/^Q flow control for output to terminal
 (no effect except in CBREAK mode).
Third arg META t means accept 8-bit input (for a Meta key).
 META nil means ignore the top bit, on the assumption it is parity.
 Otherwise, accept 8-bit input and don't use the top bit for Meta.
Optional fourth arg QUIT if non-nil specifies character to use for quitting.
See also `current-input-mode'.

arguments: (interrupt flow meta &optional quit)Fcurrent-input-mode
Return information about the way Emacs currently reads keyboard input.
The value is a list of the form (INTERRUPT FLOW META QUIT), where
  INTERRUPT is non-nil if Emacs is using interrupt-driven input; if
    nil, Emacs is using CBREAK mode.
  FLOW is non-nil if Emacs uses ^S/^Q flow control for output to the
    terminal; this does not apply if Emacs uses interrupt-driven input.
  META is t if accepting 8-bit input with 8th bit as Meta flag.
    META nil means ignoring the top bit, on the assumption it is parity.
    META is neither t nor nil if accepting 8-bit input and using
    all 8 bits as the character code.
  QUIT is the character Emacs currently uses to quit.
The elements of this list correspond to the arguments of
`set-input-mode'.

arguments: ()Vlast-command-char
Last input event that was part of a command.Vlast-command-event
Last input event that was part of a command.Vlast-nonmenu-event
Last input event in a command, except for mouse menu events.
Mouse menus give back keys that don't look like mouse events;
this variable holds the actual mouse event that led to the menu,
so that you can determine whether the command was run by mouse or not.Vlast-input-char
Last input event.Vlast-input-event
Last input event.Vunread-command-events
List of objects to be read as next command input events.Vunread-command-char
If not -1, an object to be read as next command input event.Vmeta-prefix-char
Meta-prefix character code.  Meta-foo as command input
turns into this character followed by foo.Vlast-command
The last command executed.  Normally a symbol with a function definition,
but can be whatever was found in the keymap, or whatever the variable
`this-command' was set to by that command.Vthis-command
The command now being executed.
The command can set this variable; whatever is put here
will be in `last-command' during the following command.Vauto-save-interval
*Number of keyboard input characters between auto-saves.
Zero means disable autosaving due to number of characters typed.Vauto-save-timeout
*Number of seconds idle time before auto-save.
Zero or nil means disable auto-saving due to idleness.
After auto-saving due to this many seconds of idle time,
Emacs also does a garbage collection if that seems to be warranted.Vecho-keystrokes
*Nonzero means echo unfinished commands after this many seconds of pause.Vpolling-period
*Interval between polling for input during Lisp execution.
The reason for polling is to make C-g work to stop a running program.
Polling is needed only when using X windows and SIGIO does not work.
Polling is automatically disabled in all other cases.Vdouble-click-time
*Maximum time between mouse clicks to make a double-click.
Measured in milliseconds.  nil means disable double-click recognition;
t means double-clicks have no time limit and are detected
by position only.Vnum-input-keys
*Number of complete keys read from the keyboard so far.Vlast-event-frame
*The frame in which the most recently read event occurred.
If the last event came from a keyboard macro, this is set to `macro'.Vhelp-char
Character to recognize as meaning Help.
When it is read, do `(eval help-form)', and display result if it's a string.
If the value of `help-form' is nil, this char can be read normally.Vhelp-form
Form to execute when character `help-char' is read.
If the form returns a string, that string is displayed.
If `help-form' is nil, the help char is not recognized.Vprefix-help-command
Command to run when `help-char' character follows a prefix key.
This command is used only when there is no actual binding
for that character after that prefix key.Vtop-level
Form to evaluate when Emacs starts up.
Useful to set before you dump a modified Emacs.Vkeyboard-translate-table
String used as translate table for keyboard input, or nil.
Each character is looked up in this string and the contents used instead.
If string is of length N, character codes N and up are untranslated.Vmenu-prompting
Non-nil means prompt with menus when appropriate.
This is done when reading from a keymap that has a prompt string,
for elements that have prompt strings.
The menu is displayed on the screen
if X menus were enabled at configuration
time and the previous event was a mouse click prefix key.
Otherwise, menu prompting uses the echo area.Vmenu-prompt-more-char
Character to see next line of menu prompt.
Type this character while in a menu prompt to rotate around the lines of it.Vextra-keyboard-modifiers
A mask of additional modifier keys to use with every keyboard character.
Emacs applies the modifiers of the character stored here to each keyboard
character it reads.  For example, after evaluating the expression
    (setq extra-keyboard-modifiers ?C-x)
all input characters will have the control modifier applied to them.

Note that the character ?C-@, equivalent to the integer zero, does
not count as a control character; rather, it counts as a character
with no modifiers; thus, setting extra_keyboard_modifiers to zero
cancels any modification.Vdeactivate-mark
If an editing command sets this to t, deactivate the mark afterward.
The command loop sets this to nil before each command,
and tests the value when the command returns.
Buffer modification stores t in this variable.Vpre-command-hook
Normal hook run before each command is executed.Vpost-command-hook
Normal hook run after each command is executed.Vlucid-menu-bar-dirty-flag
t means menu bar, specified Lucid style, needs to be recomputed.Vmenu-bar-final-items
List of menu bar items to move to the end of the menu bar.
The elements of the listare event types that may have menu bar bindings.Fmake-keymap
Construct and return a new keymap, of the form (keymap VECTOR . ALIST).
VECTOR is a vector which holds the bindings for the ASCII
characters.  ALIST is an assoc-list which holds bindings for function keys,
mouse events, and any other things that appear in the input stream.
All entries in it are initially nil, meaning "command undefined".

The optional arg STRING supplies a menu name for the keymap
in case you use it as a menu with `x-popup-menu'.

arguments: (&optional string)Fmake-sparse-keymap
Construct and return a new sparse-keymap list.
Its car is `keymap' and its cdr is an alist of (CHAR . DEFINITION),
which binds the character CHAR to DEFINITION, or (SYMBOL . DEFINITION),
which binds the function key or mouse event SYMBOL to DEFINITION.
Initially the alist is nil.

The optional arg STRING supplies a menu name for the keymap
in case you use it as a menu with `x-popup-menu'.

arguments: (&optional string)Fkeymapp
Return t if ARG is a keymap.

A keymap is a list (keymap . ALIST),
or a symbol whose function definition is a keymap is itself a keymap.
ALIST elements look like (CHAR . DEFN) or (SYMBOL . DEFN);
a vector of densely packed bindings for small character codes
is also allowed as an element.

arguments: (object)Fcopy-keymap
Return a copy of the keymap KEYMAP.
The copy starts out with the same definitions of KEYMAP,
but changing either the copy or KEYMAP does not affect the other.
Any key definitions that are subkeymaps are recursively copied.
However, a key definition which is a symbol whose definition is a keymap
is not copied.

arguments: (keymap)Fdefine-key
Args KEYMAP, KEY, DEF.  Define key sequence KEY, in KEYMAP, as DEF.
KEYMAP is a keymap.  KEY is a string or a vector of symbols and characters
meaning a sequence of keystrokes and events.
DEF is anything that can be a key's definition:
 nil (means key is undefined in this keymap),
 a command (a Lisp function suitable for interactive calling)
 a string (treated as a keyboard macro),
 a keymap (to define a prefix key),
 a symbol.  When the key is looked up, the symbol will stand for its
    function definition, which should at that time be one of the above,
    or another symbol whose function definition is used, etc.
 a cons (STRING . DEFN), meaning that DEFN is the definition
    (DEFN should be a valid definition in its own right),
 or a cons (KEYMAP . CHAR), meaning use definition of CHAR in map KEYMAP.

If KEYMAP is a sparse keymap, the pair binding KEY to DEF is added at
the front of KEYMAP.

arguments: (keymap key def)Flookup-key
In keymap KEYMAP, look up key sequence KEY.  Return the definition.
nil means undefined.  See doc of `define-key' for kinds of definitions.

A number as value means KEY is "too long";
that is, characters or symbols in it except for the last one
fail to be a valid sequence of prefix characters in KEYMAP.
The number is how many characters at the front of KEY
it takes to reach a non-prefix command.

Normally, `lookup-key' ignores bindings for t, which act as default
bindings, used when nothing else in the keymap applies; this makes it
useable as a general function for probing keymaps.  However, if the
third optional argument ACCEPT-DEFAULT is non-nil, `lookup-key' will
recognize the default bindings, just as `read-key-sequence' does.

arguments: (keymap key &optional accept-default)Fkey-binding
Return the binding for command KEY in current keymaps.
KEY is a string or vector, a sequence of keystrokes.
The binding is probably a symbol with a function definition.

Normally, `key-binding' ignores bindings for t, which act as default
bindings, used when nothing else in the keymap applies; this makes it
useable as a general function for probing keymaps.  However, if the
third optional argument ACCEPT-DEFAULT is non-nil, `key-binding' will
recognize the default bindings, just as `read-key-sequence' does.

arguments: (key &optional accept-default)Flocal-key-binding
Return the binding for command KEYS in current local keymap only.
KEYS is a string, a sequence of keystrokes.
The binding is probably a symbol with a function definition.

If optional argument ACCEPT-DEFAULT is non-nil, recognize default
bindings; see the description of `lookup-key' for more details about this.

arguments: (keys &optional accept-default)Fglobal-key-binding
Return the binding for command KEYS in current global keymap only.
KEYS is a string, a sequence of keystrokes.
The binding is probably a symbol with a function definition.
This function's return values are the same as those of lookup-key
(which see).

If optional argument ACCEPT-DEFAULT is non-nil, recognize default
bindings; see the description of `lookup-key' for more details about this.

arguments: (keys &optional accept-default)Fminor-mode-key-binding
Find the visible minor mode bindings of KEY.
Return an alist of pairs (MODENAME . BINDING), where MODENAME is the
the symbol which names the minor mode binding KEY, and BINDING is
KEY's definition in that mode.  In particular, if KEY has no
minor-mode bindings, return nil.  If the first binding is a
non-prefix, all subsequent bindings will be omitted, since they would
be ignored.  Similarly, the list doesn't include non-prefix bindings
that come after prefix bindings.

If optional argument ACCEPT-DEFAULT is non-nil, recognize default
bindings; see the description of `lookup-key' for more details about this.

arguments: (key &optional accept-default)Fglobal-set-key
Give KEY a global binding as COMMAND.
COMMAND is a symbol naming an interactively-callable function.
KEY is a key sequence (a string or vector of characters or event types).
Note that if KEY has a local binding in the current buffer
that local binding will continue to shadow any global binding.

arguments: (keys function)Flocal-set-key
Give KEY a local binding as COMMAND.
COMMAND is a symbol naming an interactively-callable function.
KEY is a key sequence (a string or vector of characters or event types).
The binding goes in the current buffer's local map,
which is shared with other buffers in the same major mode.

arguments: (keys function)Fglobal-unset-key
Remove global binding of KEY.
KEY is a string representing a sequence of keystrokes.

arguments: (keys)Flocal-unset-key
Remove local binding of KEY.
KEY is a string representing a sequence of keystrokes.

arguments: (keys)Fdefine-prefix-command
Define COMMAND as a prefix command.  COMMAND should be a symbol.
A new sparse keymap is stored as COMMAND's function definition and its value.
If a second optional argument MAPVAR is given, the map is stored as
its value instead of as COMMAND's value; but COMMAND is still defined
as a function.

arguments: (name &optional mapvar)Fuse-global-map
Select KEYMAP as the global keymap.

arguments: (keymap)Fuse-local-map
Select KEYMAP as the local keymap.
If KEYMAP is nil, that means no local keymap.

arguments: (keymap)Fcurrent-local-map
Return current buffer's local keymap, or nil if it has none.

arguments: ()Fcurrent-global-map
Return the current global keymap.

arguments: ()Fcurrent-minor-mode-maps
Return a list of keymaps for the minor modes of the current buffer.

arguments: ()Faccessible-keymaps
Find all keymaps accessible via prefix characters from KEYMAP.
Returns a list of elements of the form (KEYS . MAP), where the sequence
KEYS starting from KEYMAP gets you to MAP.  These elements are ordered
so that the KEYS increase in length.  The first element is ("" . KEYMAP).
An optional argument PREFIX, if non-nil, should be a key sequence;
then the value includes only maps for prefixes that start with PREFIX.

arguments: (startmap &optional prefix)Fkey-description
Return a pretty description of key-sequence KEYS.
Control characters turn into "C-foo" sequences, meta into "M-foo"
spaces are put between sequence elements, etc.

arguments: (keys)Fsingle-key-description
Return a pretty description of command character KEY.
Control characters turn into C-whatever, etc.

arguments: (key)Ftext-char-description
Return a pretty description of file-character CHAR.
Control characters turn into "^char", etc.

arguments: (chr)Fwhere-is-internal
Return list of keys that invoke DEFINITION in KEYMAP or KEYMAP1.
If KEYMAP is nil, search only KEYMAP1.
If KEYMAP1 is nil, use the current global map.

If optional 4th arg FIRSTONLY is non-nil, return a string representing
the first key sequence found, rather than a list of all possible key
sequences.  If FIRSTONLY is t, avoid key sequences which use non-ASCII
keys and therefore may not be usable on ASCII terminals.  If FIRSTONLY
is the symbol `non-ascii', return the first binding found, no matter
what its components.

If optional 5th arg NOINDIRECT is non-nil, don't follow indirections
to other keymaps or slots.  This makes it possible to search for an
indirect definition itself.

arguments: (definition &optional local-keymap global-keymap firstonly noindirect)Fwhere-is
Print message listing key sequences that invoke specified command.
Argument is a command definition, usually a symbol with a function definition.

arguments: (definition)Fdescribe-bindings
Show a list of all defined keys, and their definitions.
The list is put in a buffer, which is displayed.
An optional argument PREFIX, if non-nil, should be a key sequence;
then we display only bindings that start with that prefix.

arguments: (&optional prefix)Fdescribe-vector
Insert a description of contents of VECTOR.
This is text showing the elements of vector matched against indices.

arguments: (vector)Fapropos-internal
Show all symbols whose names contain match for REGEXP.
If optional 2nd arg PRED is non-nil, (funcall PRED SYM) is done
for each symbol and a symbol is mentioned only if that returns non-nil.
Return list of symbols found.

arguments: (string &optional pred)Vminibuffer-local-map
Default keymap to use when reading from the minibuffer.Vminibuffer-local-ns-map
Local keymap for the minibuffer when spaces are not allowed.Vminibuffer-local-completion-map
Local keymap for minibuffer input with completion.Vminibuffer-local-must-match-map
Local keymap for minibuffer input with completion, for exact match.Vminor-mode-map-alist
Alist of keymaps to use for minor modes.
Each element looks like (VARIABLE . KEYMAP); KEYMAP is used to read
key sequences and look up bindings iff VARIABLE's value is non-nil.
If two active keymaps bind the same key, the keymap appearing earlier
in the list takes precedence.Vfunction-key-map
Keymap mapping ASCII function key sequences onto their preferred forms.
This allows Emacs to recognize function keys sent from ASCII
terminals at any point in a key sequence.

The read-key-sequence function replaces subsequences bound by
function-key-map with their bindings.  When the current local and global
keymaps have no binding for the current key sequence but
function-key-map binds a suffix of the sequence to a vector or string,
read-key-sequence replaces the matching suffix with its binding, and
continues with the new sequence.

For example, suppose function-key-map binds `ESC O P' to [f1].
Typing `ESC O P' to read-key-sequence would return [f1].  Typing
`C-x ESC O P' would return [?\C-x f1].  If [f1] were a prefix
key, typing `ESC O P x' would return [f1 x].Fread-char
Read a character from the command input (keyboard or macro).
It is returned as a number.
If the user generates an event which is not a character (i.e. a mouse
click or function key event), `read-char' signals an error.  As an
exception, switch-frame events are put off until non-ASCII events can
be read.
If you want to read non-character events, or ignore them, call
`read-event' or `read-char-exclusive' instead.

arguments: ()Fread-event
Read an event object from the input stream.

arguments: ()Fread-char-exclusive
Read a character from the command input (keyboard or macro).
It is returned as a number.  Non character events are ignored.

arguments: ()Fget-file-char
Don't use this yourself.

arguments: ()Fload
Execute a file of Lisp code named FILE.
First try FILE with `.elc' appended, then try with `.el',
 then try FILE unmodified.
This function searches the directories in `load-path'.
If optional second arg NOERROR is non-nil,
 report no error if FILE doesn't exist.
Print messages at start and end of loading unless
 optional third arg NOMESSAGE is non-nil.
If optional fourth arg NOSUFFIX is non-nil, don't try adding
 suffixes `.elc' or `.el' to the specified name FILE.
Return t if file exists.

arguments: (str &optional noerror nomessage nosuffix)Feval-buffer
Execute the current buffer as Lisp code.
Programs can pass two arguments, BUFFER and PRINTFLAG.
BUFFER is the buffer to evaluate (nil means use current buffer).
PRINTFLAG controls printing of output:
nil means discard it; anything else is stream for print.

If there is no error, point does not move.  If there is an error,
point remains at the end of the last character read from the buffer.

arguments: (&optional bufname printflag)Feval-current-buffer
Execute the current buffer as Lisp code.
Programs can pass argument PRINTFLAG which controls printing of output:
nil means discard it; anything else is stream for print.

If there is no error, point does not move.  If there is an error,
point remains at the end of the last character read from the buffer.

arguments: (&optional printflag)Feval-region
Execute the region as Lisp code.
When called from programs, expects two arguments,
giving starting and ending indices in the current buffer
of the text to be executed.
Programs can pass third argument PRINTFLAG which controls output:
nil means discard it; anything else is stream for printing it.

If there is no error, point does not move.  If there is an error,
point remains at the end of the last character read from the buffer.

arguments: (b e &optional printflag)Fread
Read one Lisp expression as text from STREAM, return as Lisp object.
If STREAM is nil, use the value of `standard-input' (which see).
STREAM or the value of `standard-input' may be:
 a buffer (read from point and advance it)
 a marker (read from where it points and advance it)
 a function (call it with no arguments for each character,
     call it with a char as argument to push a char back)
 a string (takes text from string, starting at the beginning)
 t (read text line using minibuffer and use it).

arguments: (&optional readcharfun)Fread-from-string
Read one Lisp expression which is represented as text by STRING.
Returns a cons: (OBJECT-READ . FINAL-STRING-INDEX).
START and END optionally delimit a substring of STRING from which to read;
 they default to 0 and (length STRING) respectively.

arguments: (string &optional start end)Fintern
Return the canonical symbol whose name is STRING.
If there is none, one is created by this function and returned.
A second optional argument specifies the obarray to use;
it defaults to the value of `obarray'.

arguments: (str &optional obarray)Fintern-soft
Return the canonical symbol whose name is STRING, or nil if none exists.
A second optional argument specifies the obarray to use;
it defaults to the value of `obarray'.

arguments: (str &optional obarray)Fmapatoms
Call FUNCTION on every symbol in OBARRAY.
OBARRAY defaults to the value of `obarray'.

arguments: (function &optional obarray)Vobarray
Symbol table for use by `intern' and `read'.
It is a vector whose length ought to be prime for best results.
The vector's contents don't make sense if examined from Lisp programs;
to find all the symbols in an obarray, use `mapatoms'.Vvalues
List of values of all expressions which were read, evaluated and printed.
Order is reverse chronological.Vstandard-input
Stream for read to get input from.
See documentation of `read' for possible values.Vload-path
*List of directories to search for files to load.
Each element is a string (directory name) or nil (try default directory).
Initialized based on EMACSLOADPATH environment variable, if any,
otherwise to default specified by file `paths.h' when Emacs was built.Vload-in-progress
Non-nil iff inside of `load'.Vafter-load-alist
An alist of expressions to be evalled when particular files are loaded.
Each element looks like (FILENAME FORMS...).
When `load' is run and the file-name argument is FILENAME,
the FORMS in the corresponding element are executed at the end of loading.

FILENAME must match exactly!  Normally FILENAME is the name of a library,
with no directory specified, since that is how `load' is normally called.
An error in FORMS does not undo the load,
but does prevent execution of the rest of the FORMS.Vload-history
Alist mapping source file names to symbols and features.
Each alist element is a list that starts with a file name,
except for one element (optional) that starts with nil and describes
definitions evaluated from buffers not visiting files.
The remaining elements of each list are symbols defined as functions
or variables, and cons cells `(provide . FEATURE)' and `(require . FEATURE)'.Vcurrent-load-list
Used for internal purposes by `load'.Fstart-kbd-macro
Record subsequent keyboard input, defining a keyboard macro.
The commands are recorded even as they are executed.
Use \[end-kbd-macro] to finish recording and make the macro available.
Use \[name-last-kbd-macro] to give it a permanent name.
Non-nil arg (prefix arg) means append to last macro defined;
 This begins by re-executing that macro as if you typed it again.

arguments: (append)Fend-kbd-macro
Finish defining a keyboard macro.
The definition was started by \[start-kbd-macro].
The macro is now available for use via \[call-last-kbd-macro],
or it can be given a name with \[name-last-kbd-macro] and then invoked
under that name.

With numeric arg, repeat macro now that many times,
counting the definition just completed as the first repetition.
An argument of zero means repeat until error.

arguments: (&optional arg)Fcall-last-kbd-macro
Call the last keyboard macro that you defined with \[start-kbd-macro].

A prefix argument serves as a repeat count.  Zero means repeat until error.

To make a macro permanent so you can call it even after
defining others, use \[name-last-kbd-macro].

arguments: (&optional prefix)Fexecute-kbd-macro
Execute MACRO as string of editor command characters.
If MACRO is a symbol, its function definition is used.
COUNT is a repeat count, or nil for once, or 0 for infinite loop.

arguments: (macro &optional prefixarg)Vdefining-kbd-macro
Non-nil while a keyboard macro is being defined.  Don't set this!Vexecuting-macro
Currently executing keyboard macro (a string); nil if none executing.Vexecuting-kbd-macro
Currently executing keyboard macro (a string); nil if none executing.Vlast-kbd-macro
Last kbd macro defined, as a string; nil if none defined.Fmarker-buffer
Return the buffer that MARKER points into, or nil if none.
Returns nil if MARKER points into a dead buffer.

arguments: (marker)Fmarker-position
Return the position MARKER points at, as a character number.

arguments: (marker)Fset-marker
Position MARKER before character number NUMBER in BUFFER.
BUFFER defaults to the current buffer.
If NUMBER is nil, makes marker point nowhere.
Then it no longer slows down editing in any buffer.
Returns MARKER.

arguments: (marker pos &optional buffer)Fcopy-marker
Return a new marker pointing at the same place as MARKER.
If argument is a number, makes a new marker pointing
at that position in the current buffer.

arguments: (marker)Fread-from-minibuffer
Read a string from the minibuffer, prompting with string PROMPT.
If optional second arg INITIAL-CONTENTS is non-nil, it is a string
  to be inserted into the minibuffer before reading input.
  If INITIAL-CONTENTS is (STRING . POSITION), the initial input
  is STRING, but point is placed POSITION characters into the string.
Third arg KEYMAP is a keymap to use whilst reading;
  if omitted or nil, the default is `minibuffer-local-map'.
If fourth arg READ is non-nil, then interpret the result as a lisp object
  and return that object:
  in other words, do `(car (read-from-string INPUT-STRING))'
Fifth arg HIST, if non-nil, specifies a history list
  and optionally the initial position in the list.
  It can be a symbol, which is the history list variable to use,
  or it can be a cons cell (HISTVAR . HISTPOS).
  In that case, HISTVAR is the history list variable to use,
  and HISTPOS is the initial position (the position in the list
  which INITIAL-CONTENTS corresponds to).
  Positions are counted starting from 1 at the beginning of the list.

arguments: (prompt &optional initial-input keymap read hist)Fread-minibuffer
Return a Lisp object read using the minibuffer.
Prompt with PROMPT.  If non-nil, optional second arg INITIAL-CONTENTS
is a string to insert in the minibuffer before reading.

arguments: (prompt &optional initial-contents)Feval-minibuffer
Return value of Lisp expression read using the minibuffer.
Prompt with PROMPT.  If non-nil, optional second arg INITIAL-CONTENTS
is a string to insert in the minibuffer before reading.

arguments: (prompt &optional initial-contents)Fread-string
Read a string from the minibuffer, prompting with string PROMPT.
If non-nil second arg INITIAL-INPUT is a string to insert before reading.

arguments: (prompt &optional initial-input)Fread-no-blanks-input
Args PROMPT and INIT, strings.  Read a string from the terminal, not allowing blanks.
Prompt with PROMPT, and provide INIT as an initial value of the input string.

arguments: (prompt init)Fread-command
One arg PROMPT, a string.  Read the name of a command and return as a symbol.
Prompts with PROMPT.

arguments: (prompt)Fread-function
One arg PROMPT, a string.  Read the name of a function and return as a symbol.
Prompts with PROMPT.

arguments: (prompt)Fread-variable
One arg PROMPT, a string.  Read the name of a user variable and return
it as a symbol.  Prompts with PROMPT.
A user variable is one whose documentation starts with a `*' character.

arguments: (prompt)Fread-buffer
One arg PROMPT, a string.  Read the name of a buffer and return as a string.
Prompts with PROMPT.
Optional second arg is value to return if user enters an empty line.
If optional third arg REQUIRE-MATCH is non-nil, only existing buffer names are allowed.

arguments: (prompt &optional def require-match)Ftry-completion
Return common substring of all completions of STRING in ALIST.
Each car of each element of ALIST is tested to see if it begins with STRING.
All that match are compared together; the longest initial sequence
common to all matches is returned as a string.
If there is no match at all, nil is returned.
For an exact match, t is returned.

ALIST can be an obarray instead of an alist.
Then the print names of all symbols in the obarray are the possible matches.

ALIST can also be a function to do the completion itself.
It receives three arguments: the values STRING, PREDICATE and nil.
Whatever it returns becomes the value of `try-completion'.

If optional third argument PREDICATE is non-nil,
it is used to test each possible match.
The match is a candidate only if PREDICATE returns non-nil.
The argument given to PREDICATE is the alist element or the symbol from the obarray.

arguments: (string alist &optional pred)Fall-completions
Search for partial matches to STRING in ALIST.
Each car of each element of ALIST is tested to see if it begins with STRING.
The value is a list of all the strings from ALIST that match.
ALIST can be an obarray instead of an alist.
Then the print names of all symbols in the obarray are the possible matches.

ALIST can also be a function to do the completion itself.
It receives three arguments: the values STRING, PREDICATE and t.
Whatever it returns becomes the value of `all-completion'.

If optional third argument PREDICATE is non-nil,
it is used to test each possible match.
The match is a candidate only if PREDICATE returns non-nil.
The argument given to PREDICATE is the alist element or the symbol from the obarray.

arguments: (string alist &optional pred)Fcompleting-read
Read a string in the minibuffer, with completion.
Args: PROMPT, TABLE, PREDICATE, REQUIRE-MATCH, INITIAL-INPUT, HIST.
PROMPT is a string to prompt with; normally it ends in a colon and a space.
TABLE is an alist whose elements' cars are strings, or an obarray.
PREDICATE limits completion to a subset of TABLE.
See `try-completion' for more details on completion, TABLE, and PREDICATE.
If REQUIRE-MATCH is non-nil, the user is not allowed to exit unless
 the input is (or completes to) an element of TABLE.
 If it is also not t, Return does not exit if it does non-null completion.
If INITIAL-INPUT is non-nil, insert it in the minibuffer initially.
  If it is (STRING . POSITION), the initial input
  is STRING, but point is placed POSITION characters into the string.
HIST, if non-nil, specifies a history list
  and optionally the initial position in the list.
  It can be a symbol, which is the history list variable to use,
  or it can be a cons cell (HISTVAR . HISTPOS).
  In that case, HISTVAR is the history list variable to use,
  and HISTPOS is the initial position (the position in the list
  which INITIAL-CONTENTS corresponds to).
  Positions are counted starting from 1 at the beginning of the list.
Completion ignores case if the ambient value of
  `completion-ignore-case' is non-nil.

arguments: (prompt table &optional pred require-match init hist)Fminibuffer-complete
Complete the minibuffer contents as far as possible.

arguments: ()Fminibuffer-complete-and-exit
Complete the minibuffer contents, and maybe exit.
Exit if the name is valid with no completion needed.
If name was completed to a valid match,
a repetition of this command will exit.

arguments: ()Fminibuffer-complete-word
Complete the minibuffer contents at most a single word.
After one word is completed as much as possible, a space or hyphen
is added, provided that matches some possible completion.

arguments: ()Fdisplay-completion-list
Display the list of completions, COMPLETIONS, using `standard-output'.
Each element may be just a symbol or string
or may be a list of two strings to be printed as if concatenated.

arguments: (completions)Fminibuffer-completion-help
Display a list of possible completions of the current minibuffer contents.

arguments: ()Fself-insert-and-exit
Terminate minibuffer input.

arguments: ()Fexit-minibuffer
Terminate this minibuffer argument.

arguments: ()Fminibuffer-depth
Return current depth of activations of minibuffer, a nonnegative integer.

arguments: ()Vcompletion-auto-help
*Non-nil means automatically provide help for invalid completion input.Vcompletion-ignore-case
Non-nil means don't consider case significant in completion.Venable-recursive-minibuffers
*Non-nil means to allow minibuffer commands while in the minibuffer.
More precisely, this variable makes a difference when the minibuffer window
is the selected window.  If you are in some other window, minibuffer commands
are allowed even if a minibuffer is active.Vminibuffer-completion-table
Alist or obarray used for completion in the minibuffer.
This becomes the ALIST argument to `try-completion' and `all-completion'.

The value may alternatively be a function, which is given three arguments:
  STRING, the current buffer contents;
  PREDICATE, the predicate for filtering possible matches;
  CODE, which says what kind of things to do.
CODE can be nil, t or `lambda'.
nil means to return the best completion of STRING, or nil if there is none.
t means to return a list of all possible completions of STRING.
`lambda' means to return t if STRING is a valid completion as it stands.Vminibuffer-completion-predicate
Within call to `completing-read', this holds the PREDICATE argument.Vminibuffer-completion-confirm
Non-nil => demand confirmation of completion before exiting minibuffer.Vminibuffer-help-form
Value that `help-form' takes on inside the minibuffer.Vminibuffer-history-variable
History list symbol to add minibuffer values to.
Each minibuffer output is added with
  (set minibuffer-history-variable
       (cons STRING (symbol-value minibuffer-history-variable)))Vminibuffer-history-position
Current position of redoing in the history list.Fml-if
Mocklisp version of `if'.Fml-nargs
Number of arguments to currently executing mocklisp function.

arguments: ()Fml-arg
Argument number N to currently executing mocklisp function.

arguments: (n &optional prompt)Fml-interactive
True if currently executing mocklisp function was called interactively.

arguments: ()Fml-provide-prefix-argument
Evaluate second argument, using first argument as prefix arg value.Fml-prefix-argument-loop
Fml-substr
Return a substring of STRING, starting at index FROM and of length LENGTH.
If either FROM or LENGTH is negative, the length of STRING is added to it.

arguments: (string from to)Finsert-string
Mocklisp-compatibility insert function.
Like the function `insert' except that any argument that is a number
is converted into a string by expressing it in decimal.Fpm-list-fonts
Return a list of the names of available fonts matching PATTERN.
If optional arguments FACE and FRAME are specified, return only fonts
the same size as FACE on FRAME.

PATTERN is a string, perhaps with wildcard characters;
  the * character matches any substring, and
  the ? character matches any single character.
  PATTERN is case-insensitive.
FACE is a face name - a symbol.

The return value is a list of strings, suitable as arguments to
set-face-font.

The list does not include fonts Emacs can't use (i.e.  proportional
fonts), even if they match PATTERN and FACE.

arguments: (pattern &optional face frame)Fpm-defined-color
Return t if the PM display supports the color named COLOR.

arguments: (color)Fpm-display-color-p
Return t if the display supports color.

arguments: ()Fpm-display-planes
Returns the number of bitplanes of the display FRAME is on.

arguments: (&optional frame)Fpm-open-connection
Open a connection to PM Emacs.

arguments: ()Fx-close-current-connection
Close the current connection to PM Emacs.

arguments: ()Ffocus-frame
Set the focus on FRAME.

arguments: (frame)Fpm-create-frame
Make a new PM window, which is called a "frame" in Emacs terms.
Return an Emacs frame object representing the PM window.
ALIST is an alist of frame parameters.
If the parameters specify that the frame should not have a minibuffer,
and do not specify a specific minibuffer window to use,
then `default-minibuffer-frame' must be a frame whose minibuffer can
be shared by the new frame.

arguments: (parms)Fpm-menu-bar-menu
Update a menu of the PM menu bar.
This function should be called from pm-menu-bar-update only.
KEY is the event symbol for the menu, MENU is a menu keymap.

arguments: (frame key menu)Fframe-menu-bar-items
Return the list of FRAME's menu bar items.
The elements of the list have the form (KEY STRING . nil).

arguments: (&optional frame)Vpm-color-alist
*List of elements ("COLOR" . [R G B]) for defining colors.
"COLOR" is the name of the color.  Don't use upper-case letters.
R, G and B are numbers in 0 through 255, indicating the intensity
of the red, green and blue beams, respectively.Fx-selection-owner-p
Whether the current Emacs process owns the given X Selection.
The arg should be the name of the selection in question, typically one of
the symbols `PRIMARY', `SECONDARY', or `CLIPBOARD'.
(Those are literal upper-case symbol names, since that's what X expects.)
For convenience, the symbol nil is the same as `PRIMARY',
and t is the same as `SECONDARY'.)

arguments: (&optional selection)Fx-selection-exists-p
Whether there is an owner for the given X Selection.
The arg should be the name of the selection in question, typically one of
the symbols `PRIMARY', `SECONDARY', or `CLIPBOARD'.
(Those are literal upper-case symbol names, since that's what X expects.)
For convenience, the symbol nil is the same as `PRIMARY',
and t is the same as `SECONDARY'.)

arguments: (&optional selection)Fpm-get-clipboard
Retrieve a text string from the clipboard.
Return the empty string if there is no text in the clipboard.

arguments: ()Fpm-clipboard-ready-p
Return t if a text is in the clipboard.

arguments: ()Fpm-put-clipboard
Put a text string into the clipboard.

arguments: (string)Fwrite-char
Output character CHAR to stream STREAM.
STREAM defaults to the value of `standard-output' (which see).

arguments: (ch &optional printcharfun)Fwith-output-to-temp-buffer
Bind `standard-output' to buffer BUFNAME, eval BODY, then show that buffer.
The buffer is cleared out initially, and marked as unmodified when done.
All output done by BODY is inserted in that buffer by default.
The buffer is displayed in another window, but not selected.
The value of the last form in BODY is returned.
If BODY does not finish normally, the buffer BUFNAME is not displayed.

If variable `temp-buffer-show-function' is non-nil, call it at the end
to get the buffer displayed.  It gets one argument, the buffer to display.Fterpri
Output a newline to STREAM.
If STREAM is omitted or nil, the value of `standard-output' is used.

arguments: (&optional printcharfun)Fprin1
Output the printed representation of OBJECT, any Lisp object.
Quoting characters are printed when needed to make output that `read'
can handle, whenever this is possible.
Output stream is STREAM, or value of `standard-output' (which see).

arguments: (obj &optional printcharfun)Fprin1-to-string
Return a string containing the printed representation of OBJECT,
any Lisp object.  Quoting characters are used when needed to make output
that `read' can handle, whenever this is possible, unless the optional
second argument NOESCAPE is non-nil.

arguments: (obj &optional noescape)Fprinc
Output the printed representation of OBJECT, any Lisp object.
No quoting characters are used; no delimiters are printed around
the contents of strings.
Output stream is STREAM, or value of standard-output (which see).

arguments: (obj &optional printcharfun)Fprint
Output the printed representation of OBJECT, with newlines around it.
Quoting characters are printed when needed to make output that `read'
can handle, whenever this is possible.
Output stream is STREAM, or value of `standard-output' (which see).

arguments: (obj &optional printcharfun)Fexternal-debugging-output
Write CHARACTER to stderr.
You can call print while debugging emacs, and pass it this function
to make it write to the debugging output.


arguments: (character)Vstandard-output
Output stream `print' uses by default for outputting a character.
This may be any function of one argument.
It may also be a buffer (output is inserted before point)
or a marker (output is inserted and the marker is advanced)
or the symbol t (output appears in the minibuffer line).Vfloat-output-format
The format descriptor string used to print floats.
This is a %-spec like those accepted by `printf' in C,
but with some restrictions.  It must start with the two characters `%.'.
After that comes an integer precision specification,
and then a letter which controls the format.
The letters allowed are `e', `f' and `g'.
Use `e' for exponential notation "DIG.DIGITSeEXPT"
Use `f' for decimal point notation "DIGITS.DIGITS".
Use `g' to choose the shorter of those two formats for the number at hand.
The precision in any of these cases is the number of digits following
the decimal point.  With `f', a precision of 0 means to omit the
decimal point.  0 is not allowed with `e' or `g'.

A value of nil means to use `%.20g'.Vprint-length
Maximum length of list to print before abbreviating.
A value of nil means no limit.Vprint-level
Maximum depth of list nesting to print before abbreviating.
A value of nil means no limit.Vprint-escape-newlines
Non-nil means print newlines in strings as backslash-n.Fprocessp
Return t if OBJECT is a process.

arguments: (obj)Fget-process
Return the process named NAME, or nil if there is none.

arguments: (name)Fget-buffer-process
Return the (or, a) process associated with BUFFER.
BUFFER may be a buffer or the name of one.

arguments: (name)Fdelete-process
Delete PROCESS: kill it and forget about it immediately.
PROCESS may be a process, a buffer, the name of a process or buffer, or
nil, indicating the current buffer's process.

arguments: (proc)Fprocess-status
Return the status of PROCESS: a symbol, one of these:
run  -- for a process that is running.
stop -- for a process stopped but continuable.
exit -- for a process that has exited.
signal -- for a process that has got a fatal signal.
open -- for a network stream connection that is open.
closed -- for a network stream connection that is closed.
nil -- if arg is a process name and no such process exists.
PROCESS may be a process, a buffer, the name of a process or buffer, or
nil, indicating the current buffer's process.

arguments: (proc)Fprocess-exit-status
Return the exit status of PROCESS or the signal number that killed it.
If PROCESS has not yet exited or died, return 0.

arguments: (proc)Fprocess-id
Return the process id of PROCESS.
This is the pid of the Unix process which PROCESS uses or talks to.
For a network connection, this value is nil.

arguments: (proc)Fprocess-name
Return the name of PROCESS, as a string.
This is the name of the program invoked in PROCESS,
possibly modified to make it unique among process names.

arguments: (proc)Fprocess-command
Return the command that was executed to start PROCESS.
This is a list of strings, the first string being the program executed
and the rest of the strings being the arguments given to it.
For a non-child channel, this is nil.

arguments: (proc)Fset-process-buffer
Set buffer associated with PROCESS to BUFFER (a buffer, or nil).

arguments: (proc buffer)Fprocess-buffer
Return the buffer PROCESS is associated with.
Output from PROCESS is inserted in this buffer
unless PROCESS has a filter.

arguments: (proc)Fprocess-mark
Return the marker for the end of the last output from PROCESS.

arguments: (proc)Fset-process-filter
Give PROCESS the filter function FILTER; nil means no filter.
When a process has a filter, each time it does output
the entire string of output is passed to the filter.
The filter gets two arguments: the process and the string of output.
If the process has a filter, its buffer is not used for output.

arguments: (proc filter)Fprocess-filter
Returns the filter function of PROCESS; nil if none.
See `set-process-filter' for more info on filter functions.

arguments: (proc)Fset-process-sentinel
Give PROCESS the sentinel SENTINEL; nil for none.
The sentinel is called as a function when the process changes state.
It gets two arguments: the process, and a string describing the change.

arguments: (proc sentinel)Fprocess-sentinel
Return the sentinel of PROCESS; nil if none.
See `set-process-sentinel' for more info on sentinels.

arguments: (proc)Fprocess-kill-without-query
Say no query needed if PROCESS is running when Emacs is exited.
Optional second argument if non-nill says to require a query.
Value is t if a query was formerly required.

arguments: (proc &optional value)Flist-processes
Display a list of all processes.
(Any processes listed as Exited or Signaled are actually eliminated
after the listing is made.)

arguments: ()Fprocess-list
Return a list of all processes.

arguments: ()Fstart-process
Start a program in a subprocess.  Return the process object for it.
Args are NAME BUFFER PROGRAM &rest PROGRAM-ARGS
NAME is name for process.  It is modified if necessary to make it unique.
BUFFER is the buffer or (buffer-name) to associate with the process.
 Process output goes at end of that buffer, unless you specify
 an output stream or filter function to handle the output.
 BUFFER may be also nil, meaning that this process is not associated
 with any buffer
Third arg is program file name.  It is searched for as in the shell.
Remaining arguments are strings to give program as arguments.Fopen-network-stream
Open a TCP connection for a service to a host.
Returns a subprocess-object to represent the connection.
Input and output work as for subprocesses; `delete-process' closes it.
Args are NAME BUFFER HOST SERVICE.
NAME is name for process.  It is modified if necessary to make it unique.
BUFFER is the buffer (or buffer-name) to associate with the process.
 Process output goes at end of that buffer, unless you specify
 an output stream or filter function to handle the output.
 BUFFER may be also nil, meaning that this process is not associated
 with any buffer
Third arg is name of the host to connect to, or its IP address.
Fourth arg SERVICE is name of the service desired, or an integer
 specifying a port number to connect to.

arguments: (name buffer host service)Faccept-process-output
Allow any pending output from subprocesses to be read by Emacs.
It is read into the process' buffers or given to their filter functions.
Non-nil arg PROCESS means do not return until some output has been received
from PROCESS.
Non-nil second arg TIMEOUT and third arg TIMEOUT-MSECS are number of
seconds and microseconds to wait; return after that much time whether
or not there is input.
Return non-nil iff we received any output before the timeout expired.

arguments: (&optional proc timeout timeout-msecs)Fwaiting-for-user-input-p
Returns non-NIL if emacs is waiting for input from the user.
This is intended for use by asynchronous process output filters and sentinels.

arguments: ()Fprocess-send-region
Send current contents of region as input to PROCESS.
PROCESS may be a process, a buffer, the name of a process or buffer, or
nil, indicating the current buffer's process.
Called from program, takes three arguments, PROCESS, START and END.
If the region is more than 500 characters long,
it is sent in several bunches.  This may happen even for shorter regions.
Output from processes can arrive in between bunches.

arguments: (process start end)Fprocess-send-string
Send PROCESS the contents of STRING as input.
PROCESS may be a process, a buffer, the name of a process or buffer, or
nil, indicating the current buffer's process.
If STRING is more than 500 characters long,
it is sent in several bunches.  This may happen even for shorter strings.
Output from processes can arrive in between bunches.

arguments: (process string)Finterrupt-process
Interrupt process PROCESS.  May be process or name of one.
PROCESS may be a process, a buffer, or the name of a process or buffer.
Nil or no arg means current buffer's process.
Second arg CURRENT-GROUP non-nil means send signal to
the current process-group of the process's controlling terminal
rather than to the process's own process group.
If the process is a shell, this means interrupt current subjob
rather than the shell.

arguments: (&optional process current-group)Fkill-process
Kill process PROCESS.  May be process or name of one.
See function `interrupt-process' for more details on usage.

arguments: (&optional process current-group)Fquit-process
Send QUIT signal to process PROCESS.  May be process or name of one.
See function `interrupt-process' for more details on usage.

arguments: (&optional process current-group)Fstop-process
Stop process PROCESS.  May be process or name of one.
See function `interrupt-process' for more details on usage.

arguments: (&optional process current-group)Fcontinue-process
Continue process PROCESS.  May be process or name of one.
See function `interrupt-process' for more details on usage.

arguments: (&optional process current-group)Fsignal-process
Send the process with number PID the signal with code CODE.
Both PID and CODE are integers.

arguments: (pid sig)Fprocess-send-eof
Make PROCESS see end-of-file in its input.
Eof comes after any text already sent to it.
PROCESS may be a process, a buffer, the name of a process or buffer, or
nil, indicating the current buffer's process.

arguments: (&optional process)Fprocess-connection
Return the connection type of `PROCESS'.  This can be nil (pipe),
t or pty (pty) or stream (socket connection).

arguments: (&optional process)Vdelete-exited-processes
*Non-nil means delete processes immediately when they exit.
nil means don't delete them until `list-processes' is run.Vprocess-connection-type
Control type of device used to communicate with subprocesses.
Values are nil to use a pipe, and t or 'pty for a pty.  Note that if
pty's are not available, this variable will be ignored. The value takes
effect when `start-process' is called.Fget-buffer-process
Return the (or, a) process associated with BUFFER.
This copy of Emacs has not been built to support subprocesses, so this
function always returns nil.

arguments: (name)Flooking-at
Return t if text after point matches regular expression PAT.
This function modifies the match data that `match-beginning',
`match-end' and `match-data' access; save and restore the match
data if you want to preserve them.

arguments: (string)Fstring-match
Return index of start of first match for REGEXP in STRING, or nil.
If third arg START is non-nil, start search at that index in STRING.
For index of first char beyond the match, do (match-end 0).
`match-end' and `match-beginning' also give indices of substrings
matched by parenthesis constructs in the pattern.

arguments: (regexp string &optional start)Fskip-chars-forward
Move point forward, stopping before a char not in CHARS, or at position LIM.
CHARS is like the inside of a `[...]' in a regular expression
except that `]' is never special and `\' quotes `^', `-' or `\'.
Thus, with arg "a-zA-Z", this skips letters stopping before first nonletter.
With arg "^a-zA-Z", skips nonletters stopping before first letter.
Returns the distance traveled, either zero or positive.

arguments: (string &optional lim)Fskip-chars-backward
Move point backward, stopping after a char not in CHARS, or at position LIM.
See `skip-chars-forward' for details.
Returns the distance traveled, either zero or negative.

arguments: (string &optional lim)Fskip-syntax-forward
Move point forward across chars in specified syntax classes.
SYNTAX is a string of syntax code characters.
Stop before a char whose syntax is not in SYNTAX, or at position LIM.
If SYNTAX starts with ^, skip characters whose syntax is NOT in SYNTAX.
This function returns the distance traveled, either zero or positive.

arguments: (syntax &optional lim)Fskip-syntax-backward
Move point backward across chars in specified syntax classes.
SYNTAX is a string of syntax code characters.
Stop on reaching a char whose syntax is not in SYNTAX, or at position LIM.
If SYNTAX starts with ^, skip characters whose syntax is NOT in SYNTAX.
This function returns the distance traveled, either zero or negative.

arguments: (syntax &optional lim)Fsearch-backward
Search backward from point for STRING.
Set point to the beginning of the occurrence found, and return point.
An optional second argument bounds the search; it is a buffer position.
The match found must not extend before that position.
Optional third argument, if t, means if fail just return nil (no error).
 If not nil and not t, position at limit of search and return nil.
Optional fourth argument is repeat count--search for successive occurrences.
See also the functions `match-beginning', `match-end' and `replace-match'.

arguments: (string &optional bound noerror count)Fsearch-forward
Search forward from point for STRING.
Set point to the end of the occurrence found, and return point.
An optional second argument bounds the search; it is a buffer position.
The match found must not extend after that position.  nil is equivalent
  to (point-max).
Optional third argument, if t, means if fail just return nil (no error).
  If not nil and not t, move to limit of search and return nil.
Optional fourth argument is repeat count--search for successive occurrences.
See also the functions `match-beginning', `match-end' and `replace-match'.

arguments: (string &optional bound noerror count)Fword-search-backward
Search backward from point for STRING, ignoring differences in punctuation.
Set point to the beginning of the occurrence found, and return point.
An optional second argument bounds the search; it is a buffer position.
The match found must not extend before that position.
Optional third argument, if t, means if fail just return nil (no error).
  If not nil and not t, move to limit of search and return nil.
Optional fourth argument is repeat count--search for successive occurrences.

arguments: (string &optional bound noerror count)Fword-search-forward
Search forward from point for STRING, ignoring differences in punctuation.
Set point to the end of the occurrence found, and return point.
An optional second argument bounds the search; it is a buffer position.
The match found must not extend after that position.
Optional third argument, if t, means if fail just return nil (no error).
  If not nil and not t, move to limit of search and return nil.
Optional fourth argument is repeat count--search for successive occurrences.

arguments: (string &optional bound noerror count)Fre-search-backward
Search backward from point for match for regular expression REGEXP.
Set point to the beginning of the match, and return point.
The match found is the one starting last in the buffer
and yet ending before the place the origin of the search.
An optional second argument bounds the search; it is a buffer position.
The match found must start at or after that position.
Optional third argument, if t, means if fail just return nil (no error).
  If not nil and not t, move to limit of search and return nil.
Optional fourth argument is repeat count--search for successive occurrences.
See also the functions `match-beginning', `match-end' and `replace-match'.

arguments: (string &optional bound noerror count)Fre-search-forward
Search forward from point for regular expression REGEXP.
Set point to the end of the occurrence found, and return point.
An optional second argument bounds the search; it is a buffer position.
The match found must not extend after that position.
Optional third argument, if t, means if fail just return nil (no error).
  If not nil and not t, move to limit of search and return nil.
Optional fourth argument is repeat count--search for successive occurrences.
See also the functions `match-beginning', `match-end' and `replace-match'.

arguments: (string &optional bound noerror count)Freplace-match
Replace text matched by last search with NEWTEXT.
If second arg FIXEDCASE is non-nil, do not alter case of replacement text.
Otherwise convert to all caps or cap initials, like replaced text.
If third arg LITERAL is non-nil, insert NEWTEXT literally.
Otherwise treat `\' as special:
  `\&' in NEWTEXT means substitute original matched text.
  `\N' means substitute what matched the Nth `\(...\)'.
       If Nth parens didn't match, substitute nothing.
  `\\' means insert one `\'.
FIXEDCASE and LITERAL are optional arguments.
Leaves point at end of replacement text.

arguments: (string &optional fixedcase literal)Fmatch-beginning
Return position of start of text matched by last search.
ARG, a number, specifies which parenthesized expression in the last regexp.
 Value is nil if ARGth pair didn't match, or there were less than ARG pairs.
Zero means the entire text matched by the whole regexp or whole string.

arguments: (num)Fmatch-end
Return position of end of text matched by last search.
ARG, a number, specifies which parenthesized expression in the last regexp.
 Value is nil if ARGth pair didn't match, or there were less than ARG pairs.
Zero means the entire text matched by the whole regexp or whole string.

arguments: (num)Fmatch-data
Return a list containing all info on what the last search matched.
Element 2N is `(match-beginning N)'; element 2N + 1 is `(match-end N)'.
All the elements are markers or nil (nil if the Nth pair didn't match)
if the last match was on a buffer; integers or nil if a string was matched.
Use `store-match-data' to reinstate the data in this list.

arguments: ()Fstore-match-data
Set internal data on last search match from elements of LIST.
LIST should have been created by calling `match-data' previously.

arguments: (list)Fregexp-quote
Return a regexp string which matches exactly STRING and nothing else.

arguments: (str)Fsyntax-table-p
Return t if ARG is a syntax table.
Any vector of 256 elements will do.

arguments: (obj)Fsyntax-table
Return the current syntax table.
This is the one specified by the current buffer.

arguments: ()Fstandard-syntax-table
Return the standard syntax table.
This is the one used for new buffers.

arguments: ()Fcopy-syntax-table
Construct a new syntax table and return it.
It is a copy of the TABLE, which defaults to the standard syntax table.

arguments: (&optional table)Fset-syntax-table
Select a new syntax table for the current buffer.
One argument, a syntax table.

arguments: (table)Fchar-syntax
Return the syntax code of CHAR, described by a character.
For example, if CHAR is a word constituent, the character `?w' is returned.
The characters that correspond to various syntax codes
are listed in the documentation of `modify-syntax-entry'.

arguments: (ch)Fmodify-syntax-entry
Set syntax for character CHAR according to string S.
The syntax is changed only for table TABLE, which defaults to
 the current buffer's syntax table.
The first character of S should be one of the following:
  Space or -  whitespace syntax.    w   word constituent.
  _           symbol constituent.   .   punctuation.
  (           open-parenthesis.     )   close-parenthesis.
  "           string quote.         \   escape.
  $           paired delimiter.     '   expression quote or prefix operator.
  <           comment starter.      >   comment ender.
                  
  /           character-quote.
Only single-character comment start and end sequences are represented thus.
Two-character sequences are represented as described below.
The second character of S is the matching parenthesis,
 used only if the first character is `(' or `)'.
Any additional characters are flags.
Defined flags are the characters 1, 2, 3, 4, b, and p.
 1 means C is the start of a two-char comment start sequence.
 2 means C is the second character of such a sequence.
 3 means C is the start of a two-char comment end sequence.
 4 means C is the second character of such a sequence.

There can be up to two orthogonal comment sequences. This is to support
language modes such as C++.  By default, all comment sequences are of style
a, but you can set the comment sequence style to b (on the second character of a
comment-start, or the first character of a comment-end sequence) by using
this flag:
 b means C is part of comment sequence b.

 p means C is a prefix character for `backward-prefix-chars';
   such characters are treated as whitespace when they occur
   between expressions.

arguments: (char s &optional table)Fdescribe-syntax
Describe the syntax specifications in the syntax table.
The descriptions are inserted in a buffer, which is then displayed.

arguments: ()Fforward-word
Move point forward ARG words (backward if ARG is negative).
Normally returns t.
If an edge of the buffer is reached, point is left there
and nil is returned.

arguments: (count)Fforward-comment
Move forward across up to N comments.  If N is negative, move backward.
Stop scanning if we find something other than a comment or whitespace.
Set point to where scanning stops.
If N comments are found as expected, with nothing except whitespace
between them, return t; otherwise return nil.

arguments: (count)Fscan-lists
Scan from character number FROM by COUNT lists.
Returns the character number of the position thus found.

If DEPTH is nonzero, paren depth begins counting from that value,
only places where the depth in parentheses becomes zero
are candidates for stopping; COUNT such places are counted.
Thus, a positive value for DEPTH means go out levels.

Comments are ignored if `parse-sexp-ignore-comments' is non-nil.

If the beginning or end of (the accessible part of) the buffer is reached
and the depth is wrong, an error is signaled.
If the depth is right but the count is not used up, nil is returned.

arguments: (from count depth)Fscan-sexps
Scan from character number FROM by COUNT balanced expressions.
If COUNT is negative, scan backwards.
Returns the character number of the position thus found.

Comments are ignored if `parse-sexp-ignore-comments' is non-nil.

If the beginning or end of (the accessible part of) the buffer is reached
in the middle of a parenthetical grouping, an error is signaled.
If the beginning or end is reached between groupings
but before count is used up, nil is returned.

arguments: (from count)Fbackward-prefix-chars
Move point backward over any number of chars with prefix syntax.
This includes chars with "quote" or "prefix" syntax (' or p).

arguments: ()Fparse-partial-sexp
Parse Lisp syntax starting at FROM until TO; return status of parse at TO.
Parsing stops at TO or when certain criteria are met;
 point is set to where parsing stops.
If fifth arg STATE is omitted or nil,
 parsing assumes that FROM is the beginning of a function.
Value is a list of eight elements describing final state of parsing:
 1. depth in parens.
 2. character address of start of innermost containing list; nil if none.
 3. character address of start of last complete sexp terminated.
 4. non-nil if inside a string.
    (it is the character that will terminate the string.)
 5. t if inside a comment.
 6. t if following a quote character.
 7. the minimum paren-depth encountered during this scan.
 8. t if in a comment of style `b'.
If third arg TARGETDEPTH is non-nil, parsing stops if the depth
in parentheses becomes equal to TARGETDEPTH.
Fourth arg STOPBEFORE non-nil means stop when come to
 any character that starts a sexp.
Fifth arg STATE is a seven-list like what this function returns.
It is used to initialize the state of the parse.  Its second and third
elements are ignored.
Sixth args COMMENTSTOP non-nil means stop at the start of a comment.

arguments: (from to &optional targetdepth stopbefore state commentstop)Vparse-sexp-ignore-comments
Non-nil means `forward-sexp', etc., should treat comments as whitespace.Vwords-include-escapes
Non-nil means `forward-word', etc., should treat escape chars part of words.Ftext-properties-at
Return the list of properties held by the character at POSITION
in optional argument OBJECT, a string or buffer.  If nil, OBJECT
defaults to the current buffer.
If POSITION is at the end of OBJECT, the value is nil.

arguments: (pos &optional object)Fget-text-property
Return the value of position POS's property PROP, in OBJECT.
OBJECT is optional and defaults to the current buffer.
If POSITION is at the end of OBJECT, the value is nil.

arguments: (pos prop &optional object)Fnext-property-change
Return the position of next property change.
Scans characters forward from POS in OBJECT till it finds
a change in some text property, then returns the position of the change.
The optional second argument OBJECT is the string or buffer to scan.
Return nil if the property is constant all the way to the end of OBJECT.
If the value is non-nil, it is a position greater than POS, never equal.

arguments: (pos &optional object)Fnext-single-property-change
Return the position of next property change for a specific property.
Scans characters forward from POS till it finds
a change in the PROP property, then returns the position of the change.
The optional third argument OBJECT is the string or buffer to scan.
Return nil if the property is constant all the way to the end of OBJECT.
If the value is non-nil, it is a position greater than POS, never equal.

arguments: (pos &optional prop object)Fprevious-property-change
Return the position of previous property change.
Scans characters backwards from POS in OBJECT till it finds
a change in some text property, then returns the position of the change.
The optional second argument OBJECT is the string or buffer to scan.
Return nil if the property is constant all the way to the start of OBJECT.
If the value is non-nil, it is a position less than POS, never equal.

arguments: (pos &optional object)Fprevious-single-property-change
Return the position of previous property change for a specific property.
Scans characters backward from POS till it finds
a change in the PROP property, then returns the position of the change.
The optional third argument OBJECT is the string or buffer to scan.
Return nil if the property is constant all the way to the start of OBJECT.
If the value is non-nil, it is a position less than POS, never equal.

arguments: (pos prop &optional object)Fadd-text-properties
Add properties to the text from START to END.
The third argument PROPS is a property list
specifying the property values to add.
The optional fourth argument, OBJECT,
is the string or buffer containing the text.
Return t if any property value actually changed, nil otherwise.

arguments: (start end properties &optional object)Fput-text-property
Set one property of the text from START to END.
The third and fourth arguments PROP and VALUE
specify the property to add.
The optional fifth argument, OBJECT,
is the string or buffer containing the text.

arguments: (start end prop value &optional object)Fset-text-properties
Completely replace properties of text from START to END.
The third argument PROPS is the new property list.
The optional fourth argument, OBJECT,
is the string or buffer containing the text.

arguments: (start end props &optional object)Fremove-text-properties
Remove some properties from text from START to END.
The third argument PROPS is a property list
whose property names specify the properties to remove.
(The values stored in PROPS are ignored.)
The optional fourth argument, OBJECT,
is the string or buffer containing the text.
Return t if any property was actually removed, nil otherwise.

arguments: (start end props &optional object)Ftext-property-any
Check text from START to END to see if PROP is ever `eq' to VALUE.
If so, return the position of the first character whose PROP is `eq'
to VALUE.  Otherwise return nil.
The optional fifth argument, OBJECT, is the string or buffer
containing the text.

arguments: (start end prop value &optional object)Ftext-property-not-all
Check text from START to END to see if PROP is ever not `eq' to VALUE.
If so, return the position of the first character whose PROP is not
`eq' to VALUE.  Otherwise, return nil.
The optional fifth argument, OBJECT, is the string or buffer
containing the text.

arguments: (start end prop value &optional object)Ferase-text-properties
Remove all properties from the text from START to END.
The optional third argument, OBJECT,
is the string or buffer containing the text.

arguments: (start end &optional object)Vinterval-balance-threshold
Threshold for rebalancing interval trees, expressed as the
percentage by which the left interval tree should not differ from the right.Fundo-boundary
Mark a boundary between units of undo.
An undo command will stop at this point,
but another undo command will undo to the previous boundary.

arguments: ()Fprimitive-undo
Undo N records from the front of the list LIST.
Return what remains of the list.

arguments: (n list)Fwindowp
Returns t if OBJ is a window.

arguments: (obj)Fwindow-live-p
Returns t if OBJ is a window which is currently visible.

arguments: (obj)Fselected-window
Return the window that the cursor now appears in and commands apply to.

arguments: ()Fminibuffer-window
Return the window used now for minibuffers.
If the optional argument FRAME is specified, return the minibuffer window
used by that frame.

arguments: (&optional frame)Fwindow-minibuffer-p
Returns non-nil if WINDOW is a minibuffer window.

arguments: (&optional window)Fpos-visible-in-window-p
Return t if position POS is currently on the frame in WINDOW.
Returns nil if that position is scrolled vertically out of view.
POS defaults to point; WINDOW, to the selected window.

arguments: (&optional pos window)Fwindow-buffer
Return the buffer that WINDOW is displaying.

arguments: (&optional window)Fwindow-height
Return the number of lines in WINDOW (including its mode line).

arguments: (&optional window)Fwindow-width
Return the number of columns in WINDOW.

arguments: (&optional window)Fwindow-hscroll
Return the number of columns by which WINDOW is scrolled from left margin.

arguments: (&optional window)Fset-window-hscroll
Set number of columns WINDOW is scrolled from left margin to NCOL.
NCOL should be zero or positive.

arguments: (window ncol)Fwindow-edges
Return a list of the edge coordinates of WINDOW.
(LEFT TOP RIGHT BOTTOM), all relative to 0, 0 at top left corner of frame.
RIGHT is one more than the rightmost column used by WINDOW,
and BOTTOM is one more than the bottommost row used by WINDOW
 and its mode-line.

arguments: (&optional window)Fcoordinates-in-window-p
Return non-nil if COORDINATES are in WINDOW.
COORDINATES is a cons of the form (X . Y), X and Y being distances
measured in characters from the upper-left corner of the frame.
(0 .  0) denotes the character in the upper left corner of the
frame.
If COORDINATES are in the text portion of WINDOW,
   the coordinates relative to the window are returned.
If they are in the mode line of WINDOW, `mode-line' is returned.
If they are on the border between WINDOW and its right sibling,
   `vertical-line' is returned.

arguments: (coordinates window)Fwindow-at
Return window containing coordinates X and Y on FRAME.
If omitted, FRAME defaults to the currently selected frame.
The top left corner of the frame is considered to be row 0,
column 0.

arguments: (x y &optional frame)Fwindow-point
Return current value of point in WINDOW.
For a nonselected window, this is the value point would have
if that window were selected.

Note that, when WINDOW is the selected window and its buffer
is also currently selected, the value returned is the same as (point).
It would be more strictly correct to return the `top-level' value
of point, outside of any save-excursion forms.
But that is hard to define.

arguments: (&optional window)Fwindow-start
Return position at which display currently starts in WINDOW.

arguments: (&optional window)Fwindow-end
Return position at which display currently ends in WINDOW.

arguments: (&optional window)Fset-window-point
Make point value in WINDOW be at position POS in WINDOW's buffer.

arguments: (window pos)Fset-window-start
Make display in WINDOW start at position POS in WINDOW's buffer.
Optional third arg NOFORCE non-nil inhibits next redisplay
from overriding motion of point in order to display at this exact start.

arguments: (window pos &optional noforce)Fwindow-dedicated-p
Return WINDOW's dedicated object, usually t or nil.
See also `set-window-dedicated-p'.

arguments: (window)Fset-window-dedicated-p
Control whether WINDOW is dedicated to the buffer it displays.
If it is dedicated, Emacs will not automatically change
which buffer appears in it.
The second argument is the new value for the dedication flag;
non-nil means yes.

arguments: (window arg)Fwindow-display-table
Return the display-table that WINDOW is using.

arguments: (&optional window)Fset-window-display-table
Set WINDOW's display-table to TABLE.

arguments: (window table)Fdelete-window
Remove WINDOW from the display.  Default is selected window.

arguments: (&optional window)Fnext-window
Return next window after WINDOW in canonical ordering of windows.
If omitted, WINDOW defaults to the selected window.

Optional second arg MINIBUF t means count the minibuffer window even
if not active.  MINIBUF nil or omitted means count the minibuffer iff
it is active.  MINIBUF neither t nor nil means not to count the
minibuffer even if it is active.

Several frames may share a single minibuffer; if the minibuffer
counts, all windows on all frames that share that minibuffer count
too.  This means that next-window may be used to iterate through the
set of windows even when the minibuffer is on another frame.  If the
minibuffer does not count, only windows from WINDOW's frame count.

Optional third arg ALL-FRAMES t means include windows on all frames.
ALL-FRAMES nil or omitted means cycle within the frames as specified
above.  If neither nil nor t, restrict to WINDOW's frame.

If you use consistent values for MINIBUF and ALL-FRAMES, you can use
`next-window' to iterate through the entire cycle of acceptable
windows, eventually ending up back at the window you started with.
`previous-window' traverses the same cycle, in the reverse order.

arguments: (&optional window minibuf all-frames)Fprevious-window
Return the window preceeding WINDOW in canonical ordering of windows.
If omitted, WINDOW defaults to the selected window.

Optional second arg MINIBUF t means count the minibuffer window even
if not active.  MINIBUF nil or omitted means count the minibuffer iff
it is active.  MINIBUF neither t nor nil means not to count the
minibuffer even if it is active.

Several frames may share a single minibuffer; if the minibuffer
counts, all windows on all frames that share that minibuffer count
too.  This means that previous-window may be used to iterate through
the set of windows even when the minibuffer is on another frame.  If
the minibuffer does not count, only windows from WINDOW's frame
count.

Optional third arg ALL-FRAMES t means include windows on all frames.
ALL-FRAMES nil or omitted means cycle within the frames as specified
above.  If neither nil nor t, restrict to WINDOW's frame.

If you use consistent values for MINIBUF and ALL-FRAMES, you can use
`previous-window' to iterate through the entire cycle of acceptable
windows, eventually ending up back at the window you started with.
`next-window' traverses the same cycle, in the reverse order.

arguments: (&optional window minibuf all-frames)Fother-window
Select the ARG'th different window on this frame.
All windows on current frame are arranged in a cyclic order.
This command selects the window ARG steps away in that order.
A negative ARG moves in the opposite order.  If the optional second
argument ALL_FRAMES is non-nil, cycle through all frames.

arguments: (n &optional all-frames)Fget-lru-window
Return the window least recently selected or used for display.
If optional argument FRAMES is t, search all frames.  If FRAME is a
frame, search only that frame.


arguments: (&optional frames)Fget-largest-window
Return the largest window in area.
If optional argument FRAMES is t, search all frames.  If FRAME is a
frame, search only that frame.


arguments: (&optional frame)Fget-buffer-window
Return a window currently displaying BUFFER, or nil if none.
If optional argument FRAME is t, search all visible frames.
If FRAME is nil, search only the selected frame.
If FRAME is a frame, search only that frame.


arguments: (buffer &optional frame)Fdelete-other-windows
Make WINDOW (or the selected window) fill its frame.
Only the frame WINDOW is on is affected.

arguments: (&optional window)Fdelete-windows-on
Delete all windows showing BUFFER.
Optional second argument FRAME controls which frames are affected.
If nil or omitted, delete all windows showing BUFFER in any frame.
If t, delete only windows showing BUFFER in the selected frame.
If a frame, delete only windows showing BUFFER in that frame.

arguments: (buffer frame)Freplace-buffer-in-windows
Replace BUFFER with some other buffer in all windows showing it.

arguments: (buffer)Fset-window-buffer
Make WINDOW display BUFFER as its contents.
BUFFER can be a buffer or buffer name.

arguments: (window buffer)Fselect-window
Select WINDOW.  Most editing will apply to WINDOW's buffer.
The main editor command loop selects the buffer of the selected window
before each command.

arguments: (window)Fdisplay-buffer
Make BUFFER appear in some window but don't select it.
BUFFER can be a buffer or a buffer name.
If BUFFER is shown already in some window, just use that one,
unless the window is the selected window and the optional second
argument NOT-THIS-WINDOW is non-nil (interactively, with prefix arg).
Returns the window displaying BUFFER.

arguments: (buffer &optional not-this-window)Fsplit-window
Split WINDOW, putting SIZE lines in the first of the pair.
WINDOW defaults to selected one and SIZE to half its size.
If optional third arg HOR-FLAG is non-nil, split side by side
and put SIZE columns in the first of the pair.

arguments: (&optional window chsize horflag)Fenlarge-window
Make current window ARG lines bigger.
From program, optional second arg non-nil means grow sideways ARG columns.

arguments: (n &optional side)Fshrink-window
Make current window ARG lines smaller.
From program, optional second arg non-nil means shrink sideways ARG columns.

arguments: (n &optional side)Fscroll-up
Scroll text of current window upward ARG lines; or near full screen if no ARG.
A near full screen is `next-screen-context-lines' less than a full screen.
When calling from a program, supply a number as argument or nil.

arguments: (&optional n)Fscroll-down
Scroll text of current window downward ARG lines; or near full screen if no ARG.
A near full screen is `next-screen-context-lines' less than a full screen.
When calling from a program, supply a number as argument or nil.

arguments: (&optional n)Fscroll-other-window
Scroll next window upward ARG lines; or near full screen if no ARG.
The next window is the one below the current one; or the one at the top
if the current one is at the bottom.
When calling from a program, supply a number as argument or nil.

If in the minibuffer, `minibuf-scroll-window' if non-nil
specifies the window to scroll.
If `other-window-scroll-buffer' is non-nil, scroll the window
showing that buffer, popping the buffer up if necessary.

arguments: (&optional n)Fscroll-left
Scroll selected window display ARG columns left.
Default for ARG is window width minus 2.

arguments: (&optional arg)Fscroll-right
Scroll selected window display ARG columns right.
Default for ARG is window width minus 2.

arguments: (&optional arg)Frecenter
Center point in window and redisplay frame.  With ARG, put point on line ARG.
The desired position of point is always relative to the current window.
Just C-u as prefix means put point in the center of the window.
No arg (i.e., it is nil) erases the entire frame and then
redraws with point in the center of the current window.

arguments: (&optional n)Fmove-to-window-line
Position point relative to window.
With no argument, position text at center of window.
An argument specifies frame line; zero means top of window,
negative means relative to bottom of window.

arguments: (arg)Fwindow-configuration-p
T if OBJECT is a window-configration object.

arguments: (obj)Fset-window-configuration
Set the configuration of windows and buffers as specified by CONFIGURATION.
CONFIGURATION must be a value previously returned
by `current-window-configuration' (which see).

arguments: (configuration)Fcurrent-window-configuration
Return an object representing the current window configuration of FRAME.
If FRAME is nil or omitted, use the selected frame.
This describes the number of windows, their sizes and current buffers,
and for each displayed buffer, where display starts, and the positions of
point and mark.  An exception is made for point in the current buffer:
its value is -not- saved.
This also records the currently selected frame, and FRAME's focus
redirection (see `redirect-frame-focus').

arguments: (&optional frame)Fsave-window-excursion
Execute body, preserving window sizes and contents.
Restores which buffer appears in which window, where display starts,
as well as the current buffer.
Does not restore the value of point in current buffer.Vtemp-buffer-show-function
Non-nil means call as function to display a help buffer.
Used by `with-output-to-temp-buffer'.Vdisplay-buffer-function
If non-nil, function to call to handle `display-buffer'.
It will receive two args, the buffer and a flag which if non-nil means
 that the currently selected window is not acceptable.
Commands such as `switch-to-buffer-other-window' and `find-file-other-window'
work using this function.Vminibuffer-scroll-window
Non-nil means it is the window that C-M-v in minibuffer should scroll.Vother-window-scroll-buffer
If non-nil, this is a buffer and \[scroll-other-window] should scroll its window.Vpop-up-frames
*Non-nil means `display-buffer' should make a separate frame.Vpop-up-frame-function
*If non-nil, function to call to handle automatic new frame creation.
It is called with no arguments and should return a newly created frame.

A typical value might be `(lambda () (new-frame pop-up-frame-alist))'
where `pop-up-frame-alist' would hold the default frame parameters.Vpop-up-windows
*Non-nil means display-buffer should make new windows.Vnext-screen-context-lines
*Number of lines of continuity when scrolling by screenfuls.Vsplit-height-threshold
*display-buffer would prefer to split the largest window if this large.
If there is only one window, it is split regardless of this value.Vwindow-min-height
*Delete any window less than this tall (including its mode line).Vwindow-min-width
*Delete any window less than this wide.Vglobal-mode-string
String (or mode line construct) included (normally) in `mode-line-format'.Voverlay-arrow-position
Marker for where to display an arrow on top of the buffer text.
This must be the beginning of a line in order to work.
See also `overlay-arrow-string'.Voverlay-arrow-string
String to display as an arrow.  See also `overlay-arrow-position'.Vscroll-step
*The number of lines to try scrolling a window by when point moves out.
If that fails to bring point back on frame, point is centered instead.
If this is zero, point is always centered after it moves off frame.Vdebug-end-pos
Don't askVtruncate-partial-width-windows
*Non-nil means truncate lines in all windows less than full frame wide.Vmode-line-inverse-video
*Non-nil means use inverse video for the mode line.Vline-number-display-limit
*Maximum buffer size for which line number should be displayed.Vhighlight-nonselected-windows
*Non-nil means highlight region even in nonselected windows.Fframe-face-alist


arguments: (frame)Fset-frame-face-alist


arguments: (frame value)Fmake-face-internal
Create face number FACE-ID on all frames.

arguments: (face-id)Fset-face-attribute-internal


arguments: (face-id attr-name attr-value frame)Finternal-next-face-id


arguments: ()Vregion-face
Face number to use to highlight the region
The region is highlighted with this face
when Transient Mark mode is enabled and the mark is active.Fx-popup-menu
Pop up a deck-of-cards menu and return user's selection.
POSITION is a position specification.  This is either a mouse button event
or a list ((XOFFSET YOFFSET) WINDOW)
where XOFFSET and YOFFSET are positions in characters from the top left
corner of WINDOW's frame.  (WINDOW may be a frame object instead of a window.)
This controls the position of the center of the first line
in the first pane of the menu, not the top left of the menu as a whole.

MENU is a specifier for a menu.  For the simplest case, MENU is a keymap.
The menu items come from key bindings that have a menu string as well as
a definition; actually, the "definition" in such a key binding looks like
(STRING . REAL-DEFINITION).  To give the menu a title, put a string into
the keymap as a top-level element.

You can also use a list of keymaps as MENU.
  Then each keymap makes a separate pane.
When MENU is a keymap or a list of keymaps, the return value
is a list of events.

Alternatively, you can specify a menu of multiple panes
  with a list of the form (TITLE PANE1 PANE2...),
where each pane is a list of form (TITLE ITEM1 ITEM2...).
Each ITEM is normally a cons cell (STRING . VALUE);
but a string can appear as an item--that makes a nonselectable line
in the menu.
With this form of menu, the return value is VALUE from the chosen item.

arguments: (position &optional menu)
Vonly-global-abbrevs
*t means user plans to use global abbrevs only.
Makes the commands to define mode-specific abbrevs define global ones instead.
Fabbrev-mode
Toggle abbrev mode.
With argument ARG, turn abbrev mode on iff ARG is positive.
In abbrev mode, inserting an abbreviation causes it to expand
and be replaced by its expansion.
Vedit-abbrevs-map
Keymap used in edit-abbrevs.
Fkill-all-abbrevs
Undefine all defined abbrevs.
Finsert-abbrevs
Insert after point a description of all defined abbrevs.
Mark is set after the inserted text.
Flist-abbrevs
Display a list of all defined abbrevs.
Fedit-abbrevs-mode
Major mode for editing the list of abbrev definitions.
\{edit-abbrevs-map}
Fedit-abbrevs
Alter abbrev definitions by editing a list of them.
Selects a buffer containing a list of abbrev definitions.
You can edit them and type \<edit-abbrevs-map>\[edit-abbrevs-redefine] to redefine abbrevs
according to your editing.
Buffer contains a header line for each abbrev table,
 which is the abbrev table name in parentheses.
This is followed by one line per abbrev in that table:
NAME   USECOUNT   EXPANSION   HOOK
where NAME and EXPANSION are strings with quotes,
USECOUNT is an integer, and HOOK is any valid function
or may be omitted (it is usually omitted).
Fedit-abbrevs-redefine
Redefine abbrevs according to current buffer contents.
Fdefine-abbrevs
Define abbrevs according to current visible buffer contents.
See documentation of `edit-abbrevs' for info on the format of the
text you must have in the buffer.
With argument, eliminate all abbrev definitions except
the ones defined from the buffer now.
Fread-abbrev-file
Read abbrev definitions from file written with `write-abbrev-file'.
Optional argument FILE is the name of the file to read;
it defaults to the value of `abbrev-file-name'.
Optional second argument QUIETLY non-nil means don't print anything.
Fquietly-read-abbrev-file
Read abbrev definitions from file written with write-abbrev-file.
Optional argument FILE is the name of the file to read;
it defaults to the value of `abbrev-file-name'.
Does not print anything.
Fwrite-abbrev-file
Write all abbrev definitions to a file of Lisp code.
The file written can be loaded in another session to define the same abbrevs.
The argument FILE is the file name to write.
Fadd-mode-abbrev
Define mode-specific abbrev for last word(s) before point.
Argument is how many words before point form the expansion;
or zero means the region is the expansion.
A negative argument means to undefine the specified abbrev.
Reads the abbreviation in the minibuffer.

Don't use this function in a Lisp program; use `define-abbrev' instead.
Fadd-global-abbrev
Define global (all modes) abbrev for last word(s) before point.
The prefix argument specifies the number of words before point that form the
expansion; or zero means the region is the expansion.
A negative argument means to undefine the specified abbrev.
This command uses the minibuffer to read the abbreviation.

Don't use this function in a Lisp program; use `define-abbrev' instead.
Finverse-add-mode-abbrev
Define last word before point as a mode-specific abbrev.
With prefix argument N, defines the Nth word before point.
This command uses the minibuffer to read the expansion.
Expands the abbreviation after defining it.
Finverse-add-global-abbrev
Define last word before point as a global (mode-independent) abbrev.
With prefix argument N, defines the Nth word before point.
This command uses the minibuffer to read the expansion.
Expands the abbreviation after defining it.
Fabbrev-prefix-mark
Mark current point as the beginning of an abbrev.
Abbrev to be expanded starts here rather than at beginning of word.
This way, you can expand an abbrev with a prefix: insert the prefix,
use this command, then insert the abbrev.
Fexpand-region-abbrevs
For abbrev occurrence in the region, offer to expand it.
The user is asked to type y or n for each occurrence.
A prefix argument means don't query; expand all abbrevs.
If called from a Lisp program, arguments are START END &optional NOQUERY.
VBuffer-menu-mode-map

FBuffer-menu-mode
Major mode for editing a list of buffers.
Each line describes one of the buffers in Emacs.
Letters do not insert themselves; instead, they are commands.
\<Buffer-menu-mode-map>
\[Buffer-menu-mark] -- mark buffer to be displayed.
\[Buffer-menu-select] -- select buffer of line point is on.
  Also show buffers marked with m in other windows.
\[Buffer-menu-1-window] -- select that buffer in full-frame window.
\[Buffer-menu-2-window] -- select that buffer in one window,
  together with buffer selected before this one in another window.
\[Buffer-menu-this-window] -- select that buffer in place of the buffer menu buffer.
\[Buffer-menu-other-window] -- select that buffer in another window,
  so the buffer menu buffer remains visible in its window.
\[Buffer-menu-switch-other-window] -- switch the other window to this buffer.
\[Buffer-menu-visit-tags-table] -- visit-tags-table this buffer.
\[Buffer-menu-not-modified] -- clear modified-flag on that buffer.
\[Buffer-menu-save] -- mark that buffer to be saved, and move down.
\[Buffer-menu-delete] -- mark that buffer to be deleted, and move down.
\[Buffer-menu-delete-backwards] -- mark that buffer to be deleted, and move up.
\[Buffer-menu-execute] -- delete or save marked buffers.
\[Buffer-menu-unmark] -- remove all kinds of marks from current line.
  With prefix argument, also move up one line.
\[Buffer-menu-backup-unmark] -- back up a line and remove marks.
\[Buffer-menu-toggle-read-only] -- toggle read-only status of buffer on this line.
FBuffer-menu-buffer
Return buffer described by this line of buffer menu.
Fbuffer-menu
Make a menu of buffers so you can save, delete or select them.
With argument, show only buffers that are visiting files.
Type ? after invocation to get help on commands available.
Type q immediately to make the buffer menu go away and to restore
previous window configuration.
FBuffer-menu-quit
Quit the buffer menu.
FBuffer-menu-mark
Mark buffer on this line for being displayed by \<Buffer-menu-mode-map>\[Buffer-menu-select] command.
FBuffer-menu-unmark
Cancel all requested operations on buffer on this line and move down.
Optional ARG means move up.
FBuffer-menu-backup-unmark
Move up and cancel all requested operations on buffer on line above.
FBuffer-menu-delete
Mark buffer on this line to be deleted by \<Buffer-menu-mode-map>\[Buffer-menu-execute] command.
FBuffer-menu-delete-backwards
Mark buffer on this line to be deleted by \<Buffer-menu-mode-map>\[Buffer-menu-execute] command
and then move up one line
FBuffer-menu-save
Mark buffer on this line to be saved by \<Buffer-menu-mode-map>\[Buffer-menu-execute] command.
FBuffer-menu-not-modified
Mark buffer on this line as unmodified (no changes to save).
FBuffer-menu-execute
Save and/or delete buffers marked with \<Buffer-menu-mode-map>\[Buffer-menu-save] or \<Buffer-menu-mode-map>\[Buffer-menu-delete] commands.
FBuffer-menu-select
Select this line's buffer; also display buffers marked with `>'.
You can mark buffers with the \<Buffer-menu-mode-map>\[Buffer-menu-mark] command.
FBuffer-menu-visit-tags-table
Visit the tags table in the buffer on this line.  See `visit-tags-table'.
FBuffer-menu-1-window
Select this line's buffer, alone, in full frame.
FBuffer-menu-this-window
Select this line's buffer in this window.
FBuffer-menu-other-window
Select this line's buffer in other window, leaving buffer menu visible.
FBuffer-menu-switch-other-window
Make the other window select this line's buffer.
The current window remains selected.
FBuffer-menu-2-window
Select this line's buffer, with previous buffer in second window.
FBuffer-menu-toggle-read-only
Toggle read-only status of buffer on this line.
Fdefsubst
Define an inline function.  The syntax is just like that of `defun'.
Fmake-obsolete
Make the byte-compiler warn that FUNCTION is obsolete.
The warning will say that NEW should be used instead.
If NEW is a string, that is the `use instead' message.
Fmake-obsolete-variable
Make the byte-compiler warn that VARIABLE is obsolete,
and NEW should be used instead.  If NEW is a string, then that is the
`use instead' message.
Fdont-compile
Like `progn', but the body always runs interpreted (not compiled).
If you think you need this, you're probably making a mistake somewhere.
Feval-when-compile
Like `progn', but evaluates the body at compile time.
The result of the body appears to the compiler as a quoted constant.
Feval-and-compile
Like `progn', but evaluates the body at compile time and at load time.
Vc-mode-abbrev-table
Abbrev table in use in C mode.
Vc-mode-map
Keymap used in C mode.
Fc-macro-expand
Display the result of expanding all C macros occurring in the region.
The expansion is entirely correct because it uses the C preprocessor.
Vc-mode-syntax-table
Syntax table in use in C-mode buffers.
Vc-indent-level
*Indentation of C statements with respect to containing block.
Vc-brace-imaginary-offset
*Imagined indentation of a C open brace that actually follows a statement.
Vc-brace-offset
*Extra indentation for braces, compared with other text in same context.
Vc-argdecl-indent
*Indentation level of declarations of C function arguments.
Vc-label-offset
*Offset of C label lines and case statements relative to usual indentation.
Vc-continued-statement-offset
*Extra indent for lines not starting new statements.
Vc-continued-brace-offset
*Extra indent for substatements that start with open-braces.
This is in addition to c-continued-statement-offset.
Vc-auto-newline
*Non-nil means automatically newline before and after braces,
and after colons and semicolons, inserted in C code.
If you do not want a leading newline before braces then use:
  (define-key c-mode-map "{" 'electric-c-semi)
Vc-tab-always-indent
*Non-nil means TAB in C mode should always reindent the current line,
regardless of where in the line point is when the TAB command is used.
Fc-mode
Major mode for editing C code.
Expression and list commands understand all C brackets.
Tab indents for C code.
Comments are delimited with /* ... */.
Paragraphs are separated by blank lines only.
Delete converts tabs to spaces as it moves back.
\{c-mode-map}
Variables controlling indentation style:
 c-tab-always-indent
    Non-nil means TAB in C mode should always reindent the current line,
    regardless of where in the line point is when the TAB command is used.
 c-auto-newline
    Non-nil means automatically newline before and after braces,
    and after colons and semicolons, inserted in C code.
 c-indent-level
    Indentation of C statements within surrounding block.
    The surrounding block's indentation is the indentation
    of the line on which the open-brace appears.
 c-continued-statement-offset
    Extra indentation given to a substatement, such as the
    then-clause of an if or body of a while.
 c-continued-brace-offset
    Extra indentation given to a brace that starts a substatement.
    This is in addition to c-continued-statement-offset.
 c-brace-offset
    Extra indentation for line if it starts with an open brace.
 c-brace-imaginary-offset
    An open brace following other text is treated as if it were
    this far to the right of the start of its line.
 c-argdecl-indent
    Indentation level of declarations of C function arguments.
 c-label-offset
    Extra indentation for line that is a label, or case or default.

Settings for K&R and BSD indentation styles are
  c-indent-level                5    8
  c-continued-statement-offset  5    8
  c-brace-offset               -5   -8
  c-argdecl-indent              0    8
  c-label-offset               -5   -8

Turning on C mode calls the value of the variable c-mode-hook with no args,
if that value is non-nil.
Fc-fill-paragraph
Like \[fill-paragraph] but handle C comments.
If any of the current line is a comment or within a comment,
fill the comment or the paragraph of it that point is in,
preserving the comment indentation or line-starting decorations.
Felectric-c-brace
Insert character and correct line's indentation.
Felectric-c-sharp-sign
Insert character and correct line's indentation.
Felectric-c-semi
Insert character and correct line's indentation.
Felectric-c-terminator
Insert character and correct line's indentation.
Fc-indent-command
Indent current line as C code, or in some cases insert a tab character.
If `c-tab-always-indent' is non-nil (the default), always indent current line.
Otherwise, indent the current line only if point is at the left margin or
in the line's indentation; otherwise insert a tab.

A numeric argument, regardless of its value, means indent rigidly all the
lines of the expression starting after point so that this line becomes
properly indented.  The relative indentation among the lines of the
expression are preserved.
Fc-indent-line
Indent current line as C code.
Return the amount the indentation changed by.
Fcalculate-c-indent
Return appropriate indentation for current line as C code.
In usual case returns an integer: the column to indent to.
Returns nil if line starts inside a string, t if in a comment.
Fcalculate-c-indent-within-comment
Return the indentation amount for line inside a block comment.
Optional arg AFTER-STAR means, if lines in the comment have a leading star,
return the indentation of the text that would follow this star.
Fc-backward-to-start-of-if
Move to the start of the last "unbalanced" `if'.
Fc-backward-to-start-of-do
If point follows a `do' statement, move to beginning of it and return t.
Otherwise return nil and don't move point.
Fc-beginning-of-statement
Go to the beginning of the innermost C statement.
With prefix arg, go back N - 1 statements.  If already at the beginning of a
statement then go to the beginning of the preceding one.
If within a string or comment, or next to a comment (only whitespace between),
move by sentences instead of statements.
Fc-end-of-statement
Go to the end of the innermost C statement.
With prefix arg, go forward N - 1 statements.
Move forward to end of the next statement if already at end.
If within a string or comment, move by sentences instead of statements.
Fmark-c-function
Put mark at end of C function, point at beginning.
Findent-c-exp
Indent each line of the C grouping following point.
If optional arg ENDPOS is given, indent each line, stopping when
ENDPOS is encountered.
Fset-c-style
Set C-mode variables to use one of several different indentation styles.
The arguments are a string representing the desired style
and a flag which, if non-nil, means to set the style globally.
(Interactively, the flag comes from the prefix argument.)
Available styles are GNU, K&R, BSD and Whitesmith.
Vc-backslash-column
*Minimum column for end-of-line backslashes of macro definitions.
Fc-backslash-region
Insert, align, or delete end-of-line backslashes on the lines in the region.
With no argument, inserts backslashes and aligns existing backslashes.
With an argument, deletes the backslashes.

This function does not modify the last line of the region if the region ends 
right at the start of the following line; it does not modify blank lines
at the start of the region.  So you can put the region around an entire macro
definition and conveniently use this command.
Fc-up-conditional
Move back to the containing preprocessor conditional, leaving mark behind.
A prefix argument acts as a repeat count.  With a negative argument,
move forward to the end of the containing preprocessor conditional.
When going backwards, `#elif' is treated like `#else' followed by `#if'.
When going forwards, `#elif' is ignored.
Fc-backward-conditional
Move back across a preprocessor conditional, leaving mark behind.
A prefix argument acts as a repeat count.  With a negative argument,
move forward across a preprocessor conditional.
Fc-forward-conditional
Move forward across a preprocessor conditional, leaving mark behind.
A prefix argument acts as a repeat count.  With a negative argument,
move backward across a preprocessor conditional.
Vdelete-auto-save-files
*Non-nil means delete a buffer's auto-save file when the buffer is saved.
Vdirectory-abbrev-alist
*Alist of abbreviations for file directories.
A list of elements of the form (FROM . TO), each meaning to replace
FROM with TO when it appears in a directory name.  This replacement is
done when setting up the default directory of a newly visited file.
*Every* FROM string should start with `^'.

Use this feature when you have directories which you normally refer to
via absolute symbolic links.  Make TO the name of the link, and FROM
the name it is linked to.
Vmake-backup-files
*Non-nil means make a backup of a file the first time it is saved.
This can be done by renaming the file or by copying.

Renaming means that Emacs renames the existing file so that it is a
backup file, then writes the buffer into a new file.  Any other names
that the old file had will now refer to the backup file.  The new file
is owned by you and its group is defaulted.

Copying means that Emacs copies the existing file into the backup
file, then writes the buffer on top of the existing file.  Any other
names that the old file had will now refer to the new (edited) file.
The file's owner and group are unchanged.

The choice of renaming or copying is controlled by the variables
`backup-by-copying', `backup-by-copying-when-linked' and
`backup-by-copying-when-mismatch'.
Vbackup-inhibited
Non-nil means don't make a backup file for this buffer.
Vbackup-by-copying
*Non-nil means always use copying to create backup files.
See documentation of variable `make-backup-files'.
Vbackup-by-copying-when-linked
*Non-nil means use copying to create backups for files with multiple names.
This causes the alternate names to refer to the latest version as edited.
This variable is relevant only if `backup-by-copying' is nil.
Vbackup-by-copying-when-mismatch
*Non-nil means create backups by copying if this preserves owner or group.
Renaming may still be used (subject to control of other variables)
when it would not result in changing the owner or group of the file;
that is, for files which are owned by you and whose group matches
the default for a new file created there by you.
This variable is relevant only if `backup-by-copying' is nil.
Vbackup-enable-predicate
Predicate that looks at a file name and decides whether to make backups.
Called with an absolute file name as argument, it returns t to enable backup.
Vbuffer-offer-save
*Non-nil in a buffer means offer to save the buffer on exit
even if the buffer is not visiting a file.
Automatically local in all buffers.
Vfind-file-existing-other-name
*Non-nil means find a file under alternative names, in existing buffers.
This means if any existing buffer is visiting the file you want
under another name, you get the existing buffer instead of a new buffer.
Vfind-file-visit-truename
*Non-nil means visit a file under its truename.
The truename of a file is found by chasing all links
both at the file level and at the levels of the containing directories.
Vbuffer-file-truename
The truename of the file visited in the current buffer.
This variable is automatically local in all buffers, when non-nil.
Vbuffer-file-number
The device number and file number of the file visited in the current buffer.
The value is a list of the form (FILENUM DEVNUM).
This pair of numbers uniquely identifies the file.
If the buffer is visiting a new file, the value is nil.
Vfile-precious-flag
*Non-nil means protect against I/O errors while saving files.
Some modes set this non-nil in particular buffers.
Vversion-control
*Control use of version numbers for backup files.
t means make numeric backup versions unconditionally.
nil means make them for files that have some already.
never means do not make them.
Vdired-kept-versions
*When cleaning directory, number of versions to keep.
Vtrim-versions-without-asking
*If t, deletes excess backup versions silently.
If nil, asks confirmation.  Any other value prevents any trimming.
Vkept-old-versions
*Number of oldest versions to keep when a new numbered backup is made.
Vkept-new-versions
*Number of newest versions to keep when a new numbered backup is made.
Includes the new backup.  Must be > 0
Vrequire-final-newline
*Value of t says silently ensure a file ends in a newline when it is saved.
Non-nil but not t says ask user whether to add a newline when there isn't one.
nil means don't add newlines.
Vauto-save-default
*Non-nil says by default do auto-saving of every file-visiting buffer.
Vauto-save-visited-file-name
*Non-nil says auto-save a buffer in the file it is visiting, when practical.
Normally auto-save files are written under other names.
Vsave-abbrevs
*Non-nil means save word abbrevs too when files are saved.
Loading an abbrev file sets this to t.
Vfind-file-run-dired
*Non-nil says run dired if `find-file' is given the name of a directory.
Vfind-file-not-found-hooks
List of functions to be called for `find-file' on nonexistent file.
These functions are called as soon as the error is detected.
`buffer-file-name' is already set up.
The functions are called in the order given until one of them returns non-nil.
Vfind-file-hooks
List of functions to be called after a buffer is loaded from a file.
The buffer's local variables (if any) will have been processed before the
functions are called.
Vwrite-file-hooks
List of functions to be called before writing out a buffer to a file.
If one of them returns non-nil, the file is considered already written
and the rest are not called.
These hooks are considered to pertain to the visited file.
So this list is cleared if you change the visited file name.
See also `write-contents-hooks'.
Don't make this variable buffer-local; instead, use `local-write-file-hooks'.
Vlocal-write-file-hooks
Just like `write-file-hooks', except intended for per-buffer use.
The functions in this list are called before the ones in
`write-file-hooks'.
Vwrite-contents-hooks
List of functions to be called before writing out a buffer to a file.
If one of them returns non-nil, the file is considered already written
and the rest are not called.
These hooks are considered to pertain to the buffer's contents,
not to the particular visited file; thus, `set-visited-file-name' does
not clear this variable, but changing the major mode does clear it.
See also `write-file-hooks'.
Venable-local-variables
*Control use of local-variables lists in files you visit.
The value can be t, nil or something else.
A value of t means local-variables lists are obeyed;
nil means they are ignored; anything else means query.

The command \[normal-mode] always obeys local-variables lists
and ignores this variable.
Venable-local-eval
*Control processing of the "variable" `eval' in a file's local variables.
The value can be t, nil or something else.
A value of t means obey `eval' variables;
nil means ignore them; anything else means query.

The command \[normal-mode] always obeys local-variables lists
and ignores this variable.
Fpwd
Show the current default directory.
Vcd-path
Value of the CDPATH environment variable, as a list.
Not actually set up until the first time you you use it.
Fparse-colon-path
Explode a colon-separated list of paths into a string list.
Fcd-absolute
Change current directory to given absolute file name DIR.
Fcd
Make DIR become the current buffer's default directory.
If your environment includes a `CDPATH' variable, try each one of that
colon-separated list of directories when resolving a relative directory name.
Fload-file
Load the Lisp file named FILE.
Fload-library
Load the library named LIBRARY.
This is an interface to the function `load'.
Ffile-local-copy
Copy the file FILE into a temporary file on this machine.
Returns the name of the local copy, or nil, if FILE is directly
accessible.
Ffile-truename
Return the truename of FILENAME, which should be absolute.
The truename of a file name is found by chasing symbolic links
both at the level of the file and at the level of the directories
containing it, until no links are left at any level.
Ffile-chase-links
Chase links in FILENAME until a name that is not a link.
Does not examine containing directories for links,
unlike `file-truename'.
Fswitch-to-buffer-other-window
Select buffer BUFFER in another window.
Fswitch-to-buffer-other-frame
Switch to buffer BUFFER in another frame.
Ffind-file
Edit file FILENAME.
Switch to a buffer visiting file FILENAME,
creating one if none already exists.
Ffind-file-other-window
Edit file FILENAME, in another window.
May create a new window, or reuse an existing one.
See the function `display-buffer'.
Ffind-file-other-frame
Edit file FILENAME, in another frame.
May create a new frame, or reuse an existing one.
See the function `display-buffer'.
Ffind-file-read-only
Edit file FILENAME but don't allow changes.
Like \[find-file] but marks buffer as read-only.
Use \[toggle-read-only] to permit editing.
Ffind-file-read-only-other-window
Edit file FILENAME in another window but don't allow changes.
Like \[find-file-other-window] but marks buffer as read-only.
Use \[toggle-read-only] to permit editing.
Ffind-file-read-only-other-frame
Edit file FILENAME in another frame but don't allow changes.
Like \[find-file-other-frame] but marks buffer as read-only.
Use \[toggle-read-only] to permit editing.
Ffind-alternate-file
Find file FILENAME, select its buffer, kill previous buffer.
If the current buffer now contains an empty file that you just visited
(presumably by mistake), use this command to visit the file you really want.
Fcreate-file-buffer
Create a suitably named buffer for visiting FILENAME, and return it.
FILENAME (sans directory) is used unchanged if that name is free;
otherwise a string <2> or <3> or ... is appended to get an unused name.
Fgenerate-new-buffer
Create and return a buffer with a name based on NAME.
Choose the buffer's name using `generate-new-buffer-name'.
Vautomount-dir-prefix
Regexp to match the automounter prefix in a directory name.
Vabbreviated-home-dir
The the user's homedir abbreviated according to `directory-abbrev-list'.
Fabbreviate-file-name
Return a version of FILENAME shortened using `directory-abbrev-alist'.
This also substitutes "~" for the user's home directory.
Type \[describe-variable] directory-abbrev-alist RET for more information.
Vfind-file-not-true-dirname-list
*List of logical names for which visiting shouldn't save the true dirname.
On VMS, when you visit a file using a logical name that searches a path,
you may or may not want the visited file name to record the specific
directory where the file was found.  If you *do not* want that, add the logical
name to this list as a string.
Ffind-file-noselect
Read file FILENAME into a buffer and return the buffer.
If a buffer exists visiting FILENAME, return that one, but
verify that the file has not changed since visited or saved.
The buffer is not selected, just returned to the caller.
Fafter-find-file
Called after finding a file and by the default revert function.
Sets buffer mode, parses local variables.
Optional args ERROR, WARN, and NOAUTO: ERROR non-nil means there was an
error in reading the file.  WARN non-nil means warn if there
exists an auto-save file more recent than the visited file.
NOAUTO means don't mess with auto-save mode.
Finishes by calling the functions in `find-file-hooks'.
Fnormal-mode
Choose the major mode for this buffer automatically.
Also sets up any specified local variables of the file.
Uses the visited file name, the -*- line, and the local variables spec.

This function is called automatically from `find-file'.  In that case,
we may set up specified local variables depending on the value of
`enable-local-variables': if it is t, we do; if it is nil, we don't;
otherwise, we query.  `enable-local-variables' is ignored if you
run `normal-mode' explicitly.
Vauto-mode-alist
Alist of filename patterns vs corresponding major mode functions.
Each element looks like (REGEXP . FUNCTION).
Visiting a file whose name matches REGEXP causes FUNCTION to be called.
Vinhibit-local-variables-regexps
List of regexps; if one matches a file name, don't look for local vars.
Fset-auto-mode
Select major mode appropriate for current buffer.
This checks for a -*- mode tag in the buffer's text, or
compares the filename against the entries in auto-mode-alist.  It does
not check for the "mode:" local variable in the Local Variables
section of the file; for that, use `hack-local-variables'.

If `enable-local-variables' is nil, this function does not check for a
-*- mode tag.
Fhack-local-variables
Parse and put into effect this buffer's local variables spec.
Vignored-local-variables
Variables to be ignored in a file's local variable spec.
Fset-visited-file-name
Change name of file visited in current buffer to FILENAME.
The next time the buffer is saved it will go in the newly specified file.
nil or empty string as argument means make buffer not be visiting any file.
Remember to delete the initial contents of the minibuffer
if you wish to pass an empty string as the argument.
Fwrite-file
Write current buffer into file FILENAME.
Makes buffer visit that file, and marks it not modified.
If the buffer is already visiting a file, you can specify
a directory name as FILENAME, to write a file of the same
old name in that directory.
Fbackup-buffer
Make a backup of the disk file visited by the current buffer, if appropriate.
This is normally done before saving the buffer the first time.
If the value is non-nil, it is the result of `file-modes' on the original
file; this means that the caller, after saving the buffer, should change
the modes of the new file to agree with the old modes.
Ffile-name-sans-versions
Return FILENAME sans backup versions or strings.
This is a separate procedure so your site-init or startup file can
redefine it.
If the optional argument KEEP-BACKUP-VERSION is non-nil,
we do not remove backup version numbers, only true file version numbers.
Fmake-backup-file-name
Create the non-numeric backup file name for FILE.
This is a separate function so you can redefine it for customization.
Fbackup-file-name-p
Return non-nil if FILE is a backup file name (numeric or not).
This is a separate function so you can redefine it for customization.
You may need to redefine `file-name-sans-versions' as well.
Fbackup-extract-version
Given the name of a numeric backup file, return the backup number.
Uses the free variable `bv-length', whose value should be
the index in the name where the version number begins.
Ffind-backup-file-name
Find a file name for a backup file, and suggestions for deletions.
Value is a list whose car is the name for the backup file
 and whose cdr is a list of old versions to consider deleting now.
Ffile-nlinks
Return number of names file FILENAME has.
Ffile-relative-name
Convert FILENAME to be relative to DIRECTORY (default: default-directory).
Fsave-buffer
Save current buffer in visited file if modified.  Versions described below.
By default, makes the previous version into a backup file
 if previously requested or if this is the first save.
With 1 or 3 \[universal-argument]'s, marks this version
 to become a backup when the next save is done.
With 2 or 3 \[universal-argument]'s,
 unconditionally makes the previous version into a backup file.
With argument of 0, never makes the previous version into a backup file.

If a file's name is FOO, the names of its numbered backup versions are
 FOO.~i~ for various integers i.  A non-numbered backup file is called FOO~.
Numeric backups (rather than FOO~) will be made if value of
 `version-control' is not the atom `never' and either there are already
 numeric versions of the file being backed up, or `version-control' is
 non-nil.
We don't want excessive versions piling up, so there are variables
 `kept-old-versions', which tells Emacs how many oldest versions to keep,
 and `kept-new-versions', which tells how many newest versions to keep.
 Defaults are 2 old versions and 2 new.
`dired-kept-versions' controls dired's clean-directory (.) command.
If `trim-versions-without-asking' is nil, system will query user
 before trimming versions.  Otherwise it does it silently.
Fdelete-auto-save-file-if-necessary
Delete auto-save file for current buffer if `delete-auto-save-files' is t.
Normally delete only if the file was written by this Emacs since
the last real save, but optional arg FORCE non-nil means delete anyway.
Fbasic-save-buffer
Save the current buffer in its visited file, if it has been modified.
Fsave-some-buffers
Save some modified file-visiting buffers.  Asks user about each one.
Optional argument (the prefix) non-nil means save all with no questions.
Optional second argument EXITING means ask about certain non-file buffers
 as well as about file buffers.
Fnot-modified
Mark current buffer as unmodified, not needing to be saved.
With prefix arg, mark buffer as modified, so \[save-buffer] will save.
Ftoggle-read-only
Change whether this buffer is visiting its file read-only.
With arg, set read-only iff arg is positive.
Finsert-file
Insert contents of file FILENAME into buffer after point.
Set mark after the inserted text.

This function is meant for the user to run interactively.
Don't call it from programs!  Use `insert-file-contents' instead.
(Its calling sequence is different; see its documentation).
Fappend-to-file
Append the contents of the region to the end of file FILENAME.
When called from a function, expects three arguments,
START, END and FILENAME.  START and END are buffer positions
saying what text to write.
Ffile-newest-backup
Return most recent backup file for FILENAME or nil if no backups exist.
Frename-uniquely
Rename current buffer to a similar name not already taken.
This function is useful for creating multiple shell process buffers
or multiple mail buffers, etc.
Fmake-directory
Create the directory DIR and any nonexistent parent dirs.
Interactively, the default choice of directory to create
is the current default directory for file names.
That is useful when you have visited a file in a nonexistint directory.

Noninteractively, the second (optional) argument PARENTS says whether
to create parent directories if they don't exist.
Vrevert-buffer-function
Function to use to revert this buffer, or nil to do the default.
Vrevert-buffer-insert-file-contents-function
Function to use to insert contents when reverting this buffer.
Gets two args, first the nominal file name to use,
and second, t if reading the auto-save file.
Frevert-buffer
Replace the buffer text with the text of the visited file on disk.
This undoes all changes since the file was visited or saved.
With a prefix argument, offer to revert from latest auto-save file, if
that is more recent than the visited file.

When called from lisp, the first argument is IGNORE-AUTO; only offer
to revert from the auto-save file when this is nil.  Note that the
sense of this argument is the reverse of the prefix argument, for the
sake of backward compatibility.  IGNORE-AUTO is optional, defaulting
to nil.

Optional second argument NOCONFIRM means don't ask for confirmation at
all.

If the value of `revert-buffer-function' is non-nil, it is called to
do the work.
Frecover-file
Visit file FILE, but get contents from its last auto-save file.
Fkill-some-buffers
For each buffer, ask whether to kill it.
Fauto-save-mode
Toggle auto-saving of contents of current buffer.
With prefix argument ARG, turn auto-saving on if positive, else off.
Frename-auto-save-file
Adjust current buffer's auto save file name for current conditions.
Also rename any existing auto save file, if it was made in this session.
Fmake-auto-save-file-name
Return file name to use for auto-saves of current buffer.
Does not consider `auto-save-visited-file-name' as that variable is checked
before calling this function.  You can redefine this for customization.
See also `auto-save-file-name-p'.
Fauto-save-file-name-p
Return non-nil if FILENAME can be yielded by `make-auto-save-file-name'.
FILENAME should lack slashes.  You can redefine this for customization.
Vlist-directory-brief-switches
*Switches for list-directory to pass to `ls' for brief listing,
Vlist-directory-verbose-switches
*Switches for list-directory to pass to `ls' for verbose listing,
Flist-directory
Display a list of files in or matching DIRNAME, a la `ls'.
DIRNAME is globbed by the shell if necessary.
Prefix arg (second arg if noninteractive) means supply -l switch to `ls'.
Actions controlled by variables `list-directory-brief-switches'
and `list-directory-verbose-switches'.
Vinsert-directory-program
Absolute or relative name of the `ls' program used by `insert-directory'.
Finsert-directory
Insert directory listing for FILE, formatted according to SWITCHES.
Leaves point after the inserted text.
Optional third arg WILDCARD means treat FILE as shell wildcard.
Optional fourth arg FULL-DIRECTORY-P means file is a directory and
switches do not contain `d', so that a full listing is expected.

This works by running a directory listing program
whose name is in the variable `insert-directory-program'.
If WILDCARD, it also runs the shell specified by `shell-file-name'.
Fsave-buffers-kill-emacs
Offer to save each buffer, then kill this Emacs process.
With prefix arg, silently save all file-visiting buffers, then kill.
Vfill-individual-varying-indent
*Controls criterion for a new paragraph in `fill-individual-paragraphs'.
Non-nil means changing indent doesn't end a paragraph.
That mode can handle paragraphs with extra indentation on the first line,
but it requires separator lines between paragraphs.
Nil means that any change in indentation starts a new paragraph.
Fset-fill-prefix
Set the fill-prefix to the current line up to point.
Filling expects lines to start with the fill prefix and
reinserts the fill prefix in each resulting line.
Vadaptive-fill-mode
*Non-nil means determine a paragraph's fill prefix from its text.
Vadaptive-fill-regexp
*Regexp to match text at start of line that constitutes indentation.
If Adaptive Fill mode is enabled, whatever text matches this pattern
on the second line of a paragraph is used as the standard indentation
for the paragraph.
Ffill-region-as-paragraph
Fill region as one paragraph: break lines to fit fill-column.
Prefix arg means justify too.
From program, pass args FROM, TO and JUSTIFY-FLAG.
Ffill-paragraph
Fill paragraph at or after point.  Prefix arg means justify as well.
Ffill-region
Fill each of the paragraphs in the region.
Prefix arg (non-nil third arg, if called from program) means justify as well.
Fjustify-current-line
Add spaces to line point is in, so it ends at `fill-column'.
Ffill-nonuniform-paragraphs
Fill paragraphs within the region, allowing varying indentation within each.
This command divides the region into "paragraphs",
only at paragraph-separator lines, then fills each paragraph
using as the fill prefix the smallest indentation of any line
in the paragraph.

When calling from a program, pass range to fill as first two arguments.

Optional third and fourth arguments JUSTIFY-FLAG and MAIL-FLAG:
JUSTIFY-FLAG to justify paragraphs (prefix arg),
MAIL-FLAG for a mail message, i. e. don't fill header lines.
Ffill-individual-paragraphs
Fill paragraphs of uniform indentation within the region.
This command divides the region into "paragraphs", 
treating every change in indentation level as a paragraph boundary,
then fills each paragraph using its indentation level as the fill prefix.

When calling from a program, pass range to fill as first two arguments.

Optional third and fourth arguments JUSTIFY-FLAG and MAIL-FLAG:
JUSTIFY-FLAG to justify paragraphs (prefix arg),
MAIL-FLAG for a mail message, i. e. don't fill header lines.
Vpi
The value of Pi (3.1415926...)
Ve
The value of e (2.7182818...)
Vdegrees-to-radians
Degrees to radian conversion constant
Vradians-to-degrees
Radian to degree conversion constant
Fdegrees-to-radians
Convert ARG from degrees to radians.
Fradians-to-degrees
Convert ARG from radians to degrees.
Vframe-creation-function
Window-system dependent function to call to create a new frame.
The window system startup file should set this to its frame creation
function, which should take an alist of parameters as its argument.
Vinitial-frame-alist
Alist of frame parameters for creating the initial X window frame.
You can set this in your `.emacs' file; for example,
 (setq initial-frame-alist '((top . 1) (left . 1) (width . 80) (height . 55)))
If the value calls for a frame without a minibuffer, and you do not create a
minibuffer frame on your own, one is created according to
`minibuffer-frame-alist'.
Parameters specified here supersede the values given in
`default-frame-alist'.
Vminibuffer-frame-alist
Alist of frame parameters for initially creating a minibuffer frame.
You can set this in your `.emacs' file; for example,
 (setq minibuffer-frame-alist
   '((top . 1) (left . 1) (width . 80) (height . 2)))
Parameters specified here supersede the values given in
`default-frame-alist'.
Vpop-up-frame-alist
Alist of frame parameters used when creating pop-up frames.
Pop-up frames are used for completions, help, and the like.
This variable can be set in your init file, like this:
  (setq pop-up-frame-alist '((width . 80) (height . 20)))
These supersede the values given in `default-frame-alist'.
Fnext-multiframe-window
Select the next window, regardless of which frame it is on.
Fprevious-multiframe-window
Select the previous window, regardless of which frame it is on.
Fmake-frame
Create a new frame, displaying the current buffer.

Optional argument PARAMETERS is an alist of parameters for the new
frame.  Specifically, PARAMETERS is a list of pairs, each having one
of the following forms:

(name . STRING)	- The frame should be named STRING.

(height . NUMBER) - The frame should be NUMBER text lines high.  If
	this parameter is present, the width parameter must also be
	given.

(width . NUMBER) - The frame should be NUMBER characters in width.
	If this parameter is present, the height parameter must also
	be given.

(minibuffer . t) - the frame should have a minibuffer
(minibuffer . nil) - the frame should have no minibuffer
(minibuffer . only) - the frame should contain only a minibuffer
(minibuffer . WINDOW) - the frame should use WINDOW as its minibuffer window.

The documentation for the function `x-create-frame' describes
additional frame parameters that Emacs recognizes for X window frames.
Ffiltered-frame-list
Return a list of all live frames which satisfy PREDICATE.
Fminibuffer-frame-list
Return a list of all frames with their own minibuffers.
Fframe-remove-geometry-params
Return the parameter list PARAM-LIST, but with geometry specs removed.
This deletes all bindings in PARAM-LIST for `top', `left', `width',
and `height' parameters.
Emacs uses this to avoid overriding explicit moves and resizings from
the user during startup.
Fcurrent-frame-configuration
Return a list describing the positions and states of all frames.
Its car is `frame-configuration'.
Each element of the cdr is a list of the form (FRAME ALIST WINDOW-CONFIG),
where
  FRAME is a frame object,
  ALIST is an association list specifying some of FRAME's parameters, and
  WINDOW-CONFIG is a window configuration object for FRAME.
Fset-frame-configuration
Restore the frames to the state described by CONFIGURATION.
Each frame listed in CONFIGURATION has its position, size, window
configuration, and other parameters set as specified in CONFIGURATION.
Fframe-configuration-p
Return non-nil if OBJECT seems to be a frame configuration.
Any list whose car is `frame-configuration' is assumed to be a frame
configuration.
Fframe-height
Return number of lines available for display on FRAME.
If FRAME is omitted, describe the currently selected frame.
Fframe-width
Return number of columns available for display on FRAME.
If FRAME is omitted, describe the currently selected frame.
Fset-default-font
Set the font of the selected frame to FONT.
When called interactively, prompt for the name of the font to use.
Fset-background-color
Set the background color of the selected frame to COLOR.
When called interactively, prompt for the name of the color to use.
Fset-foreground-color
Set the foreground color of the selected frame to COLOR.
When called interactively, prompt for the name of the color to use.
Fset-cursor-color
Set the text cursor color of the selected frame to COLOR.
When called interactively, prompt for the name of the color to use.
Fset-mouse-color
Set the color of the mouse pointer of the selected frame to COLOR.
When called interactively, prompt for the name of the color to use.
Fset-border-color
Set the color of the border of the selected frame to COLOR.
When called interactively, prompt for the name of the color to use.
Fauto-raise-mode
Toggle whether or not the selected frame should auto-raise.
With arg, turn auto-raise mode on if and only if arg is positive.
Fauto-lower-mode
Toggle whether or not the selected frame should auto-lower.
With arg, turn auto-lower mode on if and only if arg is positive.
Ftoggle-scroll-bar
Toggle whether or not the selected frame has vertical scroll bars.
With arg, turn vertical scroll bars on if and only if arg is positive.
Ftoggle-horizontal-scroll-bar
Toggle whether or not the selected frame has horizontal scroll bars.
With arg, turn horizontal scroll bars on if and only if arg is positive.
Horizontal scroll bars aren't implemented yet.
Fset-screen-width
Obsolete function to change the size of the screen to COLS columns.
Optional second arg non-nil means that redisplay should use COLS columns
but that the idea of the actual width of the frame should not be changed.
This function is provided only for compatibility with Emacs 18; new code
should use `set-frame-width instead'.
Fset-screen-height
Obsolete function to change the height of the screen to LINES lines.
Optional second arg non-nil means that redisplay should use LINES lines
but that the idea of the actual height of the screen should not be changed.
This function is provided only for compatibility with Emacs 18; new code
should use `set-frame-width' instead.
Vctl-x-5-map
Keymap for frame commands.
Fmouse-delete-window
Delete the window you click on.
This must be bound to a mouse click.
Fmouse-tear-off-window
Delete the window clicked on, and create a new frame displaying its buffer.
Fmouse-delete-other-windows
Delete all window except the one you click on.
Fmouse-split-window-vertically
Select Emacs window mouse is on, then split it vertically in half.
The window is split at the line clicked on.
This command must be bound to a mouse click.
Fmouse-split-window-horizontally
Select Emacs window mouse is on, then split it horizontally in half.
The window is split at the column clicked on.
This command must be bound to a mouse click.
Fmouse-set-point
Move point to the position clicked on with the mouse.
This must be bound to a mouse click.
Fmouse-set-region
Set the region to the text that the mouse is dragged over.
This must be bound to a mouse drag event.
Vmouse-scroll-delay
*The pause between scroll steps caused by mouse drags, in seconds.
If you drag the mouse beyond the edge of a window, Emacs scrolls the
window to bring the text beyond that edge into view, with a delay of
this many seconds between scroll steps.  Scrolling stops when you move
the mouse back into the window, or release the button.
This variable's value may be non-integral.
Setting this to zero causes Emacs to scroll as fast as it can.
Fmouse-scroll-subr
Scroll the selected window JUMP lines at a time, until new input arrives.
If OVERLAY is an overlay, let it stretch from START to the far edge of
the newly visible text.
Upon exit, point is at the far edge of the newly visible text.
Fmouse-drag-region
Set the region to the text that the mouse is dragged over.
Highlight the drag area as the user moves the mouse.
This must be bound to a button-down mouse event.
Fmouse-set-mark
Set mark at the position clicked on with the mouse.
Display cursor at that position for a second.
This must be bound to a mouse click.
Fmouse-kill
Kill the region between point and the mouse click.
The text is saved in the kill ring, as with \[kill-region].
Fmouse-yank-at-click
Insert the last stretch of killed text at the position clicked on.
Prefix arguments are interpreted as with \[yank].
Fmouse-kill-ring-save
Copy the region between point and the mouse click in the kill ring.
This does not delete the region; it acts like \[kill-ring-save].
Fmouse-save-then-kill
Save text to point in kill ring; the second time, kill the text.
If the text between point and the mouse is the same as what's
at the front of the kill ring, this deletes the text.
Otherwise, it adds the text to the kill ring, like \[kill-ring-save],
which prepares for a second click to delete the text.
Fmouse-start-secondary
Set one end of the secondary selection to the position clicked on.
Use \[mouse-secondary-save-then-kill] to set the other end
and complete the secondary selection.
Fmouse-set-secondary
Set the secondary selection to the text that the mouse is dragged over.
This must be bound to a mouse drag event.
Fmouse-drag-secondary
Set the secondary selection to the text that the mouse is dragged over.
This must be bound to a button-down mouse event.
Fmouse-kill-secondary
Kill the text in the secondary selection.
Fmouse-secondary-save-then-kill
Save text to secondary start point in kill ring; if twice, kill it.
If the text between secondary start point and the mouse is the same as what's
at the front of the kill ring, this deletes the text.
Otherwise, it adds the text to the kill ring, like \[kill-ring-save],
which prepares for a second click to delete the text.
Fmouse-buffer-menu
Pop up a menu of buffers for selection with the mouse.
This switches buffers in the window that you clicked on,
and selects that window.
Vx-fixed-font-alist
X fonts suitable for use in Emacs.
Fmouse-set-font
Select an emacs font from a list of known good fonts
Fx-get-selection
Return the value of an X Windows selection.
The argument TYPE (default `PRIMARY') says which selection, 
and the argument DATA-TYPE (default `STRING') says how to convert the data.
Fx-get-clipboard
Return text pasted to the clipboard.
Fx-set-selection
Make an X Windows selection of type TYPE and value DATA.
The argument TYPE (default `PRIMARY') says which selection, 
and DATA specifies the contents.  DATA may be a string,
a symbol, an integer (or a cons of two integers or list of two integers),
or a cons of two markers pointing to the same buffer.
In the last case, the selection is considered to be the text 
between the markers.
The data may also be a vector of valid non-vector selection values.
Fx-get-cut-buffer
Returns the value of one of the 8 X server cut-buffers.  Optional arg
WHICH-ONE should be a number from 0 to 7, defaulting to 0.
Cut buffers are considered obsolete; you should use selections instead.
Fx-set-cut-buffer
Store STRING into the X server's primary cut buffer.
If PUSH is non-nil, also rotate the cut buffers:
this means the previous value of the primary cut buffer moves the second
cut buffer, and the second to the third, and so on (there are 8 buffers.)
Cut buffers are considered obsolete; you should use selections instead.
Fxselect-convert-to-class
Emacs
Fxselect-convert-to-name
emacs
Fscroll-bar-scale
Given a pair (NUM . DENOM) and WHOLE, return (/ (* NUM WHOLE) DENOM).
This is handy for scaling a position on a scroll bar into real units,
like buffer positions.  If SCROLL-BAR-POS is the (PORTION . WHOLE) pair
from a scroll bar event, then (scroll-bar-scale SCROLL-BAR-POS
(buffer-size)) is the position in the current buffer corresponding to
that scroll bar position.
Fscroll-bar-mode
Toggle display of vertical scroll bars on each frame.
This command applies to all frames that exist and frames to be
created in the future.
With a numeric argument, if the argument is negative,
turn off scroll bars; otherwise, turn on scroll bars.
Fscroll-bar-set-window-start
Set the window start according to where the scroll bar is dragged.
EVENT should be a scroll bar click or drag event.
Fscroll-bar-drag
Scroll the window by dragging the scroll bar slider.
If you click outside the slider, the window scrolls to bring the slider there.
Fscroll-bar-scroll-down
Scroll the window's top line down to the location of the scroll bar click.
EVENT should be a scroll bar click.
Fscroll-bar-scroll-up
Scroll the line next to the scroll bar click to the top of the window.
EVENT should be a scroll bar click.
Vhelp-map
Keymap for characters following the Help key.
Fhelp-with-tutorial
Select the Emacs learn-by-doing tutorial.
Fdescribe-key-briefly
Print the name of the function KEY invokes.  KEY is a string.
Fprint-help-return-message
Display or return message saying how to restore windows after help command.
Computes a message and applies the optional argument FUNCTION to it.
If FUNCTION is nil, applies `message' to it, thus printing it.
Fdescribe-key
Display documentation of the function invoked by KEY.  KEY is a string.
Fdescribe-mode
Display documentation of current major mode.
If optional MINOR is non-nil (or prefix argument is given if interactive),
display documentation of active minor modes as well.
For this to work correctly for a minor mode, the mode's indicator variable
(listed in `minor-mode-alist') must also be a function whose documentation
describes the minor mode.
Fdescribe-distribution
Display info on how to obtain the latest version of GNU Emacs.
Fdescribe-copying
Display info on how you may redistribute copies of GNU Emacs.
Fdescribe-no-warranty
Display info on all the kinds of warranty Emacs does NOT have.
Fdescribe-prefix-bindings
Describe the bindings of the prefix used to reach this command.
The prefix described consists of all but the last event
of the key sequence that ran this command.
Fview-emacs-news
Display info on recent changes to Emacs.
Fview-lossage
Display last 100 input keystrokes.
Fhelp-for-help
You have typed \[help-for-help], the help character.  Type a Help option:

a  command-apropos.   Give a substring, and see a list of commands
              (functions interactively callable) that contain
	      that substring.  See also the  apropos  command.
b  describe-bindings.  Display table of all key bindings.
c  describe-key-briefly.  Type a command key sequence;
	      it prints the function name that sequence runs.
f  describe-function.  Type a function name and get documentation of it.
i  info. The  info  documentation reader.
k  describe-key.  Type a command key sequence;
	      it displays the full documentation.
l  view-lossage.  Shows last 100 characters you typed.
m  describe-mode.  Print documentation of current major mode,
	      which describes the commands peculiar to it.
n  view-emacs-news.  Shows emacs news file.
p  finder-by-keyword. Find packages matching a given topic keyword.
s  describe-syntax.  Display contents of syntax table, plus explanations
t  help-with-tutorial.  Select the Emacs learn-by-doing tutorial.
v  describe-variable.  Type name of a variable;
	      it displays the variable's documentation and value.
w  where-is.  Type command name; it prints which keystrokes
	      invoke that command.
C-c print Emacs copying permission (General Public License).
C-d print Emacs ordering information.
C-n print news of recent Emacs changes.
C-w print information on absence of warranty for GNU Emacs.
Fdescribe-function
Display the full documentation of FUNCTION (a symbol).
Fdescribe-variable
Display the full documentation of VARIABLE (a symbol).
Returns the documentation as a string, also.
Fcommand-apropos
Like apropos but lists only symbols that are names of commands
(interactively callable functions).  Argument REGEXP is a regular expression
that is matched against command symbol names.  Returns list of symbols and
documentation found.
Flocate-library
Show the full path name of Emacs library LIBRARY.
This command searches the directories in `load-path' like `M-x load-library'
to find the file that `M-x load-library RET LIBRARY RET' would load.
Optional second arg NOSUFFIX non-nil means don't add suffixes `.elc' or `.el'
to the specified name LIBRARY (a la calling `load' instead of `load-library').
Vindent-line-function
Function to indent current line.
Findent-according-to-mode
Indent line in proper way for current major mode.
Findent-for-tab-command
Indent line in proper way for current major mode.
Findent-rigidly
Indent all lines starting in the region sideways by ARG columns.
Called from a program, takes three arguments, START, END and ARG.
Vindent-region-function
Function which is short cut to indent region using indent-according-to-mode.
A value of nil means really run indent-according-to-mode on each line.
Findent-region
Indent each nonblank line in the region.
With no argument, indent each line using indent-according-to-mode.
(If there is a fill prefix, make each line start with the fill prefix.)
With argument COLUMN, indent each line to that column.
Called from a program, takes three args: START, END and COLUMN.
Findent-relative-maybe
Indent a new line like previous nonblank line.
Findent-relative
Space out to under next indent point in previous nonblank line.
An indent point is a non-whitespace character following whitespace.
If the previous nonblank line has no indent points beyond the
column point starts at, `tab-to-tab-stop' is done instead.
Vtab-stop-list
*List of tab stop positions used by `tab-to-tab-stops'.
Vedit-tab-stops-map
Keymap used in `edit-tab-stops'.
Vedit-tab-stops-buffer
Buffer whose tab stops are being edited--in case
the variable `tab-stop-list' is local in that buffer.
Fedit-tab-stops
Edit the tab stops used by `tab-to-tab-stop'.
Creates a buffer *Tab Stops* containing text describing the tab stops.
A colon indicates a column where there is a tab stop.
You can add or remove colons and then do \<edit-tab-stops-map>\[edit-tab-stops-note-changes] to make changes take effect.
Fedit-tab-stops-note-changes
Put edited tab stops into effect.
Ftab-to-tab-stop
Insert spaces or tabs to next defined tab-stop column.
The variable `tab-stop-list' is a list of columns at which there are tab stops.
Use \[edit-tab-stops] to edit them interactively.
Fmove-to-tab-stop
Move point to next defined tab-stop column.
The variable `tab-stop-list' is a list of columns at which there are tab stops.
Use \[edit-tab-stops] to edit them interactively.
Vsearch-exit-option
*Non-nil means random control characters terminate incremental search.
Vsearch-slow-window-lines
*Number of lines in slow search display windows.
These are the short windows used during incremental search on slow terminals.
Negative means put the slow search window at the top (normally it's at bottom)
and the value is minus the number of lines.
Vsearch-slow-speed
*Highest terminal speed at which to use "slow" style incremental search.
This is the style where a one-line window is created to show the line
that the search has reached.
Vsearch-upper-case
*If non-nil, upper case chars disable case fold searching.
That is, upper and lower case chars must match exactly.
This applies no matter where the chars come from, but does not
apply to chars in regexps that are prefixed with `\'.
If this value is `not-yanks', yanked text is always downcased.
Vsearch-nonincremental-instead
*If non-nil, do a nonincremental search instead if exiting immediately.
Actually, `isearch-edit-string' is called to let you enter the search
string, and RET terminates editing and does a nonincremental search.
Vsearch-whitespace-regexp
*If non-nil, regular expression to match a sequence of whitespace chars.
You might want to use something like "[ \t\r\n]+" instead.
Vsearch-highlight
*Non-nil means incremental search highlights the current match.
Visearch-mode-hook
Function(s) to call after starting up an incremental search.
Visearch-mode-end-hook
Function(s) to call after terminating an incremental search.
Vsearch-ring
List of search string sequences.
Vregexp-search-ring
List of regular expression search string sequences.
Vsearch-ring-max
*Maximum length of search ring before oldest elements are thrown away.
Vregexp-search-ring-max
*Maximum length of regexp search ring before oldest elements are thrown away.
Vsearch-ring-yank-pointer
Index in `search-ring' of last string reused.
nil if none yet.
Vregexp-search-ring-yank-pointer
Index in `regexp-search-ring' of last string reused.
nil if none yet.
Vsearch-ring-update
*Non-nil if advancing or retreating in the search ring should cause search.
Default value, nil, means edit the string instead.
Visearch-mode-map
Keymap for isearch-mode.
Vminibuffer-local-isearch-map
Keymap for editing isearch strings in the minibuffer.
Fisearch-forward
Do incremental search forward.
With a prefix argument, do an incremental regular expression search instead.
\<isearch-mode-map>
As you type characters, they add to the search string and are found.
The following non-printing keys are bound in `isearch-mode-map'.  

Type \[isearch-delete-char] to cancel characters from end of search string.
Type \[isearch-exit] to exit, leaving point at location found.
Type LFD (C-j) to match end of line.
Type \[isearch-repeat-forward] to search again forward, \[isearch-repeat-backward] to search again backward.
Type \[isearch-yank-word] to yank word from buffer onto end of search string and search for it.
Type \[isearch-yank-line] to yank rest of line onto end of search string and search for it.
Type \[isearch-quote-char] to quote control character to search for it.
\[isearch-abort] while searching or when search has failed cancels input back to what has
 been found successfully.
\[isearch-abort] when search is successful aborts and moves point to starting point.

Also supported is a search ring of the previous 16 search strings.
Type \[isearch-ring-advance] to search for the next item in the search ring.
Type \[isearch-ring-retreat] to search for the previous item in the search ring.
Type \[isearch-complete] to complete the search string using the search ring.

The above keys, bound in `isearch-mode-map', are often controlled by 
 options; do M-x apropos on search-.* to find them.
Other control and meta characters terminate the search
 and are then executed normally (depending on `search-exit-option').

If this function is called non-interactively, it does not return to
the calling function until the search is done.
Fisearch-forward-regexp
Do incremental search forward for regular expression.
With a prefix argument, do a regular string search instead.
Like ordinary incremental search except that your input
is treated as a regexp.  See \[isearch-forward] for more info.
Fisearch-backward
Do incremental search backward.
With a prefix argument, do a regular expression search instead.
See \[isearch-forward] for more information.
Fisearch-backward-regexp
Do incremental search backward for regular expression.
With a prefix argument, do a regular string search instead.
Like ordinary incremental search except that your input
is treated as a regexp.  See \[isearch-forward] for more info.
Fisearch-mode
Start isearch minor mode.  Called by isearch-forward, etc.
Fisearch-exit
Exit search normally.
However, if this is the first command after starting incremental
search and `search-nonincremental-instead' is non-nil, do a
nonincremental search instead via `isearch-edit-string'.
Fisearch-edit-string
Edit the search string in the minibuffer.
The following additional command keys are active while editing.
\<minibuffer-local-isearch-map>
\[exit-minibuffer] to resume incremental searching with the edited string.
\[isearch-nonincremental-exit-minibuffer] to do one nonincremental search.
\[isearch-forward-exit-minibuffer] to resume isearching forward.
\[isearch-backward-exit-minibuffer] to resume isearching backward.
\[isearch-ring-advance-edit] to replace the search string with the next item in the search ring.
\[isearch-ring-retreat-edit] to replace the search string with the previous item in the search ring.
\[isearch-complete-edit] to complete the search string using the search ring.

If first char entered is \[isearch-yank-word], then do word search instead.
Fisearch-abort
Abort incremental search mode if searching is successful, signalling quit.
Otherwise, revert to previous successful search and continue searching.
Use `isearch-exit' to quit without signalling.
Fisearch-repeat-forward
Repeat incremental search forwards.
Fisearch-repeat-backward
Repeat incremental search backwards.
Fisearch-toggle-regexp
Toggle regexp searching on or off.
Fisearch-delete-char
Discard last input item and move point back.  
If no previous match was done, just beep.
Fisearch-yank-word
Pull next word from buffer into search string.
Fisearch-yank-line
Pull rest of line from buffer into search string.
Fisearch-*-char
Handle * and ? specially in regexps.
Fisearch-|-char
If in regexp search, jump to the barrier.
Fisearch-other-meta-char
Exit the search normally and reread this key sequence.
But only if `search-exit-option' is non-nil, the default.
If it is the symbol `edit', the search string is edited in the minibuffer
and the meta character is unread so that it applies to editing the string.
Fisearch-quote-char
Quote special characters for incremental search.
Fisearch-return-char
Convert return into newline for incremental search.
Obsolete.
Fisearch-printing-char
Add this ordinary printing character to the search string and search.
Fisearch-whitespace-chars
Match all whitespace chars, if in regexp mode.
If you want to search for just a space, type C-q SPC.
Fisearch-ring-advance
Advance to the next search string in the ring.
Fisearch-ring-retreat
Retreat to the previous search string in the ring.
Fisearch-ring-advance-edit
Insert the next element of the search history into the minibuffer.
Fisearch-ring-retreat-edit
Inserts the previous element of the search history into the minibuffer.
Fisearch-complete
Complete the search string from the strings on the search ring.
The completed string is then editable in the minibuffer.
If there is no completion possible, say so and continue searching.
Fisearch-complete-edit
Same as `isearch-complete' except in the minibuffer.
Fisearch-no-upper-case-p
Return t if there are no upper case chars in STRING.
If REGEXP-FLAG is non-nil, disregard letters preceeded by `\' (but not `\\')
since they have special meaning in a regexp.
Vlisp-mode-syntax-table

Vemacs-lisp-mode-syntax-table

Vlisp-mode-abbrev-table

Vshared-lisp-mode-map
Keymap for commands shared by all sorts of Lisp modes.
Vemacs-lisp-mode-map
Keymap for Emacs Lisp mode.
All commands in shared-lisp-mode-map are inherited by this map.
Femacs-lisp-mode
Major mode for editing Lisp code to run in Emacs.
Commands:
Delete converts tabs to spaces as it moves back.
Blank lines separate paragraphs.  Semicolons start comments.
\{emacs-lisp-mode-map}
Entry to this mode calls the value of `emacs-lisp-mode-hook'
if that value is non-nil.
Vlisp-mode-map
Keymap for ordinary Lisp mode.
All commands in `shared-lisp-mode-map' are inherited by this map.
Flisp-mode
Major mode for editing Lisp code for Lisps other than GNU Emacs Lisp.
Commands:
Delete converts tabs to spaces as it moves back.
Blank lines separate paragraphs.  Semicolons start comments.
\{lisp-mode-map}
Note that `run-lisp' may be used either to start an inferior Lisp job
or to switch back to an existing one.

Entry to this mode calls the value of `lisp-mode-hook'
if that value is non-nil.
Flisp-send-defun
Send the current defun to the Lisp process made by \[run-lisp].
Vlisp-interaction-mode-map
Keymap for Lisp Interaction moe.
All commands in `shared-lisp-mode-map' are inherited by this map.
Flisp-interaction-mode
Major mode for typing and evaluating Lisp forms.
Like Lisp mode except that \[eval-print-last-sexp] evals the Lisp expression
before point, and prints its value into the buffer, advancing point.

Commands:
Delete converts tabs to spaces as it moves back.
Paragraphs are separated only by blank lines.
Semicolons start comments.
\{lisp-interaction-mode-map}
Entry to this mode calls the value of `lisp-interaction-mode-hook'
if that value is non-nil.
Feval-print-last-sexp
Evaluate sexp before point; print value into current buffer.
Feval-last-sexp
Evaluate sexp before point; print value in minibuffer.
With argument, print output into current buffer.
Feval-defun
Evaluate defun that point is in or before.
Print value in minibuffer.
With argument, insert value in current buffer after the defun.
Vlisp-indent-offset

Vlisp-indent-function

Flisp-indent-line
Indent current line as Lisp code.
With argument, indent any additional lines of the same expression
rigidly along with this one.
Fcalculate-lisp-indent
Return appropriate indentation for current line as Lisp code.
In usual case returns an integer: the column to indent to.
Can instead return a list, whose car is the column to indent to.
This means that following lines at the same level of indentation
should not necessarily be indented the same way.
The second element of the list is the buffer position
of the start of the containing expression.
Vlisp-body-indent
Number of columns to indent the second line of a `(def...)' form.
Findent-sexp
Indent each line of the list starting just after point.
If optional arg ENDPOS is given, indent each line, stopping when
ENDPOS is encountered.
Flisp-fill-paragraph
Like \[fill-paragraph], but handle Emacs Lisp comments.
If any of the current line is a comment, fill the comment or the
paragraph of it that point is in, preserving the comment's indentation
and initial semicolons.
Findent-code-rigidly
Indent all lines of code, starting in the region, sideways by ARG columns.
Does not affect lines starting inside comments or strings, assuming that
the start of the region is not inside them.

Called from a program, takes args START, END, COLUMNS and NOCHANGE-REGEXP.
The last is a regexp which, if matched at the beginning of a line,
means don't indent that line.
Vdefun-prompt-regexp
Non-nil => regexp to ignore, before the `(' that starts a defun.
Vparens-require-spaces
Non-nil => `insert-parentheses' should insert whitespace as needed.
Fforward-sexp
Move forward across one balanced expression (sexp).
With argument, do it that many times.  Negative arg -N means
move backward across N balanced expressions.
Fbackward-sexp
Move backward across one balanced expression (sexp).
With argument, do it that many times.  Negative arg -N means
move forward across N balanced expressions.
Fmark-sexp
Set mark ARG sexps from point.
The place mark goes is the same place \[forward-sexp] would
move to with the same argument.
Fforward-list
Move forward across one balanced group of parentheses.
With argument, do it that many times.
Negative arg -N means move backward across N groups of parentheses.
Fbackward-list
Move backward across one balanced group of parentheses.
With argument, do it that many times.
Negative arg -N means move forward across N groups of parentheses.
Fdown-list
Move forward down one level of parentheses.
With argument, do this that many times.
A negative argument means move backward but still go down a level.
In Lisp programs, an argument is required.
Fbackward-up-list
Move backward out of one level of parentheses.
With argument, do this that many times.
A negative argument means move forward but still to a less deep spot.
In Lisp programs, an argument is required.
Fup-list
Move forward out of one level of parentheses.
With argument, do this that many times.
A negative argument means move backward but still to a less deep spot.
In Lisp programs, an argument is required.
Fkill-sexp
Kill the sexp (balanced expression) following the cursor.
With argument, kill that many sexps after the cursor.
Negative arg -N means kill N sexps before the cursor.
Fbackward-kill-sexp
Kill the sexp (balanced expression) preceding the cursor.
With argument, kill that many sexps before the cursor.
Negative arg -N means kill N sexps after the cursor.
Fbeginning-of-defun
Move backward to the beginning of a defun.
With argument, do it that many times.  Negative arg -N
means move forward to Nth following beginning of defun.
Returns t unless search stops due to beginning or end of buffer.

Normally a defun starts when there is an char with open-parenthesis
syntax at the beginning of a line.  If `defun-prompt-regexp' is
non-nil, then a string which matches that regexp may precede the
open-parenthesis.
Fend-of-defun
Move forward to next end of defun.  With argument, do it that many times.
Negative argument -N means move back to Nth preceding end of defun.

An end of a defun occurs right after the close-parenthesis that matches
the open-parenthesis that starts a defun; see `beginning-of-defun'.
Fmark-defun
Put mark at end of this defun, point at beginning.
The defun marked is the one that contains point or follows point.
Finsert-parentheses
Put parentheses around next ARG sexps.  Leave point after open-paren.
No argument is equivalent to zero: just insert `()' and leave point between.
This command also sometimes inserts a space before and after,
depending on the surrounding characters.
Fmove-past-close-and-reindent
Move past next `)', delete indentation before it, then indent after it.
Flisp-complete-symbol
Perform completion on Lisp symbol preceding point.  That symbol is
compared against the symbols that exist and any additional characters
determined by what is there are inserted.
   If the symbol starts just after an open-parenthesis, only symbols
with function definitions are considered.  Otherwise, all symbols with
function definitions, values or properties are considered.
Vminor-mode-alist
Alist saying how to show minor modes in the mode line.
Each element looks like (VARIABLE STRING);
STRING is included in the mode line iff VARIABLE's value is non-nil.

Actually, STRING need not be a string; any possible mode-line element
is okay.  See `mode-line-format'.
Vchange-log-default-name
*Name of a change log file for \[add-change-log-entry].
Ffind-change-log
Find a change log file for \[add-change-log-entry] and return the name.
Optional arg FILE-NAME is a name to try first.
If FILE-NAME is nil, use the value of `change-log-default-name' if non-nil.
Failing that, use "ChangeLog" in the current directory.
If the file does not exist in the named directory, successive parent
directories are tried.

Once a file is found, `change-log-default-name' is set locally in the
current buffer to the complete file name.
Fadd-change-log-entry
Find change log file and add an entry for today.
Optional arg (interactive prefix) non-nil means prompt for user name and site.
Second arg is file name of change log.  If nil, uses `change-log-default-name'.
Third arg OTHER-WINDOW non-nil means visit in other window.
Fadd-change-log-entry-other-window
Find change log file in other window and add an entry for today.
First arg (interactive prefix) non-nil means prompt for user name and site.
Second arg is file name of change log.
Interactively, with a prefix argument, the file name is prompted for.
Fchange-log-mode
Major mode for editing change logs; like Indented Text Mode.
Prevents numeric backups and sets `left-margin' to 8 and `fill-column' to 74.
New log entries are usually made with \[add-change-log-entry] or \[add-change-log-entry-other-window].
Each entry behaves as a paragraph, and the entries for one day as a page.
Runs `change-log-mode-hook'.
Vad-start-advice-on-load
*Non-NIL will start advice magic when this file gets loaded.
Also see function `ad-start-advice'.
Vad-activate-on-definition
*Non-NIL means automatic advice activation at function definition.
Set this variable to t if you want to enable forward advice (which is
automatic advice activation of a previously undefined function at the
point the function gets defined/loaded/autoloaded). The value of this
variable takes effect only during the execution of `ad-start-advice'. 
If non-NIL it will enable definition hooks regardless of the value
of `ad-enable-definition-hooks'.
Vad-redefinition-action
*Defines what to do with redefinitions during de/activation.
Redefinition occurs if a previously activated function that already has an
original definition associated with it gets redefined and then de/activated.
In such a case we can either accept the current definition as the new
original definition, discard the current definition and replace it with the
old original, or keep it and raise an error. The values `accept', `discard',
`error' or `warn' govern what will be done. `warn' is just like `accept' but
it additionally prints a warning message. All other values will be
interpreted as `error'.
Vad-definition-hooks
*List of hooks to be run after a function definition.
The variable `ad-defined-function' will be bound to the name of
the currently defined function when the hook function is run.
Vad-enable-definition-hooks
*Non-NIL will enable hooks to be run on function definition.
Setting this variable is a noop unless the value of
`ad-activate-on-definition' (which see) is NIL.
Vad-use-jwz-byte-compiler
*Non-NIL means Jamie Zawinski's v19 byte-compiler will be used.
If you use a v18 Emacs and don't use jwz's optimizing byte-compiler (the
normal case) then this variable should be NIL, because otherwise
enabling definition hooks (e.g., for forward advice) will redefine the 
`byte-code' subr which will lead to some performance degradation for
byte-compiled code.
Fad-add-advice
Adds a piece of ADVICE to FUNCTION's list of advices in CLASS.
If FUNCTION already has one or more pieces of advice of the specified
CLASS then POSITION determines where the new piece will go. The value
of POSITION can either be `first', `last' or a number where 0 corresponds
to `first'. Numbers outside the range will be mapped to the closest
extreme position. If there was already a piece of ADVICE with the same
name, then the position argument will be ignored and the old advice
will be overwritten with the new one.
    If the FUNCTION was not advised already, then its advice info will be 
initialized. Redefining a piece of advice whose name is part of the cache-id
will clear the cache.
Fdefadvice
Defines a piece of advice for FUNCTION (a symbol).

  (defadvice <function> (<class> <name> [<position>] [<arglist>] {<flags>}*)
    [ [<documentation-string>] [<interactive-form>] ]
    {<body-form>}* )

<function> ::= name of the function to be advised
<class> ::= before | around | after | activation | deactivation
<name> ::= non-NIL symbol that names this piece of advice
<position> ::= first | last | <number> (optional, defaults to `first',
    see also `ad-add-advice')
<arglist> ::= an optional argument list to be used for the advised function
    instead of the argument list of the original. The first one found in
    before/around/after advices will be used.
<flags> ::= protect | disable | activate | compile | preactivate
    All flags can be specified with unambiguous initial substrings.
<documentation-string> ::= optional documentation for this piece of advice
<interactive-form> ::= optional interactive form to be used for the advised
    function. The first one found in before/around/after advices will be used.
<body-form> ::= any s-expression

Semantics of the various flags:
`protect': The piece of advice will be protected against non-local exits in
any code that precedes it. If any around advice of a function is protected
then automatically all around advices will be protected (the complete onion).

`activate': All advice of FUNCTION will be activated immediately if
FUNCTION has been properly defined prior to the defadvice.

`compile': In conjunction with `activate' specifies that the resulting
advised function should be compiled.

`disable': The defined advice will be disabled, hence it will not be used 
during activation until somebody enables it.

`preactivate': Preactivates the advised FUNCTION at macro expansion/compile
time. This generates a compiled advised definition according to the current
advice state that will be used during activation if appropriate. Only use
this if the defadvice gets actually compiled (with a v18 byte-compiler put
the defadvice into the body of a defun).

Look at the file advice.el for comprehensive documentation.
Fad-start-advice
Redefines some primitives to start the advice magic.
If `ad-activate-on-definition' is t then advice information will
automatically get activated whenever an advised function gets defined or
redefined.  This will enable goodies such as forward advice and
automatically enable function definition hooks. If its value is nil but
the value of `ad-enable-definition-hooks' is t then definition hooks
will be enabled without having automatic advice activation, otherwise
function definition hooks will be disabled too. If definition hooks are
enabled then functions stored in `ad-definition-hooks' are run whenever
a function gets defined or redefined.
Vappt-issue-message
*Non-nil means check for appointments in the diary buffer.
To be detected, the diary entry must have the time
as the first thing on a line.
Vappt-message-warning-time
*Time in minutes before an appointment that the warning begins.
Vappt-audible
*Non-nil means beep to indicate appointment.
Vappt-visible
*Non-nil means display appointment message in echo area.
Vappt-display-mode-line
*Non-nil means display minutes to appointment and time on the mode line.
Vappt-msg-window
*Non-nil means display appointment message in another window.
Vappt-display-duration
*The number of seconds an appointment message is displayed.
Vappt-display-diary
*Non-nil means to display the next days diary on the screen. 
This will occur at midnight when the appointment list is updated.
Fapropos
Show all symbols whose names contain matches for REGEXP.
If optional argument DO-ALL is non-nil, does more (time-consuming) work such as
showing key bindings.  Optional argument PRED is called with each symbol, and
if it returns nil, the symbol is not shown.

Returns list of symbols and documentation found.
Fsuper-apropos
Show symbols whose names/documentation contain matches for REGEXP.
If optional argument DO-ALL is non-nil, does more (time-consuming) work such as
showing key bindings and documentation that is not stored in the documentation
file.

Returns list of symbols and documentation found.
Fasm-mode
Major mode for editing typical assembler code.
Features a private abbrev table and the following bindings:

\[asm-colon]	outdent a preceding label, tab to next tab stop.
\[tab-to-tab-stop]	tab to next tab stop.
\[asm-newline]	newline, then tab to next tab stop.
\[asm-comment]	smart placement of assembler comments.

The character used for making comments is set by the variable
`asm-comment-char' (which defaults to `?;').

Alternatively, you may set this variable in `asm-set-comment-hook', which is
called near the beginning of mode initialization.

Turning on Asm mode runs the hook `asm-mode-hook' at the end of initialization.

Special commands:\{asm-mode-map}

Fupdate-file-autoloads
Update the autoloads for FILE in `generated-autoload-file'
(which FILE might bind in its local variables).
Fupdate-autoloads-here
Update sections of the current buffer generated by \[update-file-autoloads].
Fupdate-directory-autoloads
Run \[update-file-autoloads] on each .el file in DIR.
Fbatch-update-autoloads
Update the autoloads for the files or directories on the command line.
Runs \[update-file-autoloads] on files and \[update-directory-autoloads]
on directories.  Must be used only with -batch, and kills Emacs on completion.
Each file will be processed even if an error occurred previously.
For example, invoke "emacs -batch -f batch-update-autoloads *.el"
Fawk-mode
Major mode for editing AWK code.
This is much like C mode except for the syntax of comments.  It uses
the same keymap as C mode and has the same variables for customizing
indentation.  It has its own abbrev table and its own syntax table.

Turning on AWK mode calls the value of the variable `awk-mode-hook'
with no args, if that value is non-nil.
Fq
(` FORM)  is a macro that expands to code to construct FORM.
Note that this is very slow in interpreted code, but fast if you compile.
FORM is one or more nested lists, which are `almost quoted':
They are copied recursively, with non-lists used unchanged in the copy.
 (` a b) == (list 'a 'b)  constructs a new list with two elements, `a' and `b'.
 (` a (b c)) == (list 'a (list 'b 'c))  constructs two nested new lists.

However, certain special lists are not copied.  They specify substitution.
Lists that look like (, EXP) are evaluated and the result is substituted.
 (` a (, (+ x 5))) == (list 'a (+ x 5))

Elements of the form (,@ EXP) are evaluated and then all the elements
of the result are substituted.  This result must be a list; it may
be `nil'.

As an example, a simple macro `push' could be written:
   (defmacro push (v l)
        (` (setq (, l) (cons (,@ (list v l))))))
or as
   (defmacro push (v l)
        (` (setq (, l) (cons (, v) (, l)))))

LIMITATIONS: "dotted lists" are not allowed in FORM.
The ultimate cdr of each list scanned by ` must be `nil'.
(This does not apply to constants inside expressions to be substituted.)

Substitution elements are not allowed as the cdr
of a cons cell.  For example, (` (A . (, B))) does not work.
Instead, write (` (A (,@ B))).

You cannot construct vectors, only lists.  Vectors are treated as
constants.

BEWARE BEWARE BEWARE
Inclusion of (,ATOM) rather than (, ATOM)
or of (,@ATOM) rather than (,@ ATOM)
will result in errors that will show up very late.
Fbibtex-mode
Major mode for editing bibtex files.

\{bibtex-mode-map}

A command such as \[bibtex-Book] will outline the fields for a BibTeX book entry.

The optional fields start with the string OPT, and thus ignored by BibTeX.
The OPT string may be removed from a field with \[bibtex-remove-OPT].
\[bibtex-kill-optional-field] kills the current optional field entirely.
\[bibtex-remove-double-quotes] removes the double-quotes around the text of
the current field.  \[bibtex-empty-field] replaces the text of the current
field with the default "".

The command \[bibtex-clean-entry] cleans the current entry, i.e. (i) removes
double-quotes from entirely numerical fields, (ii) removes OPT from all
non-empty optional fields, (iii) removes all empty optional fields, and (iv)
checks that no non-optional fields are empty.

Use \[bibtex-find-text] to position the dot at the end of the current field.
Use \[bibtex-next-field] to move to end of the next field.

The following may be of interest as well:

  Functions:
    find-bibtex-duplicates
    find-bibtex-entry-location
    hide-bibtex-entry-bodies
    sort-bibtex-entries
    validate-bibtex-buffer

  Variables:
    bibtex-clean-entry-zap-empty-opts
    bibtex-entry-field-alist
    bibtex-include-OPTannote
    bibtex-include-OPTcrossref
    bibtex-include-OPTkey
    bibtex-maintain-sorted-entries
    bibtex-mode-user-optional-fields

Fields:
    address
           Publisher's address
    annote
           Long annotation used for annotated bibliographies (begins sentence)
    author
           Name(s) of author(s), in BibTeX name format
    booktitle
           Book title when the thing being referenced isn't the whole book.
           For book entries, the title field should be used instead.
    chapter
           Chapter number
    crossref
	   The database key of the entry being cross referenced.
    edition
           Edition of a book (e.g., "second")
    editor
           Name(s) of editor(s), in BibTeX name format.
           If there is also an author field, then the editor field should be
           for the book or collection that the work appears in
    howpublished
            How something strange has been published (begins sentence)
    institution
           Sponsoring institution
    journal
           Journal name (macros are provided for many)
    key
           Alphabetizing and labeling key (needed when no author or editor)
    month
           Month (macros are provided)
    note
           To help the reader find a reference (begins sentence)
    number
           Number of a journal or technical report
    organization
           Organization (sponsoring a conference)
    pages
           Page number or numbers (use `--' to separate a range)
    publisher
           Publisher name
    school
           School name (for theses)
    series
           The name of a series or set of books.
           An individual book will will also have it's own title
    title
           The title of the thing being referenced
    type
           Type of a technical report (e.g., "Research Note") to be used
           instead of the default "Technical Report"
    volume
           Volume of a journal or multivolume work
    year
           Year---should contain only numerals
---------------------------------------------------------
Entry to this mode calls the value of bibtex-mode-hook if that value is
non-nil.
Fblackbox
Play blackbox.  Optional prefix argument is the number of balls;
the default is 4.

What is blackbox?

Blackbox is a game of hide and seek played on an 8 by 8 grid (the
Blackbox).  Your opponent (Emacs, in this case) has hidden several
balls (usually 4) within this box.  By shooting rays into the box and
observing where they emerge it is possible to deduce the positions of
the hidden balls.  The fewer rays you use to find the balls, the lower
your score.

Overview of play:

\<blackbox-mode-map>To play blackbox, type \[blackbox].  An optional prefix argument
specifies the number of balls to be hidden in the box; the default is
four.

The cursor can be moved around the box with the standard cursor
movement keys.

To shoot a ray, move the cursor to the edge of the box and press SPC.
The result will be determined and the playfield updated.

You may place or remove balls in the box by moving the cursor into the
box and pressing \[bb-romp].

When you think the configuration of balls you have placed is correct,
press \[bb-done].  You will be informed whether you are correct or
not, and be given your score.  Your score is the number of letters and
numbers around the outside of the box plus five for each incorrectly
placed ball.  If you placed any balls incorrectly, they will be
indicated with `x', and their actual positions indicated with `o'.

Details:

There are three possible outcomes for each ray you send into the box:

	Detour: the ray is deflected and emerges somewhere other than
		where you sent it in.  On the playfield, detours are
		denoted by matching pairs of numbers -- one where the
		ray went in, and the other where it came out.

	Reflection: the ray is reflected and emerges in the same place
		it was sent in.  On the playfield, reflections are
		denoted by the letter `R'.

	Hit:	the ray strikes a ball directly and is absorbed.  It does
		not emerge from the box.  On the playfield, hits are
		denoted by the letter `H'.

The rules for how balls deflect rays are simple and are best shown by
example.

As a ray approaches a ball it is deflected ninety degrees.  Rays can
be deflected multiple times.  In the diagrams below, the dashes
represent empty box locations and the letter `O' represents a ball.
The entrance and exit points of each ray are marked with numbers as
described under "Detour" above.  Note that the entrance and exit
points are always interchangeable.  `*' denotes the path taken by the
ray.

Note carefully the relative positions of the ball and the ninety
degree deflection it causes.

    1                                            
  - * - - - - - -         - - - - - - - -         - - - - - - - -       
  - * - - - - - -         - - - - - - - -         - - - - - - - -       
1 * * - - - - - -         - - - - - - - -         - O - - - - O -       
  - - O - - - - -         - - O - - - - -         - - * * * * - -
  - - - - - - - -         - - - * * * * * 2     3 * * * - - * - -
  - - - - - - - -         - - - * - - - -         - - - O - * - -      
  - - - - - - - -         - - - * - - - -         - - - - * * - -       
  - - - - - - - -         - - - * - - - -         - - - - * - O -       
                                2                         3

As mentioned above, a reflection occurs when a ray emerges from the same point
it was sent in.  This can happen in several ways:

                                                                           
  - - - - - - - -         - - - - - - - -          - - - - - - - -
  - - - - O - - -         - - O - O - - -          - - - - - - - -
R * * * * - - - -         - - - * - - - -          O - - - - - - -
  - - - - O - - -         - - - * - - - -        R - - - - - - - -
  - - - - - - - -         - - - * - - - -          - - - - - - - -
  - - - - - - - -         - - - * - - - -          - - - - - - - -
  - - - - - - - -       R * * * * - - - -          - - - - - - - -
  - - - - - - - -         - - - - O - - -          - - - - - - - -

In the first example, the ray is deflected downwards by the upper
ball, then left by the lower ball, and finally retraces its path to
its point of origin.  The second example is similar.  The third
example is a bit anomalous but can be rationalized by realizing the
ray never gets a chance to get into the box.  Alternatively, the ray
can be thought of as being deflected downwards and immediately
emerging from the box.

A hit occurs when a ray runs straight into a ball:

  - - - - - - - -         - - - - - - - -          - - - - - - - -
  - - - - - - - -         - - - - - - - -          - - - - O - - -
  - - - - - - - -         - - - - O - - -        H * * * * - - - -
  - - - - - - - -       H * * * * O - - -          - - - * - - - -
  - - - - - - - -         - - - - O - - -          - - - O - - - -
H * * * O - - - -         - - - - - - - -          - - - - - - - -
  - - - - - - - -         - - - - - - - -          - - - - - - - -
  - - - - - - - -         - - - - - - - -          - - - - - - - -

Be sure to compare the second example of a hit with the first example of
a reflection.
Fbyte-recompile-directory
Recompile every `.el' file in DIRECTORY that needs recompilation.
This is if a `.elc' file exists but is older than the `.el' file.

If the `.elc' file does not exist, normally the `.el' file is *not* compiled.
But a prefix argument (optional second arg) means ask user,
for each such `.el' file, whether to compile it.  Prefix argument 0 means
don't ask and compile the file anyway.
Fbyte-compile-file
Compile a file of Lisp code named FILENAME into a file of byte code.
The output file's name is made by appending `c' to the end of FILENAME.
With prefix arg (noninteractively: 2nd arg), load the file after compiling.
Fcompile-defun
Compile and evaluate the current top-level form.
Print the result in the minibuffer.
With argument, insert value in current buffer after the form.
Fbyte-compile
If FORM is a symbol, byte-compile its function definition.
If FORM is a lambda or a macro, byte-compile it as a function.
Fdisplay-call-tree
Display a call graph of a specified file.
This lists which functions have been called, what functions called
them, and what functions they call.  The list includes all functions
whose definitions have been compiled in this Emacs session, as well as
all functions called by those functions.

The call graph does not include macros, inline functions, or
primitives that the byte-code interpreter knows about directly (eq,
cons, etc.).

The call tree also lists those functions which are not known to be called
(that is, to which no calls have been compiled), and which cannot be
invoked interactively.
Fbatch-byte-compile
Run `byte-compile-file' on the files remaining on the command line.
Use this from the command line, with `-batch';
it won't work in an interactive Emacs.
Each file is processed even if an error occurred previously.
For example, invoke "emacs -batch -f batch-byte-compile $emacs/ ~/*.el"
Vview-diary-entries-initially
*If t, the diary entries for the current date will be displayed on entry.
The diary is displayed in another window when the calendar is first displayed,
if the current date is visible.  The number of days of diary entries displayed
is governed by the variable `number-of-diary-entries'.
Vnumber-of-diary-entries
*Specifies how many days of diary entries are to be displayed initially.
This variable affects the diary display when the command M-x diary is used,
or if the value of the variable `view-diary-entries-initially' is t.  For
example, if the default value 1 is used, then only the current day's diary
entries will be displayed.  If the value 2 is used, then both the current
day's and the next day's entries will be displayed.  The value can also be
a vector such as [0 2 2 2 2 4 1]; this value will cause no diary entries to
be displayed on Sunday, the current date's and the next day's diary entries
to be displayed Monday through Thursday, Friday through Monday's entries to
be displayed on Friday, and only Saturday's entries to be displayed on
Saturday.  This variable does not affect the diary display with the `d'
command from the calendar; in that case, the prefix argument controls the
number of days of diary entries displayed.
Vmark-diary-entries-in-calendar
*If t, dates with diary entries will be marked in the calendar window.
The marking symbol is specified by the variable `diary-entry-marker'.
Vdiary-entry-marker
*The symbol used to mark dates that have diary entries.
Vview-calendar-holidays-initially
*If t, holidays for current three month period will be displayed on entry.
The holidays are displayed in another window when the calendar is first
displayed.
Vmark-holidays-in-calendar
*If t, dates of holidays will be marked in the calendar window.
The marking symbol is specified by the variable `calendar-holiday-marker'.
Vcalendar-holiday-marker
*The symbol used to mark notable dates in the calendar.
Vall-hebrew-calendar-holidays
*If nil, show only major holidays from the Hebrew calendar.

If nil, the only holidays from the Hebrew calendar shown will be those days of
such major interest as to appear on secular calendars.

If t, the holidays shown in the calendar will include all special days that
would be shown on a complete Hebrew calendar.
Vall-christian-calendar-holidays
*If nil, show only major holidays from the Christian calendar.

If nil, the only holidays from the Christian calendar shown will be those days
of such major interest as to appear on secular calendars.

If t, the holidays shown in the calendar will include all special days that
would be shown on a complete Christian calendar.
Vall-islamic-calendar-holidays
*If nil, show only major holidays from the Islamic calendar.

If nil, the only holidays from the Islamic calendar shown will be those days
of such major interest as to appear on secular calendars.

If t, the holidays shown in the calendar will include all special days that
would be shown on a complete Islamic calendar.
Vcalendar-load-hook
*List of functions to be called after the calendar is first loaded.
This is the place to add key bindings to calendar-mode-map.
Vinitial-calendar-window-hook
*List of functions to be called when the calendar window is first opened.
The functions invoked are called after the calendar window is opened, but
once opened is never called again.  Leaving the calendar with the `q' command
and reentering it will cause these functions to be called again.
Vtoday-visible-calendar-hook
*List of functions called whenever the current date is visible.
This can be used, for example, to replace today's date with asterisks; a
function `calendar-star-date' is included for this purpose:
    (setq today-visible-calendar-hook 'calendar-star-date)
It could also be used to mark the current date with `='; a function is also
provided for this:
    (setq today-visible-calendar-hook 'calendar-mark-today)

The corresponding variable `today-invisible-calendar-hook' is the list of
functions called when the calendar function was called when the current
date is not visible in the window.

Other than the use of the provided functions, the changing of any
characters in the calendar buffer by the hooks may cause the failure of the
functions that move by days and weeks.
Vtoday-invisible-calendar-hook
*List of functions called whenever the current date is not visible.

The corresponding variable `today-visible-calendar-hook' is the list of
functions called when the calendar function was called when the current
date is visible in the window.

Other than the use of the provided functions, the changing of any
characters in the calendar buffer by the hooks may cause the failure of the
functions that move by days and weeks.
Vdiary-file
*Name of the file in which one's personal diary of dates is kept.

The file's entries are lines in any of the forms

            MONTH/DAY
            MONTH/DAY/YEAR
            MONTHNAME DAY
            MONTHNAME DAY, YEAR
            DAYNAME

at the beginning of the line; the remainder of the line is the diary entry
string for that date.  MONTH and DAY are one or two digit numbers, YEAR is
a number and may be written in full or abbreviated to the final two digits.
If the date does not contain a year, it is generic and applies to any year.
DAYNAME entries apply to any date on which is on that day of the week.
MONTHNAME and DAYNAME can be spelled in full, abbreviated to three
characters (with or without a period), capitalized or not.  Any of DAY,
MONTH, or MONTHNAME, YEAR can be `*' which matches any day, month, or year,
respectively.

The European style (in which the day precedes the month) can be used
instead, if you execute `european-calendar' when in the calendar, or set
`european-calendar-style' to t in your .emacs file.  The European forms are

            DAY/MONTH
            DAY/MONTH/YEAR
            DAY MONTHNAME
            DAY MONTHNAME YEAR
            DAYNAME

To revert to the default American style from the European style, execute
`american-calendar' in the calendar.

A diary entry can be preceded by a diary-nonmarking-symbol (ordinarily `&')
to make that entry nonmarking--that is, it will not be marked on dates in
the calendar window but will appear in a diary window.

Multiline diary entries are made by indenting lines after the first with
either a TAB or one or more spaces.

Lines not in one the above formats are ignored.  Here are some sample diary
entries (in the default American style):

     12/22/1988 Twentieth wedding anniversary!!
     &1/1. Happy New Year!
     10/22 Ruth's birthday.
     21: Payday
     Tuesday--weekly meeting with grad students at 10am
              Supowit, Shen, Bitner, and Kapoor to attend.
     1/13/89 Friday the thirteenth!!
     &thu 4pm squash game with Lloyd.
     mar 16 Dad's birthday
     April 15, 1989 Income tax due.
     &* 15 time cards due.

If the first line of a diary entry consists only of the date or day name with
no trailing blanks or punctuation, then that line will not be displayed in the
diary window; only the continuation lines will be shown.  For example, the
single diary entry

     02/11/1989
      Bill Blattner visits Princeton today
      2pm Cognitive Studies Committee meeting
      2:30-5:30 Lizzie at Lawrenceville for `Group Initiative'
      4:00pm Jamie Tappenden
      7:30pm Dinner at George and Ed's for Alan Ryan
      7:30-10:00pm dance at Stewart Country Day School

will appear in the diary window without the date line at the beginning.  This
facility allows the diary window to look neater, but can cause confusion if
used with more than one day's entries displayed.

Diary entries can be based on Lisp sexps.  For example, the diary entry

      %%(diary-block 11 1 1990 11 10 1990) Vacation

causes the diary entry "Vacation" to appear from November 1 through November
10, 1990.  Other functions available are `diary-float', `diary-anniversary',
`diary-cyclic', `diary-day-of-year', `diary-iso-date', `diary-french-date',
`diary-hebrew-date', `diary-islamic-date', `diary-mayan-date',
`diary-yahrzeit', `diary-sunrise-sunset', `diary-phases-of-moon',
`diary-parasha', `diary-omer', `diary-rosh-hodesh', and
`diary-sabbath-candles'.  See the documentation for the function
`list-sexp-diary-entries' for more details.

Diary entries based on the Hebrew and/or the Islamic calendar are also
possible, but because these are somewhat slow, they are ignored
unless you set the `nongregorian-diary-listing-hook' and the
`nongregorian-diary-marking-hook' appropriately.  See the documentation
for these functions for details.

Diary files can contain directives to include the contents of other files; for
details, see the documentation for the variable `list-diary-entries-hook'.
Vdiary-nonmarking-symbol
*Symbol indicating that a diary entry is not to be marked in the calendar.
Vhebrew-diary-entry-symbol
*Symbol indicating a diary entry according to the Hebrew calendar.
Vislamic-diary-entry-symbol
*Symbol indicating a diary entry according to the Islamic calendar.
Vdiary-include-string
*The string indicating inclusion of another file of diary entries.
See the documentation for the function `include-other-diary-files'.
Vsexp-diary-entry-symbol
*The string used to indicate a sexp diary entry in diary-file.
See the documentation for the function `list-sexp-diary-entries'.
Vabbreviated-calendar-year
*Interpret a two-digit year DD in a diary entry as either 19DD or 20DD.
For the Gregorian calendar; similarly for the Hebrew and Islamic calendars.
If this variable is nil, years must be written in full.
Veuropean-calendar-style
*Use the European style of dates in the diary and in any displays.
If this variable is t, a date 1/2/1990 would be interpreted as February 1,
1990.  The accepted European date styles are

            DAY/MONTH
            DAY/MONTH/YEAR
            DAY MONTHNAME
            DAY MONTHNAME YEAR
            DAYNAME

Names can be capitalized or not, written in full, or abbreviated to three
characters with or without a period.
Vamerican-date-diary-pattern
*List of pseudo-patterns describing the American patterns of date used.
See the documentation of diary-date-forms for an explanation.
Veuropean-date-diary-pattern
*List of pseudo-patterns describing the European patterns of date used.
See the documentation of diary-date-forms for an explanation.
Vdiary-date-forms
*List of pseudo-patterns describing the forms of date used in the diary.
The patterns on the list must be MUTUALLY EXCLUSIVE and must should not match
any portion of the diary entry itself, just the date component.

A pseudo-pattern is a list of regular expressions and the keywords `month',
`day', `year', `monthname', and `dayname'.  The keyword `monthname' will
match the name of the month, capitalized or not, or its three-letter
abbreviation, followed by a period or not; it will also match `*'.
Similarly, `dayname' will match the name of the day, capitalized or not, or
its three-letter abbreviation, followed by a period or not.  The keywords
`month', `day', and `year' will match those numerical values, preceded by
arbitrarily many zeros; they will also match `*'.

The matching of the diary entries with the date forms is done with the
standard syntax table from Fundamental mode, but with the `*' changed so
that it is a word constituent.

If, to be mutually exclusive, a pseudo-pattern must match a portion of the
diary entry itself, the first element of the pattern MUST be `backup'.  This
directive causes the date recognizer to back up to the beginning of the
current word of the diary entry, so in no case can the pattern match more than
a portion of the first word of the diary entry.
Veuropean-calendar-display-form
*Pseudo-pattern governing the way a date appears in the European style.
See the documentation of calendar-date-display-forms for an explanation.
Vamerican-calendar-display-form
*Pseudo-pattern governing the way a date appears in the American style.
See the documentation of calendar-date-display-forms for an explanation.
Vcalendar-date-display-form
*Pseudo-pattern governing the way a date appears.

Used by the function `calendar-date-string', a pseudo-pattern is a list of
expressions that can involve the keywords `month', `day', and `year', all
numbers in string form, and `monthname' and `dayname', both alphabetic
strings.  For example, the ISO standard would use the pseudo- pattern

       '(year "-" month "-" day)

while a typical American form would be

       '(month "/" day "/" (substring year -2))

and

       '((format "%9s, %9s %2s, %4s" dayname monthname day year))

would give the usual American style in fixed-length fields.

See the documentation of the function `calendar-date-string'.
Vprint-diary-entries-hook
*List of functions called after a temporary diary buffer is prepared.
The buffer shows only the diary entries currently visible in the diary
buffer.  The default just does the printing.  Other uses might include, for
example, rearranging the lines into order by day and time, saving the buffer
instead of deleting it, or changing the function used to do the printing.
Vlist-diary-entries-hook
*List of functions called after diary file is culled for relevant entries.
It is to be used for diary entries that are not found in the diary file.

A function `include-other-diary-files' is provided for use as the value of
this hook.  This function enables you to use shared diary files together
with your own.  The files included are specified in the diary-file by lines
of the form

        #include "filename"

This is recursive; that is, #include directives in files thus included are
obeyed.  You can change the "#include" to some other string by changing
the variable `diary-include-string'.  When you use `include-other-diary-files'
as part of the list-diary-entries-hook, you will probably also want to use the
function `mark-included-diary-files' as part of the mark-diary-entries-hook.

For example, you could use

     (setq list-diary-entries-hook
       '(include-other-diary-files sort-diary-entries))
     (setq diary-display-hook 'fancy-diary-display)

in your .emacs file to cause the fancy diary buffer to be displayed with
diary entries from various included files, each day's entries sorted into
lexicographic order.
Vdiary-display-hook
*List of functions that handle the display of the diary.

Ordinarily, this just displays the diary buffer (with holidays indicated in
the mode line), if there are any relevant entries.  At the time these
functions are called, the variable `diary-entries-list' is a list, in order
by date, of all relevant diary entries in the form of ((MONTH DAY YEAR)
STRING), where string is the diary entry for the given date.  This can be
used, for example, to handle appointment notification, prepare a different
buffer for display (perhaps combined with holidays), or produce hard copy
output.

A function `fancy-diary-display' is provided as an alternative
choice for this hook; this function prepares a special noneditable diary
buffer with the relevant diary entries that has neat day-by-day arrangement
with headings.  The fancy diary buffer will show the holidays unless the
variable `holidays-in-diary-buffer' is set to nil.  Ordinarily, the fancy
diary buffer will not show days for which there are no diary entries, even
if that day is a holiday; if you want such days to be shown in the fancy
diary buffer, set the variable `diary-list-include-blanks' to t.
Vnongregorian-diary-listing-hook
*List of functions called for listing diary file and included files.
As the files are processed for diary entries, these functions are used to cull
relevant entries.  You can use either or both of `list-hebrew-diary-entries'
and `list-islamic-diary-entries'.  The documentation for these functions
describes the style of such diary entries.
Vmark-diary-entries-hook
*List of functions called after marking diary entries in the calendar.

A function `mark-included-diary-files' is also provided for use as the
mark-diary-entries-hook; it enables you to use shared diary files together
with your own.  The files included are specified in the diary-file by lines
of the form
        #include "filename"
This is recursive; that is, #include directives in files thus included are
obeyed.  You can change the "#include" to some other string by changing the
variable `diary-include-string'.  When you use `mark-included-diary-files' as
part of the mark-diary-entries-hook, you will probably also want to use the
function `include-other-diary-files' as part of the list-diary-entries-hook.
Vnongregorian-diary-marking-hook
*List of functions called for marking diary file and included files.
As the files are processed for diary entries, these functions are used to cull
relevant entries.  You can use either or both of `mark-hebrew-diary-entries'
and `mark-islamic-diary-entries'.  The documentation for these functions
describes the style of such diary entries.
Vdiary-list-include-blanks
*If nil, do not include days with no diary entry in the list of diary entries.
Such days will then not be shown in the the fancy diary buffer, even if they
are holidays.
Vholidays-in-diary-buffer
*If t, the holidays will be indicated in the diary display.
The holidays will be given in the mode line of the diary buffer, or in the
fancy diary buffer next to the date.  This slows down the diary functions
somewhat; setting it to nil will make the diary display faster.
Vgeneral-holidays
*General holidays.  Default value is for the United States.
See the documentation for `calendar-holidays' for details.
Vlocal-holidays
*Local holidays.
See the documentation for `calendar-holidays' for details.
Vother-holidays
*User defined holidays.
See the documentation for `calendar-holidays' for details.
Vhebrew-holidays
*Jewish holidays.
See the documentation for `calendar-holidays' for details.
Vchristian-holidays
*Christian holidays.
See the documentation for `calendar-holidays' for details.
Vislamic-holidays
*Islamic holidays.
See the documentation for `calendar-holidays' for details.
Vsolar-holidays
*Sun-related holidays.
See the documentation for `calendar-holidays' for details.
Fcalendar
Display a three-month calendar in another window.
The three months appear side by side, with the current month in the middle
surrounded by the previous and next months.  The cursor is put on today's date.

If called with an optional prefix argument, prompts for month and year.

This function is suitable for execution in a .emacs file; appropriate setting
of the variable `view-diary-entries-initially' will cause the diary entries for
the current date to be displayed in another window.  The value of the variable
`number-of-diary-entries' controls the number of days of diary entries
displayed upon initial display of the calendar.

An optional prefix argument ARG causes the calendar displayed to be ARG
months in the future if ARG is positive or in the past if ARG is negative;
in this case the cursor goes on the first day of the month.

Once in the calendar window, future or past months can be moved into view.
Arbitrary months can be displayed, or the calendar can be scrolled forward
or backward.

The cursor can be moved forward or backward by one day, one week, one month,
or one year.  All of these commands take prefix arguments which, when negative,
cause movement in the opposite direction.  For convenience, the digit keys
and the minus sign are automatically prefixes.  The window is replotted as
necessary to display the desired date.

Diary entries can be marked on the calendar or displayed in another window.

Use M-x describe-mode for details of the key bindings in the calendar window.

The Gregorian calendar is assumed.

After loading the calendar, the hooks given by the variable
`calendar-load-hook' are run.  This the place to add key bindings to the
calendar-mode-map.

After preparing the calendar window initially, the hooks given by the variable
`initial-calendar-window-hook' are run.

The hooks given by the variable `today-visible-calendar-hook' are run
everytime the calendar window gets scrolled, if the current date is visible
in the window.  If it is not visible, the hooks given by the variable
`today-invisible-calendar-hook' are run.  Thus, for example, setting
`today-visible-calendar-hook' to 'calendar-star-date will cause today's date
to be replaced by asterisks to highlight it whenever it is in the window.
Flist-yahrzeit-dates
List Yahrzeit dates for *Gregorian* DEATH-DATE from START-YEAR to END-YEAR.
When called interactively from the calendar window, the date of death is taken
from the cursor position.
Fdescribe-buffer-case-table
Describe the case table of the current buffer.
Fset-case-syntax-delims
Make characters L and R a matching pair of non-case-converting delimiters.
This sets the entries for L and R in TABLE, which is a string
that will be used as the downcase part of a case table.
It also modifies `standard-syntax-table', and `text-mode-syntax-table' to
indicate left and right delimiters.
Fset-case-syntax-pair
Make characters UC and LC a pair of inter-case-converting letters.
This sets the entries for characters UC and LC in TABLE, which is a string
that will be used as the downcase part of a case table.
It also modifies `standard-syntax-table' and `text-mode-syntax-table'
to indicate an (uppercase, lowercase) pair of letters.
Fset-case-syntax
Make characters C case-invariant with syntax SYNTAX.
This sets the entries for character C in TABLE, which is a string
that will be used as the downcase part of a case table.
It also modifies `standard-syntax-table' and `text-mode-syntax-table'.
SYNTAX should be " ", "w", "." or "_".
Frepeat-matching-complex-command
Edit and re-evaluate complex command with name matching PATTERN.
Matching occurrences are displayed, most recent first, until you select
a form for evaluation.  If PATTERN is empty (or nil), every form in the
command history is offered.  The form is placed in the minibuffer for
editing and the result is evaluated.
Flist-command-history
List history of commands typed to minibuffer.
The number of commands listed is controlled by `list-command-history-max'.
Calls value of `list-command-history-filter' (if non-nil) on each history
element to judge if that element should be excluded from the list.

The buffer is left in Command History mode.
Fcommand-history-mode
Major mode for examining commands from `command-history'.
The number of commands listed is controlled by `list-command-history-max'.
The command history is filtered by `list-command-history-filter' if non-nil.
Use \<command-history-map>\[command-history-repeat] to repeat the command on the current line.

Otherwise much like Emacs-Lisp Mode except that there is no self-insertion
and digits provide prefix arguments.  Tab does not indent.
\{command-history-map}
Calls the value of `command-history-hook' if that is non-nil.
The Command History listing is recomputed each time this mode is invoked.
Fmake-comint
Make a comint process NAME in a buffer, running PROGRAM.
The name of the buffer is made by surrounding NAME with `*'s.
If there is already a running process in that buffer, it is not restarted.
Optional third arg STARTFILE is the name of a file to send the contents of to 
the process.  Any more args are arguments to PROGRAM.
Fcompare-windows
Compare text in current window with text in next window.
Compares the text starting at point in each window,
moving over text in each one as far as they match.

A prefix arg means ignore changes in whitespace.
The variable `compare-windows-whitespace' controls how whitespace is skipped.
If `compare-ignore-case' is non-nil, changes in case are also ignored.
Vcompilation-mode-hook
*List of hook functions run by `compilation-mode' (see `run-hooks').
Vcompilation-window-height
*Number of lines in a compilation window.  If nil, use Emacs default.
Vcompilation-buffer-name-function
Function to compute the name of a compilation buffer.
The function receives one argument, the name of the major mode of the
compilation buffer.  It should return a string.
nil means compute the name with `(concat "*" (downcase major-mode) "*")'.
Vcompilation-finish-function
*Function to call when a compilation process finishes.
It is called with two arguments: the compilation buffer, and a string
describing how the process finished.
Vcompilation-search-path
*List of directories to search for source files named in error messages.
Elements should be directory names, not file names of directories.
nil as an element means to try the default directory.
Fcompile
Compile the program including the current buffer.  Default: run `make'.
Runs COMMAND, a shell command, in a separate process asynchronously
with output going to the buffer `*compilation*'.

You can then use the command \[next-error] to find the next error message
and move to the source code that caused it.

To run more than one compilation at once, start one and rename the
`*compilation*' buffer to some other name with \[rename-buffer].
Then start the next one.

The name used for the buffer is actually whatever is returned by
the function in `compilation-buffer-name-function', so you can set that
to a function that generates a unique name.
Fgrep
Run grep, with user-specified args, and collect output in a buffer.
While grep runs asynchronously, you can use the \[next-error] command
to find the text that grep hits refer to.

This command uses a special history list for its arguments, so you can
easily repeat a grep command.
Fnext-error
Visit next compilation error message and corresponding source code.
This operates on the output from the \[compile] command.
If all preparsed error messages have been processed,
the error message buffer is checked for new ones.

A prefix arg specifies how many error messages to move;
negative means move back to previous error messages.
Just C-u as a prefix means reparse the error message buffer
and start at the first error.

\[next-error] normally applies to the most recent compilation started,
but as long as you are in the middle of parsing errors from one compilation
output buffer, you stay with that compilation output buffer.

Use \[next-error] in a compilation output buffer to switch to
processing errors from that compilation.

See variables `compilation-parse-errors-function' and
`compilation-error-regexp-alist' for customization ideas.
Fc++-mode
Major mode for editing C++ code.  Very much like editing C code.
Expression and list commands understand all C++ brackets.
Tab at left margin indents for C++ code
Comments are delimited with /* ... */ {or with // ... <newline>}
Paragraphs are separated by blank lines only.
Delete converts tabs to spaces as it moves back.
\{c++-mode-map}
Variables controlling indentation style:
 c-tab-always-indent
    Non-nil means TAB in C mode should always reindent the current line,
    regardless of where in the line point is when the TAB command is used.
    Default is t.
 c-auto-newline
    Non-nil means automatically newline before and after braces,
    and after colons and semicolons, inserted in C code.
 c-indent-level
    Indentation of C statements within surrounding block.
    The surrounding block's indentation is the indentation
    of the line on which the open-brace appears.
 c-continued-statement-offset
    Extra indentation given to a substatement, such as the
    then-clause of an if or body of a while.
 c-continued-brace-offset
    Extra indentation given to a brace that starts a substatement.
    This is in addition to c-continued-statement-offset.
 c-brace-offset
    Extra indentation for line if it starts with an open brace.
 c-brace-imaginary-offset
    An open brace following other text is treated as if it were
    this far to the right of the start of its line.
 c-argdecl-indent
    Indentation level of declarations of C function arguments.
 c-label-offset
    Extra indentation for line that is a label, or case or ``default:'', or
    ``public:'' or ``private:'', or ``protected:''.
 c++-electric-colon
    If non-nil at invocation of c++-mode (t is the default) colon electricly
    indents.
 c++-empty-arglist-indent
    If non-nil, a function declaration or invocation which ends a line with a
    left paren is indented this many extra spaces, instead of flush with the
    left paren.
 c++-friend-offset
    Offset of C++ friend class declarations relative to member declarations.
 c++-member-init-indent
    Indentation level of member initializations in function declarations,
    if they are on a separate line beginning with a colon.
 c++-continued-member-init-offset
    Extra indentation for continuation lines of member initializations; NIL
    means to align with previous initializations rather than with the colon.

Settings for K&R, BSD, and Stroustrup indentation styles are
  c-indent-level                5    8    4
  c-continued-statement-offset  5    8    4
  c-continued-brace-offset                0
  c-brace-offset               -5   -8    0
  c-brace-imaginary-offset                0
  c-argdecl-indent              0    8    4
  c-label-offset               -5   -8   -4
  c++-empty-arglist-indent                4
  c++-friend-offset                       0

Turning on C++ mode calls the value of the variable `c++-mode-hook' with
no args if that value is non-nil.
Fdabbrev-expand
Expand previous word "dynamically".
Expands to the most recent, preceding word for which this is a prefix.
If no suitable preceding word is found, words following point are considered.

If `case-fold-search' and `case-replace' are non-nil (usually true)
then the substituted word may be case-adjusted to match the abbreviation
that you had typed.  This takes place if the substituted word, as found,
is all lower case, or if it is at the beginning of a sentence and only
its first letter was upper case.

A positive prefix arg N says to take the Nth backward DISTINCT
possibility.  A negative argument says search forward.  The variable
`dabbrev-backward-only' may be used to limit the direction of search to
backward if set non-nil.

If the cursor has not moved from the end of the previous expansion and
no argument is given, replace the previously-made expansion
with the next possible expansion not yet tried.
Fdebug
Enter debugger.  Returns if user says "continue".
Arguments are mainly for use when this is called from the internals
of the evaluator.

You may call with no args, or you may pass nil as the first arg and
any other args you like.  In that case, the list of args after the
first will be printed into the backtrace buffer.
Fdebug-on-entry
Request FUNCTION to invoke debugger each time it is called.
If the user continues, FUNCTION's execution proceeds.
Works by modifying the definition of FUNCTION,
which must be written in Lisp, not predefined.
Use \[cancel-debug-on-entry] to cancel the effect of this command.
Redefining FUNCTION also does that.
Fcancel-debug-on-entry
Undo effect of \[debug-on-entry] on FUNCTION.
If argument is nil or an empty string, cancel for all functions.
Fdelete-selection-mode
Toggle Delete Selection mode.
When ON, typed text replaces the selection if the selection is active.
When OFF, typed text is just inserted at point.
Fdiary
Generate the diary window for ARG days starting with the current date.
If no argument is provided, the number of days of diary entries is governed
by the variable `number-of-diary-entries'.  This function is suitable for
execution in a .emacs file.
Fdiff
Find and display the differences between OLD and NEW files.
Interactively the current buffer's file name is the default for for NEW
and a backup file for NEW is the default for OLD.
With prefix arg, prompt for diff switches.
Fdiff-backup
Diff this file with its backup file or vice versa.
Uses the latest backup, if there are several numerical backups.
If this file is a backup, diff it with its original.
The backup file is the first file given to `diff'.
Fdired-diff
Compare file at point with file FILE using `diff'.
FILE defaults to the file at the mark.
The prompted-for file is the first file given to `diff'.
Fdired-backup-diff
Diff this file with its backup file or vice versa.
Uses the latest backup, if there are several numerical backups.
If this file is a backup, diff it with its original.
The backup file is the first file given to `diff'.
Fdired-do-chmod
Change the mode of the marked (or next ARG) files.
This calls chmod, thus symbolic modes like `g+w' are allowed.
Fdired-do-chgrp
Change the group of the marked (or next ARG) files.
Fdired-do-chown
Change the owner of the marked (or next ARG) files.
Fdired-do-print
Print the marked (or next ARG) files.
Uses the shell command coming from variables `lpr-command' and
`lpr-switches' as default.
Fdired-do-shell-command
Run a shell command COMMAND on the marked files.
If no files are marked or a specific numeric prefix arg is given,
the next ARG files are used.  Just \[universal-argument] means the current file.
The prompt mentions the file(s) or the marker, as appropriate.

If there is output, it goes to a separate buffer.

Normally the command is run on each file individually.
However, if there is a `*' in the command then it is run
just once with the entire file list substituted there.

No automatic redisplay of dired buffers is attempted, as there's no
telling what files the command may have changed.  Type
\[dired-do-redisplay] to redisplay the marked files.

The shell command has the top level directory as working directory, so
output files usually are created there instead of in a subdir.
Fdired-do-kill-lines
Kill all marked lines (not the files).
With a prefix argument, kill that many lines starting with the current line.
(A negative argument kills lines before the current line.)
To kill an entire subdirectory, go to its directory header line
and use this command with a prefix argument (the value does not matter).
Fdired-do-compress
Compress or uncompress marked (or next ARG) files.
Fdired-do-byte-compile
Byte compile marked (or next ARG) Emacs Lisp files.
Fdired-do-load
Load the marked (or next ARG) Emacs Lisp files.
Fdired-do-redisplay
Redisplay all marked (or next ARG) files.
If on a subdir line, redisplay that subdirectory.  In that case,
a prefix arg lets you edit the `ls' switches used for the new listing.
Fdired-string-replace-match
Replace first match of REGEXP in STRING with NEWTEXT.
If it does not match, nil is returned instead of the new string.
Optional arg LITERAL means to take NEWTEXT literally.
Optional arg GLOBAL means to replace all matches.
Fdired-create-directory
Create a directory called DIRECTORY.
Fdired-do-copy
Copy all marked (or next ARG) files, or copy the current file.
This normally preserves the last-modified date when copying.
When operating on just the current file, you specify the new name.
When operating on multiple or marked files, you specify a directory
and new symbolic links are made in that directory
with the same names that the files currently have.
Fdired-do-symlink
Make symbolic links to current file or all marked (or next ARG) files.
When operating on just the current file, you specify the new name.
When operating on multiple or marked files, you specify a directory
and new symbolic links are made in that directory
with the same names that the files currently have.
Fdired-do-hardlink
Add names (hard links) current file or all marked (or next ARG) files.
When operating on just the current file, you specify the new name.
When operating on multiple or marked files, you specify a directory
and new hard links are made in that directory
with the same names that the files currently have.
Fdired-do-rename
Rename current file or all marked (or next ARG) files.
When renaming just the current file, you specify the new name.
When renaming multiple or marked files, you specify a directory.
Fdired-do-rename-regexp
Rename marked files containing REGEXP to NEWNAME.
As each match is found, the user must type a character saying
  what to do with it.  For directions, type \[help-command] at that time.
NEWNAME may contain \=\<n> or \& as in `query-replace-regexp'.
REGEXP defaults to the last regexp used.
With a zero prefix arg, renaming by regexp affects the complete
  pathname - usually only the non-directory part of file names is used
  and changed.
Fdired-do-copy-regexp
Copy all marked files containing REGEXP to NEWNAME.
See function `dired-rename-regexp' for more info.
Fdired-do-hardlink-regexp
Hardlink all marked files containing REGEXP to NEWNAME.
See function `dired-rename-regexp' for more info.
Fdired-do-symlink-regexp
Symlink all marked files containing REGEXP to NEWNAME.
See function `dired-rename-regexp' for more info.
Fdired-upcase
Rename all marked (or next ARG) files to upper case.
Fdired-downcase
Rename all marked (or next ARG) files to lower case.
Fdired-maybe-insert-subdir
Insert this subdirectory into the same dired buffer.
If it is already present, just move to it (type \[dired-do-redisplay] to refresh),
  else inserts it at its natural place (as `ls -lR' would have done).
With a prefix arg, you may edit the ls switches used for this listing.
  You can add `R' to the switches to expand the whole tree starting at
  this subdirectory.
This function takes some pains to conform to `ls -lR' output.
Fdired-prev-subdir
Go to previous subdirectory, regardless of level.
When called interactively and not on a subdir line, go to this subdir's line.
Fdired-goto-subdir
Go to end of header line of DIR in this dired buffer.
Return value of point on success, otherwise return nil.
The next char is either \n, or \r if DIR is hidden.
Fdired-mark-subdir-files
Mark all files except `.' and `..'.
Fdired-kill-subdir
Remove all lines of current subdirectory.
Lower levels are unaffected.
Fdired-tree-up
Go up ARG levels in the dired tree.
Fdired-tree-down
Go down in the dired tree.
Fdired-hide-subdir
Hide or unhide the current subdirectory and move to next directory.
Optional prefix arg is a repeat factor.
Use \[dired-hide-all] to (un)hide all directories.
Fdired-hide-all
Hide all subdirectories, leaving only their header lines.
If there is already something hidden, make everything visible again.
Use \[dired-hide-subdir] to (un)hide a particular subdirectory.
Vdired-listing-switches
*Switches passed to `ls' for dired.  MUST contain the `l' option.
May contain all other options that don't contradict `-l';
may contain even `F', `b', `i' and `s'.
Vdired-chown-program
Name of chown command (usually `chown' or `/etc/chown').
Vdired-ls-F-marks-symlinks
*Informs dired about how `ls -lF' marks symbolic links.
Set this to t if `insert-directory-program' with `-lF' marks the symbolic link
itself with a trailing @ (usually the case under Ultrix).

Example: if `ln -s foo bar; ls -F bar' gives `bar -> foo', set it to
nil (the default), if it gives `bar@ -> foo', set it to t.

Dired checks if there is really a @ appended.  Thus, if you have a
marking `ls' program on one host and a non-marking on another host, and
don't care about symbolic links which really end in a @, you can
always set this variable to t.
Vdired-trivial-filenames
*Regexp of files to skip when finding first file of a directory.
A value of nil means move to the subdir line.
A value of t means move to first file.
Vdired-keep-marker-rename
*Controls marking of renamed files.
If t, files keep their previous marks when they are renamed.
If a character, renamed files (whether previously marked or not)
are afterward marked with that character.
Vdired-keep-marker-copy
*Controls marking of copied files.
If t, copied files are marked if and as the corresponding original files were.
If a character, copied files are unconditionally marked with that character.
Vdired-keep-marker-hardlink
*Controls marking of newly made hard links.
If t, they are marked if and as the files linked to were marked.
If a character, new links are unconditionally marked with that character.
Vdired-keep-marker-symlink
*Controls marking of newly made symbolic links.
If t, they are marked if and as the files linked to were marked.
If a character, new links are unconditionally marked with that character.
Vdired-dwim-target
*If non-nil, dired tries to guess a default target directory.
This means: if there is a dired buffer displayed in the next window,
use its current subdir, instead of the current subdir of this dired buffer.

The target is used in the prompt for file copy, rename etc.
Vdired-copy-preserve-time
*If non-nil, Dired preserves the last-modified time in a file copy.
(This works on only some systems.)
Fdired
"Edit" directory DIRNAME--delete, rename, print, etc. some files in it.
Optional second argument SWITCHES specifies the `ls' options used.
(Interactively, use a prefix argument to be able to specify SWITCHES.)
Dired displays a list of files in DIRNAME (which may also have
shell wildcards appended to select certain files).  If DIRNAME is a cons,
its first element is taken as the directory name and the resr as an explicit
list of files to make directory entries for.
\<dired-mode-map>You can move around in it with the usual commands.
You can flag files for deletion with \[dired-flag-file-deletion] and then
delete them by typing \[dired-do-flagged-delete].
Type \[describe-mode] after entering dired for more info.

If DIRNAME is already in a dired buffer, that buffer is used without refresh.
Fdired-other-window
"Edit" directory DIRNAME.  Like `dired' but selects in another window.
Fdired-other-frame
"Edit" directory DIRNAME.  Like `dired' but makes a new frame.
Fdired-noselect
Like `dired' but returns the dired buffer as value, does not select it.
Fdisassemble
Print disassembled code for OBJECT in (optional) BUFFER.
OBJECT can be a symbol defined as a function, or a function itself
(a lambda expression or a compiled-function object).
If OBJECT is not already compiled, we compile it, but do not
redefine OBJECT if it is a symbol.
Fdescribe-current-display-table
Describe the display table in use in the selected window and buffer.
Fmake-display-table
Return a new, empty display table.
Fstandard-display-8bit
Display characters in the range L to H literally.
Fstandard-display-default
Display characters in the range L to H using the default notation.
Fstandard-display-ascii
Display character C using string S.
Fstandard-display-g1
Display character C as character SC in the g1 character set.
Fstandard-display-graphic
Display character C as character GC in graphics character set.
Fstandard-display-underline
Display character C as character UC plus underlining.
Fstandard-display-european
Toggle display of European characters encoded with ISO 8859.
When enabled, characters in the range of 160 to 255 display not
as octal escapes, but as accented characters.
With prefix argument, enable European character display iff arg is positive.
Fdissociated-press
Dissociate the text of the current buffer.
Output goes in buffer named *Dissociation*,
which is redisplayed each time text is added to it.
Every so often the user must say whether to continue.
If ARG is positive, require ARG chars of continuity.
If ARG is negative, require -ARG words of continuity.
Default is 2.
Fdoctor
Switch to *doctor* buffer and start giving psychotherapy.
Fdunnet
Switch to *dungeon* buffer and start game.
Felectric-buffer-list
Pops up a buffer describing the set of Emacs buffers.
Vaguely like ITS lunar select buffer; combining typeoutoid buffer
listing with menuoid buffer selection.

If the very next character typed is a space then the buffer list
window disappears.  Otherwise, one may move around in the buffer list
window, marking buffers to be selected, saved or deleted.

To exit and select a new buffer, type a space when the cursor is on
the appropriate line of the buffer-list window.  Other commands are
much like those of buffer-menu-mode.

Calls value of `electric-buffer-menu-mode-hook' on entry if non-nil.

\{electric-buffer-menu-mode-map}
FElectric-command-history-redo-expression
Edit current history line in minibuffer and execute result.
With prefix arg NOCONFIRM, execute current line as-is without editing.
Fedebug-defun
Evaluate defun or defmacro, like eval-defun, but with edebug calls.
Print its name in the minibuffer and leave point after any error it finds,
with mark at the original point.
Vglobal-edebug-prefix
Prefix key for global edebug commands, available from any buffer.
Vglobal-edebug-map
Global map of edebug commands, available from any buffer.
Fedebug-debug
Replacement for debug.  
If an error or quit occurred and we are running an edebugged function,
show where we last were.  Otherwise call debug normally.
Fedit-last-kbd-macro
Edit the most recently defined keyboard macro.
Fedit-kbd-macro
Edit a keyboard macro which has been given a name by `name-last-kbd-macro'.
(See also `edit-last-kbd-macro'.)
Fread-kbd-macro
Read the region as a keyboard macro definition.
The region is interpreted as spelled-out keystrokes, e.g., "M-x abc RET".
The resulting macro is installed as the "current" keyboard macro.

Symbols:  RET, SPC, TAB, DEL, LFD, NUL; C-key; M-key.  (Must be uppercase.)
          REM marks the rest of a line as a comment.
          Whitespace is ignored; other characters are copied into the macro.
Fedt-emulation-on
Emulate DEC's EDT editor.
Note that many keys are rebound; including nearly all keypad keys.
Use \[edt-emulation-off] to undo all rebindings except the keypad keys.
Freport-emacs-bug
Report a bug in GNU Emacs.
Prompts for bug subject.  Leaves you in a mail buffer.
Femerge-files
Run Emerge on two files.
Femerge-files-with-ancestor
Run Emerge on two files, giving another file as the ancestor.
Femerge-buffers
Run Emerge on two buffers.
Femerge-buffers-with-ancestor
Run Emerge on two buffers, giving another buffer as the ancestor.
Fsetenv
Set the value of the environment variable named VARIABLE to VALUE.
VARIABLE should be a string.  VALUE is optional; if not provided or is
`nil', the environment variable VARIABLE will be removed.  
This function works by modifying `process-environment'.
Vtags-file-name
*File name of tags table.
To switch to a new tags table, setting this variable is sufficient.
If you set this variable, do not also set `tags-table-list'.
Use the `etags' program to make a tags table file.
Vtags-table-list
*List of file names of tags tables to search.
An element that is a directory means the file "TAGS" in that directory.
To switch to a new list of tags tables, setting this variable is sufficient.
If you set this variable, do not also set `tags-file-name'.
Use the `etags' program to make a tags table file.
Vfind-tag-hook
*Hook to be run by \[find-tag] after finding a tag.  See `run-hooks'.
The value in the buffer in which \[find-tag] is done is used,
not the value in the buffer \[find-tag] goes to.
Vfind-tag-default-function
*A function of no arguments used by \[find-tag] to pick a default tag.
If nil, and the symbol that is the value of `major-mode'
has a `find-tag-default-function' property (see `put'), that is used.
Otherwise, `find-tag-default' is used.
Vdefault-tags-table-function
*If non-nil, a function of no arguments to choose a default tags file
for a particular buffer.
Fvisit-tags-table
Tell tags commands to use tags table file FILE.
FILE should be the name of a file created with the `etags' program.
A directory name is ok too; it means file TAGS in that directory.

Normally \[visit-tags-table] sets the global value of `tags-file-name'.
With a prefix arg, set the buffer-local value instead.
When you find a tag with \[find-tag], the buffer it finds the tag
in is given a local value of this variable which is the name of the tags
file the tag was in.
Ftags-table-files
Return a list of files in the current tags table.
Assumes the tags table is the current buffer.
File names returned are absolute.
Ffind-tag-noselect
Find tag (in current tags table) whose name contains TAGNAME.
Returns the buffer containing the tag's definition and moves its point there,
but does not select the buffer.
The default for TAGNAME is the expression in the buffer near point.

If second arg NEXT-P is t (interactively, with prefix arg), search for
another tag that matches the last tagname or regexp used.  When there are
multiple matches for a tag, more exact matches are found first.  If NEXT-P
is the atom `-' (interactively, with prefix arg that is a negative number
or just \[negative-argument]), pop back to the previous tag gone to.

If third arg REGEXP-P is non-nil, treat TAGNAME as a regexp.

See documentation of variable `tags-file-name'.
Ffind-tag
Find tag (in current tags table) whose name contains TAGNAME.
Select the buffer containing the tag's definition, and move point there.
The default for TAGNAME is the expression in the buffer around or before point.

If second arg NEXT-P is t (interactively, with prefix arg), search for
another tag that matches the last tagname or regexp used.  When there are
multiple matches for a tag, more exact matches are found first.  If NEXT-P
is the atom `-' (interactively, with prefix arg that is a negative number
or just \[negative-argument]), pop back to the previous tag gone to.

See documentation of variable `tags-file-name'.
Ffind-tag-other-window
Find tag (in current tags table) whose name contains TAGNAME.
Select the buffer containing the tag's definition in another window, and
move point there.  The default for TAGNAME is the expression in the buffer
around or before point.

If second arg NEXT-P is t (interactively, with prefix arg), search for
another tag that matches the last tagname or regexp used.  When there are
multiple matches for a tag, more exact matches are found first.  If NEXT-P
is negative (interactively, with prefix arg that is a negative number or
just \[negative-argument]), pop back to the previous tag gone to.

See documentation of variable `tags-file-name'.
Ffind-tag-other-frame
Find tag (in current tags table) whose name contains TAGNAME.
Select the buffer containing the tag's definition in another frame, and
move point there.  The default for TAGNAME is the expression in the buffer
around or before point.

If second arg NEXT-P is t (interactively, with prefix arg), search for
another tag that matches the last tagname or regexp used.  When there are
multiple matches for a tag, more exact matches are found first.  If NEXT-P
is negative (interactively, with prefix arg that is a negative number or
just \[negative-argument]), pop back to the previous tag gone to.

See documentation of variable `tags-file-name'.
Ffind-tag-regexp
Find tag (in current tags table) whose name matches REGEXP.
Select the buffer containing the tag's definition and move point there.

If second arg NEXT-P is t (interactively, with prefix arg), search for
another tag that matches the last tagname or regexp used.  When there are
multiple matches for a tag, more exact matches are found first.  If NEXT-P
is negative (interactively, with prefix arg that is a negative number or
just \[negative-argument]), pop back to the previous tag gone to.

If third arg OTHER-WINDOW is non-nil, select the buffer in another window.

See documentation of variable `tags-file-name'.
Fnext-file
Select next file among files in current tags table.
Non-nil first argument (prefix arg, if interactive)
initializes to the beginning of the list of files in the tags table.

Non-nil second argument NOVISIT means use a temporary buffer
 to save time and avoid uninteresting warnings.

Value is nil if the file was already visited;
if the file was newly read in, the value is the filename.
Ftags-loop-continue
Continue last \[tags-search] or \[tags-query-replace] command.
Used noninteractively with non-nil argument to begin such a command.
Two variables control the processing we do on each file:
the value of `tags-loop-scan' is a form to be executed on each file
to see if it is interesting (it returns non-nil if so)
and `tags-loop-operate' is a form to execute to operate on an interesting file
If the latter returns non-nil, we exit; otherwise we scan the next file.
Ftags-search
Search through all files listed in tags table for match for REGEXP.
Stops when a match is found.
To continue searching for next match, use command \[tags-loop-continue].

See documentation of variable `tags-file-name'.
Ftags-query-replace
Query-replace-regexp FROM with TO through all files listed in tags table.
Third arg DELIMITED (prefix arg) means replace only word-delimited matches.
If you exit (\[keyboard-quit] or ESC), you can resume the query-replace
with the command \[tags-loop-continue].

See documentation of variable `tags-file-name'.
Flist-tags
Display list of tags in file FILE.
FILE should not contain a directory specification
unless it has one in the tags table.
Ftags-apropos
Display list of all tags in tags table REGEXP matches.
Fselect-tags-table
Select a tags table file from a menu of those you have already used.
The list of tags tables to select from is stored in `tags-table-file-list';
see the doc of that variable if you want to add names to the list.
Fcomplete-tag
Perform tags completion on the text around point.
Completes to the set of names listed in the current tags table.  
The string to complete is chosen in the same way as the default
for \[find-tag] (which see).
Vtags-file-name
*File name of tags table.
To switch to a new tags table, setting this variable is sufficient.
If you set this variable, do not also set `tags-table-list'.
Use the `etags' program to make a tags table file.
Vtags-table-list
*List of file names of tags tables to search.
An element that is a directory means the file "TAGS" in that directory.
To switch to a new list of tags tables, setting this variable is sufficient.
If you set this variable, do not also set `tags-file-name'.
Use the `etags' program to make a tags table file.
Vfind-tag-hook
*Hook to be run by \[find-tag] after finding a tag.  See `run-hooks'.
The value in the buffer in which \[find-tag] is done is used,
not the value in the buffer \[find-tag] goes to.
Vfind-tag-default-function
*A function of no arguments used by \[find-tag] to pick a default tag.
If nil, and the symbol that is the value of `major-mode'
has a `find-tag-default-function' property (see `put'), that is used.
Otherwise, `find-tag-default' is used.
Vdefault-tags-table-function
*If non-nil, a function of no arguments to choose a default tags file
for a particular buffer.
Fvisit-tags-table
Tell tags commands to use tags table file FILE.
FILE should be the name of a file created with the `etags' program.
A directory name is ok too; it means file TAGS in that directory.

Normally \[visit-tags-table] sets the global value of `tags-file-name'.
With a prefix arg, set the buffer-local value instead.
When you find a tag with \[find-tag], the buffer it finds the tag
in is given a local value of this variable which is the name of the tags
file the tag was in.
Ftags-table-files
Return a list of files in the current tags table.
Assumes the tags table is the current buffer.
File names returned are absolute.
Ffind-tag-noselect
Find tag (in current tags table) whose name contains TAGNAME.
Returns the buffer containing the tag's definition and moves its point there,
but does not select the buffer.
The default for TAGNAME is the expression in the buffer near point.

If second arg NEXT-P is t (interactively, with prefix arg), search for
another tag that matches the last tagname or regexp used.  When there are
multiple matches for a tag, more exact matches are found first.  If NEXT-P
is the atom `-' (interactively, with prefix arg that is a negative number
or just \[negative-argument]), pop back to the previous tag gone to.

If third arg REGEXP-P is non-nil, treat TAGNAME as a regexp.

See documentation of variable `tags-file-name'.
Ffind-tag
Find tag (in current tags table) whose name contains TAGNAME.
Select the buffer containing the tag's definition, and move point there.
The default for TAGNAME is the expression in the buffer around or before point.

If second arg NEXT-P is t (interactively, with prefix arg), search for
another tag that matches the last tagname or regexp used.  When there are
multiple matches for a tag, more exact matches are found first.  If NEXT-P
is the atom `-' (interactively, with prefix arg that is a negative number
or just \[negative-argument]), pop back to the previous tag gone to.

See documentation of variable `tags-file-name'.
Ffind-tag-other-window
Find tag (in current tags table) whose name contains TAGNAME.
Select the buffer containing the tag's definition in another window, and
move point there.  The default for TAGNAME is the expression in the buffer
around or before point.

If second arg NEXT-P is t (interactively, with prefix arg), search for
another tag that matches the last tagname or regexp used.  When there are
multiple matches for a tag, more exact matches are found first.  If NEXT-P
is negative (interactively, with prefix arg that is a negative number or
just \[negative-argument]), pop back to the previous tag gone to.

See documentation of variable `tags-file-name'.
Ffind-tag-other-frame
Find tag (in current tags table) whose name contains TAGNAME.
Select the buffer containing the tag's definition in another frame, and
move point there.  The default for TAGNAME is the expression in the buffer
around or before point.

If second arg NEXT-P is t (interactively, with prefix arg), search for
another tag that matches the last tagname or regexp used.  When there are
multiple matches for a tag, more exact matches are found first.  If NEXT-P
is negative (interactively, with prefix arg that is a negative number or
just \[negative-argument]), pop back to the previous tag gone to.

See documentation of variable `tags-file-name'.
Ffind-tag-regexp
Find tag (in current tags table) whose name matches REGEXP.
Select the buffer containing the tag's definition and move point there.

If second arg NEXT-P is t (interactively, with prefix arg), search for
another tag that matches the last tagname or regexp used.  When there are
multiple matches for a tag, more exact matches are found first.  If NEXT-P
is negative (interactively, with prefix arg that is a negative number or
just \[negative-argument]), pop back to the previous tag gone to.

If third arg OTHER-WINDOW is non-nil, select the buffer in another window.

See documentation of variable `tags-file-name'.
Fnext-file
Select next file among files in current tags table.
Non-nil first argument (prefix arg, if interactive)
initializes to the beginning of the list of files in the tags table.

Non-nil second argument NOVISIT means use a temporary buffer
 to save time and avoid uninteresting warnings.

Value is nil if the file was already visited;
if the file was newly read in, the value is the filename.
Ftags-loop-continue
Continue last \[tags-search] or \[tags-query-replace] command.
Used noninteractively with non-nil argument to begin such a command.
Two variables control the processing we do on each file:
the value of `tags-loop-scan' is a form to be executed on each file
to see if it is interesting (it returns non-nil if so)
and `tags-loop-operate' is a form to execute to operate on an interesting file
If the latter returns non-nil, we exit; otherwise we scan the next file.
Ftags-search
Search through all files listed in tags table for match for REGEXP.
Stops when a match is found.
To continue searching for next match, use command \[tags-loop-continue].

See documentation of variable `tags-file-name'.
Ftags-query-replace
Query-replace-regexp FROM with TO through all files listed in tags table.
Third arg DELIMITED (prefix arg) means replace only word-delimited matches.
If you exit (\[keyboard-quit] or ESC), you can resume the query-replace
with the command \[tags-loop-continue].

See documentation of variable `tags-file-name'.
Flist-tags
Display list of tags in file FILE.
FILE should not contain a directory specification
unless it has one in the tags table.
Ftags-apropos
Display list of all tags in tags table REGEXP matches.
Fselect-tags-table
Select a tags table file from a menu of those you have already used.
The list of tags tables to select from is stored in `tags-table-file-list';
see the doc of that variable if you want to add names to the list.
Fcomplete-tag
Perform tags completion on the text around point.
Completes to the set of names listed in the current tags table.  
The string to complete is chosen in the same way as the default
for \[find-tag] (which see).
Vfind-ls-option
*Option to `find' to produce an `ls -l'-type listing.
Vfind-grep-options
*Option to grep to be as silent as possible.
On Berkeley systems, this is `-s', for others it seems impossible to
suppress all output, so `-l' is used to print nothing more than the
file name.
Ffind-dired
Run `find' and go into dired-mode on a buffer of the output.
The command run (after changing into DIR) is

    find . \( ARGS \) -ls
Ffind-name-dired
Search DIR recursively for files matching the globbing pattern PATTERN,
and run dired on those files.
PATTERN is a shell wildcard (not an Emacs regexp) and need not be quoted.
The command run (after changing into DIR) is

    find . -name 'PATTERN' -ls
Ffind-grep-dired
Find files in DIR containing a regexp ARG and start Dired on output.
The command run (after changing into DIR) is

    find . -exec grep -s ARG {} \; -ls

Thus ARG can also contain additional grep options.
Fenable-flow-control
Enable use of flow control; let user type C-s as C-\ and C-q as C-^.
Fenable-flow-control-on
Enable flow control if using one of a specified set of terminal types.
Use `(enable-flow-control-on "vt100" "h19")' to enable flow control
on VT-100 and H19 terminals.  When flow control is enabled,
you must type C-\ to get the effect of a C-s, and type C-^
to get the effect of a C-q.
Vfont-lock-mode-hook
Function or functions to run on entry to Font Lock mode.
Ffont-lock-mode
Toggle Font Lock mode.
With arg, turn Font Lock mode on if and only if arg is positive.

When Font Lock mode is enabled, text is fontified as you type it:

 - comments are displayed in `font-lock-comment-face';
     (That is a variable whose value should be a face name.)
 - strings are displayed in `font-lock-string-face';
 - documentation strings are displayed in `font-lock-doc-string-face';
 - function and variable names in their defining forms are displayed
   in `font-lock-function-name-face';
 - and certain other expressions are displayed in other faces
   according to the value of the variable `font-lock-keywords'.

When you turn Font Lock mode on/off, the buffer is fontified/defontified.
To fontify a buffer without having newly typed text become fontified, you
can use \[font-lock-fontify-buffer].
Fforms-mode
Major mode to visit files in a field-structured manner using a form.

Commands (prefix with C-c if not in read-only mode):
\{forms-mode-map}
Fforms-find-file
Visit a file in Forms mode.
Fforms-find-file-other-window
Visit a file in Forms mode in other window.
Vfortran-tab-mode-default
*Default tabbing/carriage control style for empty files in Fortran mode.
A value of t specifies tab-digit style of continuation control.
A value of nil specifies that continuation lines are marked
with a character in column 6.
Ffortran-mode
Major mode for editing Fortran code.
\[fortran-indent-line] indents the current Fortran line correctly. 
DO statements must not share a common CONTINUE.

Type ;? or ;\[help-command] to display a list of built-in abbrevs for Fortran keywords.

Key definitions:
\{fortran-mode-map}

Variables controlling indentation style and extra features:

 comment-start
    Normally nil in Fortran mode.  If you want to use comments
    starting with `!', set this to the string "!".
 fortran-do-indent
    Extra indentation within do blocks.  (default 3)
 fortran-if-indent
    Extra indentation within if blocks.  (default 3)
 fortran-structure-indent
    Extra indentation within structure, union and map blocks.  (default 3)
 fortran-continuation-indent
    Extra indentation applied to continuation statements.  (default 5)
 fortran-comment-line-extra-indent
    Amount of extra indentation for text within full-line comments. (default 0)
 fortran-comment-indent-style
    nil    means don't change indentation of text in full-line comments,
    fixed  means indent that text at `fortran-comment-line-extra-indent' beyond
           the value of `fortran-minimum-statement-indent-fixed' (for fixed
           format continuation style) or `fortran-minimum-statement-indent-tab'
           (for TAB format continuation style).
    relative  means indent at `fortran-comment-line-extra-indent' beyond the
 	      indentation for a line of code.
    (default 'fixed)
 fortran-comment-indent-char
    Single-character string to be inserted instead of space for
    full-line comment indentation.  (default " ")
 fortran-minimum-statement-indent-fixed
    Minimum indentation for Fortran statements in fixed format mode. (def.6)
 fortran-minimum-statement-indent-tab
    Minimum indentation for Fortran statements in TAB format mode. (default 9)
 fortran-line-number-indent
    Maximum indentation for line numbers.  A line number will get
    less than this much indentation if necessary to avoid reaching
    column 5.  (default 1)
 fortran-check-all-num-for-matching-do
    Non-nil causes all numbered lines to be treated as possible "continue"
    statements.  (default nil)
 fortran-blink-matching-if 
    From a Fortran ENDIF statement, blink the matching IF statement.
    (default nil)
 fortran-continuation-string
    Single-character string to be inserted in column 5 of a continuation
    line.  (default "$")
 fortran-comment-region
    String inserted by \[fortran-comment-region] at start of each line in 
    region.  (default "c$$$")
 fortran-electric-line-number
    Non-nil causes line number digits to be moved to the correct column 
    as typed.  (default t)
 fortran-break-before-delimiters
    Non-nil causes `fortran-do-auto-fill' breaks lines before delimiters.
    (default t)
 fortran-startup-message
    Set to nil to inhibit message first time Fortran mode is used.

Turning on Fortran mode calls the value of the variable `fortran-mode-hook'
with no args, if that value is non-nil.
Fgnus
Read network news.
If optional argument CONFIRM is non-nil, ask NNTP server.
Fgnus-post-news
Begin editing a new USENET news article to be posted.
Type \[describe-mode] once editing the article to get a list of commands.
Fgomoku
Start a Gomoku game between you and Emacs.
If a game is in progress, this command allow you to resume it.
If optional arguments N and M are given, an N by M board is used.

You and Emacs play in turn by marking a free square.  You mark it with X
and Emacs marks it with O. The winner is the first to get five contiguous
marks horizontally, vertically or in diagonal.

You play by moving the cursor over the square you choose and hitting
\<gomoku-mode-map>\[gomoku-human-plays].
Use \[describe-mode] for more info.
Fset-gosmacs-bindings
Rebind some keys globally to make GNU Emacs resemble Gosling Emacs.
Use \[set-gnu-bindings] to restore previous global bindings.
Fgdb
Run gdb on program FILE in buffer *gud-FILE*.
The directory containing FILE becomes the initial working directory
and source-file directory for your debugger.
Fsdb
Run sdb on program FILE in buffer *gud-FILE*.
The directory containing FILE becomes the initial working directory
and source-file directory for your debugger.
Fdbx
Run dbx on program FILE in buffer *gud-FILE*.
The directory containing FILE becomes the initial working directory
and source-file directory for your debugger.
Fxdb
Run xdb on program FILE in buffer *gud-FILE*.
The directory containing FILE becomes the initial working directory
and source-file directory for your debugger.

You can set the variable 'gud-xdb-directories' to a list of program source
directories if your program contains sources from more than one directory.
Fhanoi
Towers of Hanoi diversion.  Argument is number of rings.
FHelper-describe-bindings
Describe local key bindings of current mode.
FHelper-help
Provide help for current mode.
Fhexl-mode
\<hexl-mode-map>
A major mode for editing binary files in hex dump format.

This function automatically converts a buffer into the hexl format
using the function `hexlify-buffer'.

Each line in the buffer has an "address" (displayed in hexadecimal)
representing the offset into the file that the characters on this line
are at and 16 characters from the file (displayed as hexadecimal
values grouped every 16 bits) and as their ASCII values.

If any of the characters (displayed as ASCII characters) are
unprintable (control or meta characters) they will be replaced as
periods.

If `hexl-mode' is invoked with an argument the buffer is assumed to be
in hexl format.

A sample format:

  HEX ADDR: 0001 0203 0405 0607 0809 0a0b 0c0d 0e0f     ASCII-TEXT
  --------  ---- ---- ---- ---- ---- ---- ---- ----  ----------------
  00000000: 5468 6973 2069 7320 6865 786c 2d6d 6f64  This is hexl-mod
  00000010: 652e 2020 4561 6368 206c 696e 6520 7265  e.  Each line re
  00000020: 7072 6573 656e 7473 2031 3620 6279 7465  presents 16 byte
  00000030: 7320 6173 2068 6578 6164 6563 696d 616c  s as hexadecimal
  00000040: 2041 5343 4949 0a61 6e64 2070 7269 6e74   ASCII.and print
  00000050: 6162 6c65 2041 5343 4949 2063 6861 7261  able ASCII chara
  00000060: 6374 6572 732e 2020 416e 7920 636f 6e74  cters.  Any cont
  00000070: 726f 6c20 6f72 206e 6f6e 2d41 5343 4949  rol or non-ASCII
  00000080: 2063 6861 7261 6374 6572 730a 6172 6520   characters.are 
  00000090: 6469 7370 6c61 7965 6420 6173 2070 6572  displayed as per
  000000a0: 696f 6473 2069 6e20 7468 6520 7072 696e  iods in the prin
  000000b0: 7461 626c 6520 6368 6172 6163 7465 7220  table character 
  000000c0: 7265 6769 6f6e 2e0a                      region..

Movement is as simple as movement in a normal emacs text buffer.  Most
cursor movement bindings are the same (ie. Use \[hexl-backward-char], \[hexl-forward-char], \[hexl-next-line], and \[hexl-previous-line]
to move the cursor left, right, down, and up).

Advanced cursor movement commands (ala \[hexl-beginning-of-line], \[hexl-end-of-line], \[hexl-beginning-of-buffer], and \[hexl-end-of-buffer]) are
also supported.

There are several ways to change text in hexl mode:

ASCII characters (character between space (0x20) and tilde (0x7E)) are
bound to self-insert so you can simply type the character and it will
insert itself (actually overstrike) into the buffer.

\[hexl-quoted-insert] followed by another keystroke allows you to insert the key even if
it isn't bound to self-insert.  An octal number can be supplied in place
of another key to insert the octal number's ASCII representation.

\[hexl-insert-hex-char] will insert a given hexadecimal value (if it is between 0 and 0xFF)
into the buffer at the current point.

\[hexl-insert-octal-char] will insert a given octal value (if it is between 0 and 0377)
into the buffer at the current point.

\[hexl-insert-decimal-char] will insert a given decimal value (if it is between 0 and 255)
into the buffer at the current point.

\[hexl-mode-exit] will exit hexl-mode.

Note: saving the file with any of the usual Emacs commands
will actually convert it back to binary format while saving.

You can use \[hexl-find-file] to visit a file in hexl-mode.

\[describe-bindings] for advanced commands.
Fhexl-find-file
Edit file FILENAME in hexl-mode.
Switch to a buffer visiting file FILENAME, creating one in none exists.
Fhide-ifdef-mode
Toggle Hide-Ifdef mode.  This is a minor mode, albeit a large one.
With ARG, turn Hide-Ifdef mode on iff arg is positive.
In Hide-Ifdef mode, code within #ifdef constructs that the C preprocessor
would eliminate may be hidden from view.  Several variables affect
how the hiding is done:

hide-ifdef-env
	An association list of defined and undefined symbols for the
	current buffer.  Initially, the global value of `hide-ifdef-env'
	is used.

hide-ifdef-define-alist
	An association list of defined symbol lists.  
        Use `hide-ifdef-set-define-alist' to save the current `hide-ifdef-env'
        and `hide-ifdef-use-define-alist' to set the current `hide-ifdef-env'
        from one of the lists in `hide-ifdef-define-alist'.

hide-ifdef-lines
	Set to non-nil to not show #if, #ifdef, #ifndef, #else, and
	#endif lines when hiding.

hide-ifdef-initially
	Indicates whether `hide-ifdefs' should be called when Hide-Ifdef mode
	is activated.

hide-ifdef-read-only
	Set to non-nil if you want to make buffers read only while hiding.
	After `show-ifdefs', read-only status is restored to previous value.

\{hide-ifdef-mode-map}
Vhide-ifdef-initially
*Non-nil if `hide-ifdefs' should be called when Hide-Ifdef mode
is first activated.
Vhide-ifdef-read-only
*Set to non-nil if you want buffer to be read-only while hiding text.
Vhide-ifdef-lines
*Set to t if you don't want to see the #ifX, #else, and #endif lines.
Vhippie-expand-try-functions-list
The list of expansion functions tried in order by `hippie-expand'.
To change the behavior of `hippie-expand', remove, change the order of,
or insert functions in this list.
Vhippie-expand-verbose
*Non-nil makes `hippie-expand' output which function it is trying.
Vhippie-expand-max-buffers
*The maximum number of buffers (apart from the current) searched.
If nil, all buffers are searched.
Fhippie-expand
Try to expand text before point, using multiple methods.
The expansion functions in `hippie-expand-try-functions-list' are
tried in order, until a possible expansion is found.  Repeated
application of `hippie-expand' inserts successively possible
expansions.  
With a positive numeric argument, jumps directly to the ARG next
function in this list.  With a negative argument or just \[universal-argument], 
undoes the expansion.
Fmake-hippie-expand-function
Construct a function similar to `hippie-expand'.
Make it use the expansion functions in TRY-LIST.  An optional second
argument VERBOSE non-nil makes the function verbose.
Vinferior-lisp-filter-regexp
*What not to save on inferior Lisp's input history.
Input matching this regexp is not saved on the input history in Inferior Lisp
mode.  Default is whitespace followed by 0 or 1 single-letter colon-keyword 
(as in :a, :c, etc.)
Vinferior-lisp-program
*Program name for invoking an inferior Lisp with for Inferior Lisp mode.
Vinferior-lisp-prompt
Regexp to recognise prompts in the Inferior Lisp mode.
Defaults to "^[^> ]*>+:? *", which works pretty good for Lucid, kcl,
and franz.  This variable is used to initialize `comint-prompt-regexp' in the 
Inferior Lisp buffer.

More precise choices:
Lucid Common Lisp: "^\(>\|\(->\)+\) *"
franz: "^\(->\|<[0-9]*>:\) *"
kcl: "^>+ *"

This is a fine thing to set in your .emacs file.
Vinferior-lisp-mode-hook
*Hook for customising Inferior Lisp mode.
Finferior-lisp
Run an inferior Lisp process, input and output via buffer `*inferior-lisp*'.
If there is a process already running in `*inferior-lisp*', just switch
to that buffer.
With argument, allows you to edit the command line (default is value
of `inferior-lisp-program').  Runs the hooks from
`inferior-lisp-mode-hook' (after the `comint-mode-hook' is run).
(Type \[describe-mode] in the process buffer for a list of commands.)
Finfo
Enter Info, the documentation browser.
Optional argument FILE specifies the file to examine;
the default is the top-level directory of Info.

In interactive use, a prefix argument directs this command
to read a file name from the minibuffer.
FInfo-goto-emacs-command-node
Go to the Info node in the Emacs manual for command COMMAND.
FInfo-goto-emacs-key-command-node
Go to the Info node in the Emacs manual the command bound to KEY, a string.
Interactively, if the binding is execute-extended-command, a command is read.
FInfo-tagify
Create or update Info-file tag table in current buffer.
FInfo-split
Split an info file into an indirect file plus bounded-size subfiles.
Each subfile will be up to 50,000 characters plus one node.

To use this command, first visit a large Info file that has a tag
table.  The buffer is modified into a (small) indirect info file which
should be saved in place of the original visited file.

The subfiles are written in the same directory the original file is
in, with names generated by appending `-' and a number to the original
file name.  The indirect file still functions as an Info file, but it
contains just the tag table and a directory of subfiles.
FInfo-validate
Check current buffer for validity as an Info file.
Check that every node pointer points to an existing node.
Fbatch-info-validate
Runs `Info-validate' on the files remaining on the command line.
Must be used only with -batch, and kills Emacs on completion.
Each file will be processed even if an error occurred previously.
For example, invoke "emacs -batch -f batch-info-validate $info/ ~/*.info"
Fispell
Run Ispell over current buffer's visited file.
First the file is scanned for misspelled words, then Ispell
enters a loop with the following commands for every misspelled word:

DIGIT	Near miss selector.  If the misspelled word is close to
	some words in the dictionary, they are offered as near misses.
r	Replace.  Replace the word with a string you type.  Each word
	of your new string is also checked.
i	Insert.  Insert this word in your private dictionary (kept in
	`$HOME/ispell.words').
a	Accept.  Accept this word for the rest of this editing session,
 	but don't put it in your private dictionary.
l	Lookup.  Look for a word in the dictionary by fast binary
	search, or search for a regular expression in the dictionary
	using grep.
SPACE	Accept the word this time, but complain if it is seen again.
q, \[keyboard-quit]	Leave the command loop.  You can come back later with \[ispell-next].
Fispell-word
Check the spelling of the word under the cursor.
See the command `ispell' for more information.
With a prefix argument, resume handling of the previous Ispell command.
Fispell-region
Check the spelling for all of the words in the region.
Vledit-save-files
*Non-nil means Ledit should save files before transferring to Lisp.
Vledit-go-to-lisp-string
*Shell commands to execute to resume Lisp job.
Vledit-go-to-liszt-string
*Shell commands to execute to resume Lisp compiler job.
Fledit-mode
\<ledit-mode-map>Major mode for editing text and stuffing it to a Lisp job.
Like Lisp mode, plus these special commands:
  \[ledit-save-defun]	-- record defun at or after point
	   for later transmission to Lisp job.
  \[ledit-save-region] -- record region for later transmission to Lisp job.
  \[ledit-go-to-lisp] -- transfer to Lisp job and transmit saved text.
  \[ledit-go-to-liszt] -- transfer to Liszt (Lisp compiler) job
	   and transmit saved text.
\{ledit-mode-map}
To make Lisp mode automatically change to Ledit mode,
do (setq lisp-mode-hook 'ledit-from-lisp-mode)
Flife
Run Conway's Life simulation.
The starting pattern is randomly selected.  Prefix arg (optional first
arg non-nil from a program) is the number of seconds to sleep between
generations (this defaults to 1).
Funload-feature
Unload the library that provided FEATURE, restoring all its autoloads.
If the feature is required by any other loaded code, and optional FORCE
is nil, raise an error.
Vlpr-switches
*List of strings to pass as extra switch args to lpr when it is invoked.
Vlpr-command
*Shell command for printing a file
Flpr-buffer
Print buffer contents as with Unix command `lpr'.
`lpr-switches' is a list of extra switches (strings) to pass to lpr.
Fprint-buffer
Print buffer contents as with Unix command `lpr -p'.
`lpr-switches' is a list of extra switches (strings) to pass to lpr.
Flpr-region
Print region contents as with Unix command `lpr'.
`lpr-switches' is a list of extra switches (strings) to pass to lpr.
Fprint-region
Print region contents as with Unix command `lpr -p'.
`lpr-switches' is a list of extra switches (strings) to pass to lpr.
Fphases-of-moon
Display the quarters of the moon for last month, this month, and next month.
If called with an optional prefix argument, prompts for month and year.

This function is suitable for execution in a .emacs file.
Fname-last-kbd-macro
Assign a name to the last keyboard macro defined.
Argument SYMBOL is the name to define.
The symbol's function definition becomes the keyboard macro string.
Such a "function" cannot be called from Lisp, but it is a valid editor command.
Finsert-kbd-macro
Insert in buffer the definition of kbd macro NAME, as Lisp code.
Optional second arg KEYS means also record the keys it is on
(this is the prefix argument, when calling interactively).

This Lisp code will, when executed, define the kbd macro with the same
definition it has now.  If you say to record the keys, the Lisp code
will also rebind those keys to the macro.  Only global key bindings
are recorded since executing this Lisp code always makes global
bindings.

To save a kbd macro, visit a file of Lisp code such as your `~/.emacs',
use this command, and then save the file.
Fkbd-macro-query
Query user during kbd macro execution.
  With prefix argument, enters recursive edit, reading keyboard
commands even within a kbd macro.  You can give different commands
each time the macro executes.
  Without prefix argument, asks whether to continue running the macro.
Your options are: \<query-replace-map>
\[act]	Finish this iteration normally and continue with the next.
\[skip]	Skip the rest of this iteration, and start the next.
\[exit]	Stop the macro entirely right now.
\[recenter]	Redisplay the screen, then ask again.
\[edit]	Enter recursive edit; ask again when you exit from that.
Fapply-macro-to-region-lines
For each complete line between point and mark, move to the beginning
of the line, and run the last keyboard macro.

When called from lisp, this function takes two arguments TOP and
BOTTOM, describing the current region.  TOP must be before BOTTOM.
The optional third argument MACRO specifies a keyboard macro to
execute.

This is useful for quoting or unquoting included text, adding and
removing comments, or producing tables where the entries are regular.

For example, in Usenet articles, sections of text quoted from another
author are indented, or have each line start with `>'.  To quote a
section of text, define a keyboard macro which inserts `>', put point
and mark at opposite ends of the quoted section, and use
`\[apply-macro-to-region-lines]' to mark the entire section.

Suppose you wanted to build a keyword table in C where each entry
looked like this:

    { "foo", foo_data, foo_function }, 
    { "bar", bar_data, bar_function },
    { "baz", baz_data, baz_function },

You could enter the names in this format:

    foo
    bar
    baz

and write a macro to massage a word into a table entry:

    \C-x (
       \M-d { "\C-y", \C-y_data, \C-y_function },
    \C-x )

and then select the region of un-tablified names and use
`\[apply-macro-to-region-lines]' to build the table from the names.

Vmail-use-rfc822
*If non-nil, use a full, hairy RFC822 parser on mail addresses.
Otherwise, (the default) use a smaller, somewhat faster, and
often correct parser.
Fbuild-mail-abbrevs
Read mail aliases from `~/.mailrc' file and set `mail-abbrevs'.
Fdefine-mail-abbrev
Define NAME as a mail-abbrev that translates to DEFINITION.
If DEFINITION contains multiple addresses, separate them with commas.
Fdefine-mail-alias
Define NAME as a mail alias that translates to DEFINITION.
This means that sending a message to NAME will actually send to DEFINITION.
DEFINITION can be one or more mail addresses separated by commas.
Fmakefile-mode
Major mode for editing Makefiles.
Calling this function invokes the function(s) "makefile-mode-hook" before
doing anything else.

\{makefile-mode-map}

In the browser, use the following keys:

\{makefile-browser-map}

makefile-mode can be configured by modifying the following
variables:

makefile-mode-name:
    The "pretty name" of makefile-mode, as it
    appears in the modeline.

makefile-browser-buffer-name:
    Name of the macro- and target browser buffer.

makefile-target-colon:
    The string that gets appended to all target names
    inserted by makefile-insert-target.
    ":" or "::" are quite common values.

makefile-macro-assign:
   The string that gets appended to all macro names
   inserted by makefile-insert-macro.
   The normal value should be " = ", since this is what
   standard make expects. However, newer makes such as dmake
   allow a larger variety of different macro assignments, so you
   might prefer to use " += " or " := " .

makefile-tab-after-target-colon:
   If you want a TAB (instead of a space) to be appended after the
   target colon, then set this to a non-nil value.

makefile-browser-leftmost-column:
   Number of blanks to the left of the browser selection mark.

makefile-browser-cursor-column:
   Column in which the cursor is positioned when it moves
   up or down in the browser.

makefile-browser-selected-mark:
   String used to mark selected entries in the browser.

makefile-browser-unselected-mark:
   String used to mark unselected entries in the browser.

makefile-browser-auto-advance-after-selection-p:
   If this variable is set to a non-nil value the cursor
   will automagically advance to the next line after an item
   has been selected in the browser.

makefile-pickup-everything-picks-up-filenames-p:
   If this variable is set to a non-nil value then
   makefile-pickup-everything also picks up filenames as targets
   (i.e. it calls makefile-find-filenames-as-targets), otherwise
   filenames are omitted.

makefile-cleanup-continuations-p:
   If this variable is set to a non-nil value then makefile-mode
   will assure that no line in the file ends with a backslash
   (the continuation character) followed by any whitespace.
   This is done by silently removing the trailing whitespace, leaving
   the backslash itself intact.
   IMPORTANT: Please note that enabling this option causes makefile-mode
   to MODIFY A FILE WITHOUT YOUR CONFIRMATION when 'it seems necessary'.

makefile-browser-hook:
   A function or list of functions to be called just before the
   browser is entered. This is executed in the makefile buffer.

makefile-special-targets-list:
   List of special targets. You will be offered to complete
   on one of those in the minibuffer whenever you enter a "."
   at the beginning of a line in makefile-mode.
Fmake-command-summary
Make a summary of current key bindings in the buffer *Summary*.
Previous contents of that buffer are killed first.
Fmanual-entry
Get a Un*x manual page and put it in a buffer.
This command is the top-level command in the man package.  It runs a Un*x
command to retrieve and clean a manpage in the background and places the
results in a Man mode (manpage browsing) buffer.  See variable
`Man-notify' for what happens when the buffer is ready.
Universal argument ARG, is passed to `Man-getpage-in-background'.
Fmap-y-or-n-p
Ask a series of boolean questions.
Takes args PROMPTER ACTOR LIST, and optional args HELP and ACTION-ALIST.

LIST is a list of objects, or a function of no arguments to return the next
object or nil.

If PROMPTER is a string, the prompt is (format PROMPTER OBJECT).  If not
a string, PROMPTER is a function of one arg (an object from LIST), which
returns a string to be used as the prompt for that object.  If the return
value is not a string, it is eval'd to get the answer; it may be nil to
ignore the object, t to act on the object without asking the user, or a
form to do a more complex prompt.

ACTOR is a function of one arg (an object from LIST),
which gets called with each object that the user answers `yes' for.

If HELP is given, it is a list (OBJECT OBJECTS ACTION),
where OBJECT is a string giving the singular noun for an elt of LIST;
OBJECTS is the plural noun for elts of LIST, and ACTION is a transitive
verb describing ACTOR.  The default is ("object" "objects" "act on").

At the prompts, the user may enter y, Y, or SPC to act on that object;
n, N, or DEL to skip that object; ! to act on all following objects;
ESC or q to exit (skip all following objects); . (period) to act on the
current object and then exit; or \[help-command] to get help.

If ACTION-ALIST is given, it is an alist (KEY FUNCTION HELP) of extra keys
that will be accepted.  KEY is a character; FUNCTION is a function of one
arg (an object from LIST); HELP is a string.  When the user hits KEY,
FUNCTION is called.  If it returns non-nil, the object is considered
"acted upon", and the next object from LIST is processed.  If it returns
nil, the prompt is repeated for the same object.

This function uses `query-replace-map' to define the standard responses,
but not all of the responses which `query-replace' understands
are meaningful here.

Returns the number of actions taken.
Fmh-rmail
Inc(orporate) new mail (no arg) or scan a MH mail box (arg given).
This front end uses the MH mail system, which uses different conventions
from the usual mail system.
Fmh-smail
Compose and send mail with the MH mail system.
Fconvert-mocklisp-buffer
Convert buffer of Mocklisp code to real Lisp that GNU Emacs can run.
Fmodula-2-mode
This is a mode intended to support program development in Modula-2.
All control constructs of Modula-2 can be reached by typing C-c
followed by the first character of the construct.
\<m2-mode-map>
  \[m2-begin] begin         \[m2-case] case
  \[m2-definition] definition    \[m2-else] else
  \[m2-for] for           \[m2-header] header
  \[m2-if] if            \[m2-module] module
  \[m2-loop] loop          \[m2-or] or
  \[m2-procedure] procedure     Control-c Control-w with
  \[m2-record] record        \[m2-stdio] stdio
  \[m2-type] type          \[m2-until] until
  \[m2-var] var           \[m2-while] while
  \[m2-export] export        \[m2-import] import
  \[m2-begin-comment] begin-comment \[m2-end-comment] end-comment
  \[suspend-emacs] suspend Emacs     \[m2-toggle] toggle
  \[m2-compile] compile           \[m2-next-error] next-error
  \[m2-link] link

   `m2-indent' controls the number of spaces for each indentation.
   `m2-compile-command' holds the command to compile a Modula-2 program.
   `m2-link-command' holds the command to link a Modula-2 program.
Fmpuz
Multiplication puzzle with GNU Emacs.
Fenable-command
Allow COMMAND to be executed without special confirmation from now on.
The user's .emacs file is altered so that this will apply
to future sessions.
Fdisable-command
Require special confirmation to execute COMMAND from now on.
The user's .emacs file is altered so that this will apply
to future sessions.
Fnroff-mode
Major mode for editing text intended for nroff to format.
\{nroff-mode-map}
Turning on Nroff mode runs `text-mode-hook', then `nroff-mode-hook'.
Also, try `nroff-electric-mode', for automatically inserting
closing requests for requests that are used in matched pairs.
Flist-options
Display a list of Emacs user options, with values and documentation.
Fedit-options
Edit a list of Emacs user option values.
Selects a buffer containing such a list,
in which there are commands to set the option values.
Type \[describe-mode] in that buffer for a list of commands.
Foutline-mode
Set major mode for editing outlines with selective display.
Headings are lines which start with asterisks: one for major headings,
two for subheadings, etc.  Lines not starting with asterisks are body lines. 

Body text or subheadings under a heading can be made temporarily
invisible, or visible again.  Invisible lines are attached to the end 
of the heading, so they move with it, if the line is killed and yanked
back.  A heading with text hidden under it is marked with an ellipsis (...).

Commands:\<outline-mode-map>
\[outline-next-visible-heading]   outline-next-visible-heading      move by visible headings
\[outline-previous-visible-heading]   outline-previous-visible-heading
\[outline-forward-same-level]   outline-forward-same-level        similar but skip subheadings
\[outline-backward-same-level]   outline-backward-same-level
\[outline-up-heading]   outline-up-heading		    move from subheading to heading

M-x hide-body	make all text invisible (not headings).
M-x show-all	make everything in buffer visible.

The remaining commands are used when point is on a heading line.
They apply to some of the body or subheadings of that heading.
\[hide-subtree]   hide-subtree	make body and subheadings invisible.
\[show-subtree]   show-subtree	make body and subheadings visible.
\[show-children]   show-children	make direct subheadings visible.
		 No effect on body, or subheadings 2 or more levels down.
		 With arg N, affects subheadings N levels down.
M-x hide-entry	   make immediately following body invisible.
M-x show-entry	   make it visible.
M-x hide-leaves	   make body under heading and under its subheadings invisible.
		     The subheadings remain visible.
M-x show-branches  make all subheadings at all levels visible.

The variable `outline-regexp' can be changed to control what is a heading.
A line is a heading if `outline-regexp' matches something at the
beginning of the line.  The longer the match, the deeper the level.

Turning on outline mode calls the value of `text-mode-hook' and then of
`outline-mode-hook', if they are non-nil.
Foutline-minor-mode
Toggle Outline minor mode.
With arg, turn Outline minor mode on if arg is positive, off otherwise.
See the command `outline-mode' for more information on this mode.
Fpicture-mode
Switch to Picture mode, in which a quarter-plane screen model is used.
Printing characters replace instead of inserting themselves with motion
afterwards settable by these commands:
  C-c <	  Move left after insertion.
  C-c >	  Move right after insertion.
  C-c ^	  Move up after insertion.
  C-c .	  Move down after insertion.
  C-c `	  Move northwest (nw) after insertion.
  C-c '	  Move northeast (ne) after insertion.
  C-c /	  Move southwest (sw) after insertion.
  C-c \   Move southeast (se) after insertion.
The current direction is displayed in the mode line.  The initial
direction is right.  Whitespace is inserted and tabs are changed to
spaces when required by movement.  You can move around in the buffer
with these commands:
  \[picture-move-down]	  Move vertically to SAME column in previous line.
  \[picture-move-up]	  Move vertically to SAME column in next line.
  \[picture-end-of-line]	  Move to column following last non-whitespace character.
  \[picture-forward-column]	  Move right inserting spaces if required.
  \[picture-backward-column]	  Move left changing tabs to spaces if required.
  C-c C-f Move in direction of current picture motion.
  C-c C-b Move in opposite direction of current picture motion.
  Return  Move to beginning of next line.
You can edit tabular text with these commands:
  M-Tab	  Move to column beneath (or at) next interesting character.
	    `Indents' relative to a previous line.
  Tab	  Move to next stop in tab stop list.
  C-c Tab Set tab stops according to context of this line.
	    With ARG resets tab stops to default (global) value.
	    See also documentation of variable	picture-tab-chars
	    which defines "interesting character".  You can manually
	    change the tab stop list with command \[edit-tab-stops].
You can manipulate text with these commands:
  C-d	  Clear (replace) ARG columns after point without moving.
  C-c C-d Delete char at point - the command normally assigned to C-d.
  \[picture-backward-clear-column]  Clear (replace) ARG columns before point, moving back over them.
  \[picture-clear-line]	  Clear ARG lines, advancing over them.	 The cleared
	    text is saved in the kill ring.
  \[picture-open-line]	  Open blank line(s) beneath current line.
You can manipulate rectangles with these commands:
  C-c C-k Clear (or kill) a rectangle and save it.
  C-c C-w Like C-c C-k except rectangle is saved in named register.
  C-c C-y Overlay (or insert) currently saved rectangle at point.
  C-c C-x Like C-c C-y except rectangle is taken from named register.
  \[copy-rectangle-to-register]   Copies a rectangle to a register.
  \[advertised-undo]   Can undo effects of rectangle overlay commands
	    commands if invoked soon enough.
You can return to the previous mode with:
  C-c C-c Which also strips trailing whitespace from every line.
	    Stripping is suppressed by supplying an argument.

Entry to this mode calls the value of  picture-mode-hook  if non-nil.

Note that Picture mode commands will work outside of Picture mode, but
they are not defaultly assigned to keys.
Fprolog-mode
Major mode for editing Prolog code for Prologs.
Blank lines and `%%...' separate paragraphs.  `%'s start comments.
Commands:
\{prolog-mode-map}
Entry to this mode calls the value of `prolog-mode-hook'
if that value is non-nil.
Frun-prolog
Run an inferior Prolog process, input and output via buffer *prolog*.
Fdelete-rectangle
Delete (don't save) text in rectangle with point and mark as corners.
The same range of columns is deleted in each line starting with the line
where the region begins and ending with the line where the region ends.
Fdelete-extract-rectangle
Delete contents of rectangle and return it as a list of strings.
Arguments START and END are the corners of the rectangle.
The value is list of strings, one for each line of the rectangle.
Fextract-rectangle
Return contents of rectangle with corners at START and END.
Value is list of strings, one for each line of the rectangle.
Fkill-rectangle
Delete rectangle with corners at point and mark; save as last killed one.
Calling from program, supply two args START and END, buffer positions.
But in programs you might prefer to use `delete-extract-rectangle'.
Fyank-rectangle
Yank the last killed rectangle with upper left corner at point.
Finsert-rectangle
Insert text of RECTANGLE with upper left corner at point.
RECTANGLE's first line is inserted at point, its second
line is inserted at a point vertically under point, etc.
RECTANGLE should be a list of strings.
After this command, the mark is at the upper left corner
and point is at the lower right corner.
Fopen-rectangle
Blank out rectangle with corners at point and mark, shifting text right.
The text previously in the region is not overwritten by the blanks,
but instead winds up to the right of the rectangle.
Fstring-rectangle
Insert STRING on each line of the region-rectangle, shifting text right.
The left edge of the rectangle specifies the column for insertion.
This command does not delete or overwrite any existing text.

Called from a program, takes three args; START, END and STRING.
Fclear-rectangle
Blank out rectangle with corners at point and mark.
The text previously in the region is overwritten by the blanks.
When called from a program, requires two args which specify the corners.
Freposition-window
Make the current definition and/or comment visible.
Further invocations move it to the top of the window or toggle the
visibility of comments that precede it.
  Point is left unchanged unless prefix ARG is supplied.
  If the definition is fully onscreen, it is moved to the top of the
window.  If it is partly offscreen, the window is scrolled to get the
definition (or as much as will fit) onscreen, unless point is in a comment
which is also partly offscreen, in which case the scrolling attempts to get
as much of the comment onscreen as possible.
  Initially `reposition-window' attempts to make both the definition and
preceding comments visible.  Further invocations toggle the visibility of
the comment lines.
  If ARG is non-nil, point may move in order to make the whole defun
visible (if only part could otherwise be made so), to make the defun line
visible (if point is in code and it could not be made so, or if only
comments, including the first comment line, are visible), or to make the
first comment line visible (if point is in a comment).
Fresume-suspend-hook
Clear out the file used for transmitting args when Emacs resumes.
Fring-p
Returns t if X is a ring; nil otherwise.
Fmake-ring
Make a ring that can contain SIZE elements.
Vrlogin-program
*Name of program to invoke rlogin
Vrlogin-explicit-args
*List of arguments to pass to rlogin on the command line.
Vrlogin-mode-hook
*Hooks to run after setting current buffer to rlogin-mode.
Vrlogin-process-connection-type
*If non-`nil', use a pty for the local rlogin process.  
If `nil', use a pipe (if pipes are supported on the local system).  

Generally it is better not to waste ptys on systems which have a static
number of them.  On the other hand, some implementations of `rlogin' assume
a pty is being used, and errors will result from using a pipe instead.
Vrlogin-password-paranoia
*If non-`nil', query user for a password in the minibuffer when a Password: prompt appears.
It's also possible to selectively enter passwords without echoing them in
the minibuffer using the command `rlogin-password' explicitly.
Frlogin
Open a network login connection to HOST via the `rlogin' program.
Input is sent line-at-a-time to the remote connection.

Communication with HOST is recorded in a buffer *rlogin-HOST*.
If a prefix argument is given and the buffer *rlogin-HOST* already exists,
a new buffer with a different connection will be made. 

The variable `rlogin-program' contains the name of the actual program to
run.  It can be a relative or absolute path. 

The variable `rlogin-explicit-args' is a list of arguments to give to
the rlogin when starting.
Frlogin-with-args
Open a new rlogin connection to HOST, even if one already exists. 
String ARGS is given as arguments to the `rlogin' program, overriding the
value of `rlogin-explicit-args'.
Frlogin-password
Read a password and send it to an rlogin session.
For each character typed, a `*' is echoed in the minibuffer.
End with RET, LFD, or ESC.  DEL or C-h rubs out.  C-u kills line.
C-g aborts attempt to read and send password. 

Optional argument PROC is the process to which the password should be sent.
If not provided, send to the process in the current buffer.  This argument
is intended primarily for use by `rlogin-filter'.
Frlogin-mode
Set major-mode for rlogin sessions. 
If `rlogin-mode-hook' is set, run it.
Frlogin-delchar-or-send-Ctrl-D
Delete ARG characters forward, or send a C-d to process if at end of
buffer.
Vrmail-dont-reply-to-names
*A regexp specifying names to prune of reply to messages.
A value of nil means exclude your own name only.
Vrmail-default-dont-reply-to-names
A regular expression specifying part of the value of the default value of
the variable `rmail-dont-reply-to-names', for when the user does not set
`rmail-dont-reply-to-names' explicitly.  (The other part of the default
value is the user's name.)
It is useful to set this variable in the site customization file.
Vrmail-ignored-headers
*Gubbish headers one would rather not see.
Vrmail-delete-after-output
*Non-nil means automatically delete a message that is copied to a file.
Vrmail-primary-inbox-list
*List of files which are inboxes for user's primary mail file `~/RMAIL'.
`nil' means the default, which is ("/usr/spool/mail/$USER")
(the name varies depending on the operating system,
and the value of the environment variable MAIL overrides it).
Vrmail-mail-new-frame
*Non-nil means Rmail makes a new frame for composing outgoing mail.
Frmail
Read and edit incoming mail.
Moves messages into file named by  rmail-file-name  (a babyl format file)
 and edits that file in RMAIL Mode.
Type \[describe-mode] once editing that file, for a list of RMAIL commands.

May be called with filename as argument; then performs rmail editing on
that file, but does not copy any new mail into the file.
Frmail-mode
Rmail Mode is used by \<rmail-mode-map>\[rmail] for editing Rmail files.
All normal editing commands are turned off.
Instead, these commands are available:

\[rmail-beginning-of-message]	Move point to front of this message (same as \[beginning-of-buffer]).
\[scroll-up]	Scroll to next screen of this message.
\[scroll-down]	Scroll to previous screen of this message.
\[rmail-next-undeleted-message]	Move to Next non-deleted message.
\[rmail-previous-undeleted-message]	Move to Previous non-deleted message.
\[rmail-next-message]	Move to Next message whether deleted or not.
\[rmail-previous-message]	Move to Previous message whether deleted or not.
\[rmail-first-message]	Move to the first message in Rmail file.
\[rmail-last-message]	Move to the last message in Rmail file.
\[rmail-show-message]	Jump to message specified by numeric position in file.
\[rmail-search]	Search for string and show message it is found in.
\[rmail-delete-forward]	Delete this message, move to next nondeleted.
\[rmail-delete-backward]	Delete this message, move to previous nondeleted.
\[rmail-undelete-previous-message]	Undelete message.  Tries current message, then earlier messages
	till a deleted message is found.
\[rmail-edit-current-message]	Edit the current message.  \[rmail-cease-edit] to return to Rmail.
\[rmail-expunge]	Expunge deleted messages.
\[rmail-expunge-and-save]	Expunge and save the file.
\[rmail-quit]       Quit Rmail: expunge, save, then switch to another buffer.
\[save-buffer] Save without expunging.
\[rmail-get-new-mail]	Move new mail from system spool directory into this file.
\[rmail-mail]	Mail a message (same as \[mail-other-window]).
\[rmail-continue]	Continue composing outgoing message started before.
\[rmail-reply]	Reply to this message.  Like \[rmail-mail] but initializes some fields.
\[rmail-retry-failure]	Send this message again.  Used on a mailer failure message.
\[rmail-forward]	Forward this message to another user.
\[rmail-output-to-rmail-file]       Output this message to an Rmail file (append it).
\[rmail-output]	Output this message to a Unix-format mail file (append it).
\[rmail-input]	Input Rmail file.  Run Rmail on that file.
\[rmail-add-label]	Add label to message.  It will be displayed in the mode line.
\[rmail-kill-label]	Kill label.  Remove a label from current message.
\[rmail-next-labeled-message]   Move to Next message with specified label
          (label defaults to last one specified).
          Standard labels: filed, unseen, answered, forwarded, deleted.
          Any other label is present only if you add it with \[rmail-add-label].
\[rmail-previous-labeled-message]   Move to Previous message with specified label
\[rmail-summary]	Show headers buffer, with a one line summary of each message.
\[rmail-summary-by-labels]	Summarize only messages with particular label(s).
\[rmail-summary-by-recipients]   Summarize only messages with particular recipient(s).
\[rmail-summary-by-regexp]   Summarize only messages with particular regexp(s).
\[rmail-summary-by-topic]   Summarize only messages with subject line regexp(s).
\[rmail-toggle-header]	Toggle display of complete header.
Frmail-input
Run Rmail on file FILENAME.
Frot13-other-window
Display current buffer in rot 13 in another window.
Fsc-cite-original
Hook version of sc-cite.
This is callable from the various mail and news readers' reply
function according to the agreed upon standard. See \[sc-describe]
for more details.  Sc-cite-original does not do any yanking of the
original message but it does require a few things:

     1) The reply buffer is the current buffer.

     2) The original message has been yanked and inserted into the
        reply buffer.

     3) Verbose mail headers from the original message have been
        inserted into the reply buffer directly before the text of the
        original message.

     4) Point is at the beginning of the verbose headers.

     5) Mark is at the end of the body of text to be cited.
Fscheme-mode
Major mode for editing Scheme code.
Editing commands are similar to those of lisp-mode.

In addition, if an inferior Scheme process is running, some additional
commands will be defined, for evaluating expressions and controlling
the interpreter, and the state of the process will be displayed in the
modeline of all Scheme buffers.  The names of commands that interact
with the Scheme process start with "xscheme-".  For more information
see the documentation for xscheme-interaction-mode.

Commands:
Delete converts tabs to spaces as it moves back.
Blank lines separate paragraphs.  Semicolons start comments.
\{scheme-mode-map}
Entry to this mode calls the value of scheme-mode-hook
if that value is non-nil.
Fscribe-mode
Major mode for editing files of Scribe (a text formatter) source.
Scribe-mode is similar text-mode, with a few extra commands added.
\{scribe-mode-map}

Interesting variables:

scribe-fancy-paragraphs
  Non-nil makes Scribe mode use a different style of paragraph separation.

scribe-electric-quote
  Non-nil makes insert of double quote use `` or '' depending on context.

scribe-electric-parenthesis
  Non-nil makes an open-parenthesis char (one of `([<{')
  automatically insert its close if typed after an @Command form.
Vmail-self-blind
Non-nil means insert BCC to self in messages to be sent.
This is done when the message is initialized,
so you can remove or alter the BCC field to override the default.
Vmail-interactive
Non-nil means when sending a message wait for and display errors.
nil means let mailer mail back a message to report errors.
Vmail-yank-ignored-headers
Delete these headers from old message when it's inserted in a reply.
Vsend-mail-function
Function to call to send the current buffer as mail.
The headers are be delimited by a line which is `mail-header-separator'.
Vmail-header-separator
*Line used to separate headers from text in messages being composed.
Vmail-archive-file-name
*Name of file to write all outgoing messages in, or nil for none.
Do not use an rmail file here!  Instead, use its inbox file.
Vmail-signature
*Text inserted at end of mail buffer when a message is initialized.
If t, it means to insert the contents of the file `~/.signature'.
Fmail-mode
Major mode for editing mail to be sent.
Like Text Mode but with these additional commands:
C-c C-s  mail-send (send the message)    C-c C-c  mail-send-and-exit
C-c C-f  move to a header field (and create it if there isn't):
	 C-c C-f C-t  move to To:	C-c C-f C-s  move to Subj:
	 C-c C-f C-b  move to BCC:	C-c C-f C-c  move to CC:
C-c C-t  move to message text.
C-c C-y  mail-yank-original (insert current message, in Rmail).
C-c C-q  mail-fill-yanked-message (fill what was yanked).
C-c C-v  mail-sent-via (add a sent-via field for each To or CC).
Fmail
Edit a message to be sent.  Prefix arg means resume editing (don't erase).
When this function returns, the buffer `*mail*' is selected.
The value is t if the message was newly initialized; otherwise, nil.

By default, the signature file `~/.signature' is inserted at the end;
see the variable `mail-signature'.

\<mail-mode-map>
While editing message, type \[mail-send-and-exit] to send the message and exit.

Various special commands starting with C-c are available in sendmail mode
to move to message header fields:
\{mail-mode-map}

If `mail-self-blind' is non-nil, a BCC to yourself is inserted
when the message is initialized.

If `mail-default-reply-to' is non-nil, it should be an address (a string);
a Reply-to: field with that address is inserted.

If `mail-archive-file-name' is non-nil, an FCC field with that file name
is inserted.

If `mail-setup-hook' is bound, its value is called with no arguments
after the message is initialized.  It can add more default fields.

When calling from a program, the second through fifth arguments
 TO, SUBJECT, IN-REPLY-TO and CC specify if non-nil
 the initial contents of those header fields.
 These arguments should not have final newlines.
The sixth argument REPLYBUFFER is a buffer whose contents
 should be yanked if the user types C-c C-y.
The seventh argument ACTIONS is a list of actions to take
 if/when the message is sent.  Each action looks like (FUNCTION . ARGS);
 when the message is sent, we apply FUNCTION to ARGS.
 This is how Rmail arranges to mark messages `answered'.
Fmail-other-window
Like `mail' command, but display mail buffer in another window.
Fmail-other-frame
Like `mail' command, but display mail buffer in another frame.
Fserver-start
Allow this Emacs process to be a server for client processes.
This starts a server communications subprocess through which
client "editors" can send your editing commands to this Emacs job.
To use the server, set up the program `etc/emacsclient' in the
Emacs distribution as your standard "editor".

Prefix arg means just kill any existing server communications subprocess.
Fsgml-mode
Major mode for editing SGML.
Makes > display the matching <.  Makes / display matching /.
Use \[sgml-validate] to validate your document with an SGML parser.
Fshell
Run an inferior shell, with I/O through buffer *shell*.
If buffer exists but shell process is not running, make new shell.
If buffer exists and shell process is running, 
 just switch to buffer `*shell*'.
Program used comes from variable `explicit-shell-file-name',
 or (if that is nil) from the ESHELL environment variable,
 or else from SHELL if there is no ESHELL.
If a file `~/.emacs_SHELLNAME' exists, it is given as initial input
 (Note that this may lose due to a timing error if the shell
  discards input when it starts up.)
The buffer is put in Shell mode, giving commands for sending input
and controlling the subjobs of the shell.  See `shell-mode'.
See also the variable `shell-prompt-pattern'.

The shell file name (sans directories) is used to make a symbol name
such as `explicit-csh-args'.  If that symbol is a variable,
its value is used as a list of arguments when invoking the shell.
Otherwise, one argument `-i' is passed to the shell.

(Type \[describe-mode] in the shell buffer for a list of commands.)
Vcalendar-time-display-form
*The pseudo-pattern that governs the way a time of day is formatted.

A pseudo-pattern is a list of expressions that can involve the keywords
`12-hours', `24-hours', and `minutes',  all numbers in string form,
and `am-pm' and `time-zone',  both alphabetic strings.

For example, the form

  '(24-hours ":" minutes
    (if time-zone " (") time-zone (if time-zone ")"))

would give military-style times like `21:07 (UTC)'.
Vcalendar-latitude
*Latitude of `calendar-location-name' in degrees, + north, - south.
For example, 40.7 for New York City.
It may not be a good idea to set this in advance for your site;
if there may be users running Emacs at your site
who are physically located elsewhere, they would get the wrong
value and might not know how to override it.
Vcalendar-longitude
*Longitude of `calendar-location-name' in degrees, + east, - west.
For example, -74.0 for New York City.
It may not be a good idea to set this in advance for your site;
if there may be users running Emacs at your site
who are physically located elsewhere, they would get the wrong
value and might not know how to override it.
Vcalendar-location-name
*Expression evaluating to name of `calendar-longitude', calendar-latitude'.
Default value is just the latitude, longitude pair.
Fsunrise-sunset
Local time of sunrise and sunset for today.  Accurate to +/- 2 minutes.
If called with an optional prefix argument, prompts for date.

If called with an optional double prefix argument, prompts for longitude,
latitude, time zone, and date.

This function is suitable for execution in a .emacs file.
Fsort-lines
Sort lines in region alphabetically; argument means descending order.
Called from a program, there are three arguments:
REVERSE (non-nil means reverse order), BEG and END (region to sort).
Fsort-paragraphs
Sort paragraphs in region alphabetically; argument means descending order.
Called from a program, there are three arguments:
REVERSE (non-nil means reverse order), BEG and END (region to sort).
Fsort-pages
Sort pages in region alphabetically; argument means descending order.
Called from a program, there are three arguments:
REVERSE (non-nil means reverse order), BEG and END (region to sort).
Fsort-numeric-fields
Sort lines in region numerically by the ARGth field of each line.
Fields are separated by whitespace and numbered from 1 up.
Specified field must contain a number in each line of the region.
With a negative arg, sorts by the ARGth field counted from the right.
Called from a program, there are three arguments:
FIELD, BEG and END.  BEG and END specify region to sort.
If you want to sort floating-point numbers, try `sort-float-fields'.
Fsort-float-fields
Sort lines in region numerically by the ARGth field of each line.
Fields are separated by whitespace and numbered from 1 up.  Specified field
must contain a floating point number in each line of the region.  With a
negative arg, sorts by the ARGth field counted from the right.  Called from a
program, there are three arguments: FIELD, BEG and END.  BEG and END specify
region to sort.
Fsort-fields
Sort lines in region lexicographically by the ARGth field of each line.
Fields are separated by whitespace and numbered from 1 up.
With a negative arg, sorts by the ARGth field counted from the right.
Called from a program, there are three arguments:
FIELD, BEG and END.  BEG and END specify region to sort.
Fsort-regexp-fields
Sort the region lexicographically as specified by RECORD-REGEXP and KEY.
RECORD-REGEXP specifies the textual units which should be sorted.
  For example, to sort lines RECORD-REGEXP would be "^.*$"
KEY specifies the part of each record (ie each match for RECORD-REGEXP)
  is to be used for sorting.
  If it is "\digit" then the digit'th "\(...\)" match field from
  RECORD-REGEXP is used.
  If it is "\&" then the whole record is used.
  Otherwise, it is a regular-expression for which to search within the record.
If a match for KEY is not found within a record then that record is ignored.

With a negative prefix arg sorts in reverse order.

For example: to sort lines in the region by the first word on each line
 starting with the letter "f",
 RECORD-REGEXP would be "^.*$" and KEY would be "\=\<f\w*\>"
Fsort-columns
Sort lines in region alphabetically by a certain range of columns.
For the purpose of this command, the region includes
the entire line that point is in and the entire line the mark is in.
The column positions of point and mark bound the range of columns to sort on.
A prefix argument means sort into reverse order.

Note that `sort-columns' rejects text that contains tabs,
because tabs could be split across the specified columns
and it doesn't know how to handle that.  Also, when possible,
it uses the `sort' utility program, which doesn't understand tabs.
Use \[untabify] to convert tabs to spaces before sorting.
Freverse-region
Reverse the order of lines in a region.
From a program takes two point or marker arguments, BEG and END.
Fspell-buffer
Check spelling of every word in the buffer.
For each incorrect word, you are asked for the correct spelling
and then put into a query-replace to fix some or all occurrences.
If you do not want to change a word, just give the same word
as its "correct" spelling; then the query replace is skipped.
Fspell-word
Check spelling of word at or before point.
If it is not correct, ask user for the correct spelling
and `query-replace' the entire buffer to substitute it.
Fspell-region
Like `spell-buffer' but applies only to region.
Used in a program, applies from START to END.
DESCRIPTION is an optional string naming the unit being checked:
for example, "word".
Fspell-string
Check spelling of string supplied as argument.
Fspook
Adds that special touch of class to your outgoing mail.
Fsnarf-spooks
Return a vector containing the lines from `spook-phrases-file'.
Funtabify
Convert all tabs in region to multiple spaces, preserving columns.
Called non-interactively, the region is specified by arguments
START and END, rather than by the position of point and mark.
The variable `tab-width' controls the spacing of tab stops.
Ftabify
Convert multiple spaces in region to tabs when possible.
A group of spaces is partially replaced by tabs
when this can be done without changing the column they end at.
Called non-interactively, the region is specified by arguments
START and END, rather than by the position of point and mark.
The variable `tab-width' controls the spacing of tab stops.
Ftar-mode
Major mode for viewing a tar file as a dired-like listing of its contents.
You can move around using the usual cursor motion commands. 
Letters no longer insert themselves.
Type 'e' to pull a file out of the tar file and into its own buffer.
Type 'c' to copy an entry from the tar file into another file on disk.

If you edit a sub-file of this archive (as with the 'e' command) and 
save it with Control-X Control-S, the contents of that buffer will be 
saved back into the tar-file buffer; in this way you can edit a file 
inside of a tar archive without extracting it and re-archiving it.

See also: variables tar-update-datestamp and tar-anal-blocksize.
\{tar-mode-map}
Ftelnet
Open a network login connection to host named HOST (a string).
Communication with HOST is recorded in a buffer *HOST-telnet*.
Normally input is edited in Emacs and sent a line at a time.
Frsh
Open a network login connection to host named HOST (a string).
Communication with HOST is recorded in a buffer *HOST-rsh*.
Normally input is edited in Emacs and sent a line at a time.
Fterminal-emulator
Under a display-terminal emulator in BUFFER, run PROGRAM on arguments ARGS.
ARGS is a list of argument-strings.  Remaining arguments are WIDTH and HEIGHT.
BUFFER's contents are made an image of the display generated by that program,
and any input typed when BUFFER is the current Emacs buffer is sent to that
program an keyboard input.

Interactively, BUFFER defaults to "*terminal*" and PROGRAM and ARGS
are parsed from an input-string using your usual shell.
WIDTH and HEIGHT are determined from the size of the current window
-- WIDTH will be one less than the window's width, HEIGHT will be its height.

To switch buffers and leave the emulator, or to give commands
to the emulator itself (as opposed to the program running under it),
type Control-^.  The following character is an emulator command.
Type Control-^ twice to send it to the subprogram.
This escape character may be changed using the variable `terminal-escape-char'.

`Meta' characters may not currently be sent through the terminal emulator.

Here is a list of some of the variables which control the behaviour
of the emulator -- see their documentation for more information:
terminal-escape-char, terminal-scrolling, terminal-more-processing,
terminal-redisplay-interval.

This function calls the value of terminal-mode-hook if that exists
and is non-nil after the terminal buffer has been set up and the
subprocess started.

Presently with `termcap' only; if somebody sends us code to make this
work with `terminfo' we will try to use it.
Vtex-shell-file-name
*If non-nil, is file name to use for the subshell in which TeX is run.
Vtex-directory
*Directory in which temporary files are left.
You can make this /tmp if your TEXINPUTS has no relative directories in it
and you don't try to apply \[tex-region] or \[tex-buffer] when there are
\input commands with relative directories.
Vtex-offer-save
*If non-nil, ask about saving modified buffers before \[tex-file] is run.
Vtex-run-command
*Command used to run TeX subjob.
If this string contains an asterisk (*), it will be replaced by the
filename; if not, the name of the file, preceded by blank, will be added to
this string.
Vlatex-run-command
*Command used to run LaTeX subjob.
If this string contains an asterisk (*), it will be replaced by the
filename; if not, the name of the file, preceded by blank, will be added to
this string.
Vlatex-block-names
*User defined LaTeX block names.
Combined with `standard-latex-block-names' for minibuffer completion.
Vslitex-run-command
*Command used to run SliTeX subjob.
If this string contains an asterisk (*), it will be replaced by the
filename; if not, the name of the file, preceded by blank, will be added to
this string.
Vtex-bibtex-command
*Command used by `tex-bibtex-file' to gather bibliographic data.
If this string contains an asterisk (*), it will be replaced by the
filename; if not, the name of the file, preceded by blank, will be added to
this string.
Vtex-dvi-print-command
*Command used by \[tex-print] to print a .dvi file.
If this string contains an asterisk (*), it will be replaced by the
filename; if not, the name of the file, preceded by blank, will be added to
this string.
Vtex-alt-dvi-print-command
*Command used by \[tex-print] with a prefix arg to print a .dvi file.
If this string contains an asterisk (*), it will be replaced by the
filename; if not, the name of the file, preceded by blank, will be added to
this string.

If two printers are not enough of a choice, you can define the value
of tex-alt-dvi-print-command to be an expression that asks what you want;
for example,

    (setq tex-alt-dvi-print-command
         '(format "lpr -P%s" (read-string "Use printer: ")))

would tell \[tex-print] with a prefix argument to ask you which printer to
use.
Vtex-dvi-view-command
*Command used by \[tex-view] to display a .dvi file.
If this string contains an asterisk (*), it will be replaced by the
filename; if not, the name of the file, preceded by blank, will be added to
this string.

This can be set conditionally so that the previewer used is suitable for the
window system being used.  For example,

    (setq tex-dvi-view-command
          (if (eq window-system 'x) "xdvi" "dvi2tty * | cat -s"))

would tell \[tex-view] use xdvi under X windows and to use dvi2tty
otherwise.
Vtex-show-queue-command
*Command used by \[tex-show-print-queue] to show the print queue.
Should show the queue(s) that \[tex-print] puts jobs on.
Vtex-default-mode
*Mode to enter for a new file that might be either TeX or LaTeX.
This variable is used when it can't be determined whether the file
is plain TeX or LaTeX or what because the file contains no commands.
Normally set to either 'plain-tex-mode or 'latex-mode.
Vtex-open-quote
*String inserted by typing \[tex-insert-quote] to open a quotation.
Vtex-close-quote
*String inserted by typing \[tex-insert-quote] to close a quotation.
Ftex-mode
Major mode for editing files of input for TeX, LaTeX, or SliTeX.
Tries to determine (by looking at the beginning of the file) whether
this file is for plain TeX, LaTeX, or SliTeX and calls plain-tex-mode,
latex-mode, or slitex-mode, respectively.  If it cannot be determined,
such as if there are no commands in the file, the value of tex-default-mode
is used.
Fplain-tex-mode
Major mode for editing files of input for plain TeX.
Makes $ and } display the characters they match.
Makes " insert `` when it seems to be the beginning of a quotation,
and '' when it appears to be the end; it inserts " only after a \.

Use \[tex-region] to run TeX on the current region, plus a "header"
copied from the top of the file (containing macro definitions, etc.),
running TeX under a special subshell.  \[tex-buffer] does the whole buffer.
\[tex-file] saves the buffer and then processes the file.
\[tex-print] prints the .dvi file made by any of these.
\[tex-view] previews the .dvi file made by any of these.
\[tex-bibtex-file] runs bibtex on the file of the current buffer.

Use \[validate-tex-buffer] to check buffer for paragraphs containing
mismatched $'s or braces.

Special commands:
\{tex-mode-map}

Mode variables:
tex-run-command
	Command string used by \[tex-region] or \[tex-buffer].
tex-directory
	Directory in which to create temporary files for TeX jobs
	run by \[tex-region] or \[tex-buffer].
tex-dvi-print-command
	Command string used by \[tex-print] to print a .dvi file.
tex-alt-dvi-print-command
	Alternative command string used by \[tex-print] (when given a prefix
	argument) to print a .dvi file.
tex-dvi-view-command
	Command string used by \[tex-view] to preview a .dvi file.
tex-show-queue-command
	Command string used by \[tex-show-print-queue] to show the print
	queue that \[tex-print] put your job on.

Entering Plain-tex mode calls the value of `text-mode-hook', then the value
of `tex-mode-hook', and then the value of `plain-tex-mode-hook'.  When the
special subshell is initiated, the value of `tex-shell-hook' is called.
Flatex-mode
Major mode for editing files of input for LaTeX.
Makes $ and } display the characters they match.
Makes " insert `` when it seems to be the beginning of a quotation,
and '' when it appears to be the end; it inserts " only after a \.

Use \[tex-region] to run LaTeX on the current region, plus the preamble
copied from the top of the file (containing \documentstyle, etc.),
running LaTeX under a special subshell.  \[tex-buffer] does the whole buffer.
\[tex-file] saves the buffer and then processes the file.
\[tex-print] prints the .dvi file made by any of these.
\[tex-view] previews the .dvi file made by any of these.
\[tex-bibtex-file] runs bibtex on the file of the current buffer.

Use \[validate-tex-buffer] to check buffer for paragraphs containing
mismatched $'s or braces.

Special commands:
\{tex-mode-map}

Mode variables:
latex-run-command
	Command string used by \[tex-region] or \[tex-buffer].
tex-directory
	Directory in which to create temporary files for LaTeX jobs
	run by \[tex-region] or \[tex-buffer].
tex-dvi-print-command
	Command string used by \[tex-print] to print a .dvi file.
tex-alt-dvi-print-command
	Alternative command string used by \[tex-print] (when given a prefix
	argument) to print a .dvi file.
tex-dvi-view-command
	Command string used by \[tex-view] to preview a .dvi file.
tex-show-queue-command
	Command string used by \[tex-show-print-queue] to show the print
	queue that \[tex-print] put your job on.

Entering Latex mode calls the value of text-mode-hook, then the value of
tex-mode-hook, and then the value of latex-mode-hook.  When the special
subshell is initiated, the value of tex-shell-hook is called.
Ftexinfo-mode
Major mode for editing Texinfo files.

  It has these extra commands:
\{texinfo-mode-map}

  These are files that are used as input for TeX to make printed manuals
and also to be turned into Info files with \[makeinfo-buffer] or
the `makeinfo' program.  These files must be written in a very restricted and
modified version of TeX input format.

  Editing commands are like text-mode except that the syntax table is
set up so expression commands skip Texinfo bracket groups.  To see
what the Info version of a region of the Texinfo file will look like,
use \[makeinfo-region], which runs `makeinfo' on the current region.

  You can show the structure of a Texinfo file with \[texinfo-show-structure].
This command shows the structure of a Texinfo file by listing the
lines with the @-sign commands for @chapter, @section, and the like.
These lines are displayed in another window called the *Occur* window.
In that window, you can position the cursor over one of the lines and
use \[occur-mode-goto-occurrence], to jump to the corresponding spot
in the Texinfo file.

  In addition, Texinfo mode provides commands that insert various
frequently used @-sign commands into the buffer.  You can use these
commands to save keystrokes.  And you can insert balanced braces with
\[texinfo-insert-braces] and later use the command \[up-list] to
move forward past the closing brace.

Also, Texinfo mode provides functions for automatically creating or
updating menus and node pointers.  These functions

  * insert the `Next', `Previous' and `Up' pointers of a node,
  * insert or update the menu for a section, and
  * create a master menu for a Texinfo source file.

Here are the functions:

    texinfo-update-node                \[texinfo-update-node]
    texinfo-every-node-update          \[texinfo-every-node-update]
    texinfo-sequential-node-update 

    texinfo-make-menu                  \[texinfo-make-menu]
    texinfo-all-menus-update           \[texinfo-all-menus-update]
    texinfo-master-menu

    texinfo-indent-menu-description (column &optional region-p)

The `texinfo-column-for-description' variable specifies the column to
which menu descriptions are indented. 

Passed an argument (a prefix argument, if interactive), the
`texinfo-update-node' and `texinfo-make-menu' functions do their jobs
in the region.

To use the updating commands, you must structure your Texinfo file
hierarchically, such that each `@node' line, with the exception of the
Top node, is accompanied by some kind of section line, such as an
`@chapter' or `@section' line.

If the file has a `top' node, it must be called `top' or `Top' and
be the first node in the file.

Entering Texinfo mode calls the value of text-mode-hook, and then the
value of texinfo-mode-hook.
Vdisplay-time-day-and-date
*Non-nil means \[display-time] should display day and date as well as time.
Fdisplay-time
Display current time, load level, and mail flag in mode line of each buffer.
Updates automatically every minute.
If `display-time-day-and-date' is non-nil, the current day and date
are displayed as well.
After each update, `display-time-hook' is run with `run-hooks'.
Frun-at-time
Run a function at a time, and optionally on a regular interval.
Arguments are TIME, REPEAT, FUNCTION &rest ARGS.
TIME, a string, can be specified absolutely or relative to now.
TIME can also be an integer, a number of seconds.
REPEAT, an integer number of seconds, is the interval on which to repeat
the call to the function.  If REPEAT is nil, call it just once.

Absolute times may be specified in a wide variety of formats;
Something of the form `HOUR:MIN:SEC TIMEZONE MONTH/DAY/YEAR', where
all fields are numbers, works; the format used by the Unix `date'
command works too.

Relative times may be specified as a series of numbers followed by units:
  1 min         	denotes one minute from now.
  min			does too.
  1 min 5 sec		denotes 65 seconds from now.
  1 min 2 sec 3 hour 4 day 5 week 6 fortnight 7 month 8 year
			denotes the sum of all the given durations from now.
Ftq-create
Create and return a transaction queue communicating with PROCESS.
PROCESS should be a subprocess capable of sending and receiving
streams of bytes.  It may be a local process, or it may be connected
to a tcp server on another machine.
Vtrace-buffer
*Trace output will by default go to that buffer.
Ftrace-function
Traces FUNCTION with trace output going to BUFFER.
For every call of FUNCTION Lisp-style trace messages that display argument
and return values will be inserted into BUFFER. This function generates the
trace advice for FUNCTION and activates it together with any other advice
there might be!! The trace BUFFER will popup whenever FUNCTION is called.
Do not use this to trace functions that switch buffers or do any other
display oriented stuff, use `trace-function-background' instead.
Ftrace-function-background
Traces FUNCTION with trace output going quietly to BUFFER.
For every call of FUNCTION Lisp-style trace messages that display argument
and return values will be inserted into BUFFER. This function generates the
trace advice for FUNCTION and activates it together with any other advice
there might be!! Trace output will quietly go to BUFFER without changing
the window or buffer configuration at all.
Vtc-mode-map
Keymap for commands for two-column mode.
Ftc-two-columns
Split current window vertically for two-column editing.

When called the first time, associates a buffer with the current
buffer.  Both buffers are put in two-column minor mode and
tc-mode-hook gets called on both.  These buffers remember
about one another, even when renamed.

When called again, restores the screen layout with the current buffer
first and the associated buffer to it's right.

If you include long lines, i.e which will span both columns (eg.
source code), they should be in what will be the first column, with
the associated buffer having empty lines next to them.

You have the following commands at your disposal:

\[tc-two-columns]   Rearrange screen
\[tc-associate-buffer]   Reassociate buffer after changing major mode
\[tc-scroll-up]   Scroll both buffers up by a screenfull
\[tc-scroll-down]   Scroll both buffers down by a screenful
\[tc-scroll-line]   Scroll both buffers up by one or more lines
\[tc-recenter]   Recenter and realign other buffer
\[shrink-window-horizontally], \[enlarge-window-horizontally]   Shrink, enlarge current column
\[tc-associated-buffer]   Switch to associated buffer
\[tc-merge]   Merge both buffers

These keybindings can be customized in your ~/.emacs by `tc-prefix'
and `tc-mode-map'.

The appearance of the screen can be customized by the variables
`tc-window-width', `tc-beyond-fill-column',
`tc-mode-line-format' and `truncate-partial-width-windows'.
Ftc-associate-buffer
Associate another buffer with this one in two-column minor mode.
Can also be used to associate a just previously visited file, by
accepting the proposed default buffer.

See  \[tc-two-columns]  and  `lisp/two-column.el'  for further details.
Ftc-split
Unmerge a two-column text into two buffers in two-column minor mode.
The text is unmerged at the cursor's column which becomes the local
value of `tc-window-width'.  Only lines that have the ARG same
preceding characters at that column get split.  The ARG preceding
characters without any leading whitespace become the local value for
`tc-separator'.  This way lines that continue across both
columns remain untouched in the first buffer.

This function can be used with a prototype line, to set up things as
you like them.  You write the first line of each column with the
separator you like and then unmerge that line.  E.g.:

First column's text    sSs  Second columns text
		       \___/\
			/    \
   5 character Separator      You type  M-5 \[tc-split]  with the point here

See  \[tc-two-columns]  and  `lisp/two-column.el'  for further details.
Ftc-dissociate
Turn off two-column minor mode in current and associated buffer.
If the associated buffer is unmodified and empty, it is killed.
Ftc-merge
Merges the associated buffer with the current buffer.
They get merged at the column, which is the value of
`tc-window-width', i.e. usually at the vertical window
separator.  This separator gets replaced with white space.  Beyond
that the value of gets inserted on merged lines.  The two columns are
thus pasted side by side, in a single text.  If the other buffer is
not displayed to the left of this one, then this one becomes the left
column.

If you want `tc-separator' on empty lines in the second column,
you should put just one space in them.  In the final result, you can strip
off trailing spaces with \[beginning-of-buffer] \[replace-regexp] [ SPC TAB ] + $ RET RET
Ftc-associated-buffer
Switch to associated buffer.
Ftc-scroll-line
Scroll current window upward by ARG lines.
The associated window gets scrolled to the same line.
Ftc-scroll-up
Scroll current window upward by ARG screens.
The associated window gets scrolled to the same line.
Ftc-scroll-down
Scroll current window downward by ARG screens.
The associated window gets scrolled to the same line.
Ftc-recenter
Center point in window.  With ARG, put point on line ARG.
This counts from bottom if ARG is negative.  The associated window
gets scrolled to the same line.
Funderline-region
Underline all nonblank characters in the region.
Works by overstriking underscores.
Called from program, takes two arguments START and END
which specify the range to operate on.
Fununderline-region
Remove all underlining (overstruck underscores) in the region.
Called from program, takes two arguments START and END
which specify the range to operate on.
Fbatch-unrmail
Convert Rmail files to mailbox files.
Specify the input Rmail file names as command line arguments.
For each Rmail file, the corresponding output file name
is made by adding `.mail' at the end.
For example, invoke `emacs -batch -f batch-unrmail RMAIL'.
Funrmail
Convert Rmail file FILE to mailbox-format file TO-FILE.
Vreplace-copying-with
*If non-nil, replace copying notices with this file.
Fupdate-copyright
Update the copyright notice at the beginning of the buffer
to indicate the current year.  If optional arg REPLACE is given
(interactively, with prefix arg) replace the years in the notice
rather than adding the current year after them.
If `replace-copying-with' is set, the copying permissions following the
copyright are replaced as well.

If optional third argument ASK is non-nil, the user is prompted for whether
or not to update the copyright.  If optional fourth argument ASK-YEAR is
non-nil, the user is prompted for whether or not to replace the year rather
than adding to it.
Fask-to-update-copyright
If the current buffer contains a copyright notice that is out of date,
ask the user if it should be updated with `update-copyright' (which see).
Put this on write-file-hooks.
Fask-user-about-lock
Ask user what to do when he wants to edit FILE but it is locked by USER.
This function has a choice of three things to do:
  do (signal 'buffer-file-locked (list FILE USER))
    to refrain from editing the file
  return t (grab the lock on the file)
  return nil (edit the file even though it is locked).
You can rewrite it to use any criterion you like to choose which one to do.
Fask-user-about-supersession-threat
Ask a user who is about to modify an obsolete buffer what to do.
This function has two choices: it can return, in which case the modification
of the buffer will proceed, or it can (signal 'file-supersession (file)),
in which case the proposed buffer modification will not be made.

You can rewrite this to use any criterion you like to choose which one to do.
The buffer in question is current when this function is called.
Vvc-checkin-hook
*List of functions called after a checkin is done.  See `run-hooks'.
Fvc-next-action
Do the next logical checkin or checkout operation on the current file.
   If the file is not already registered, this registers it for version
control and then retrieves a writable, locked copy for editing.
   If the file is registered and not locked by anyone, this checks out
a writable and locked file ready for editing.
   If the file is checked out and locked by the calling user, this
first checks to see if the file has changed since checkout.  If not,
it performs a revert.
   If the file has been changed, this pops up a buffer for entry
of a log message; when the message has been entered, it checks in the
resulting changes along with the log message as change commentary.  If
the variable `vc-keep-workfiles' is non-nil (which is its default), a
read-only copy of the changed file is left in place afterwards.
   If the file is registered and locked by someone else, you are given
the option to steal the lock.
   If you call this from within a VC dired buffer with no files marked,
it will operate on the file in the current line.
   If you call this from within a VC dired buffer, and one or more
files are marked, it will accept a log message and then operate on
each one.  The log message will be used as a comment for any register
or checkin operations, but ignored when doing checkouts.  Attempted
lock steals will raise an error.
Fvc-register
Register the current file into your version-control system.
Fvc-diff
Display diffs between file versions.
Normally this compares the current file and buffer with the most recent 
checked in version of that file.  This uses no arguments.
With a prefix argument, it reads the file name to use
and two version designators specifying which versions to compare.
Fvc-insert-headers
Insert headers in a file for use with your version-control system.
Headers desired are inserted at the start of the buffer, and are pulled from
the variable `vc-header-alist'.
Fvc-directory
Show version-control status of all files under the current directory.
Fvc-create-snapshot
Make a snapshot called NAME.
The snapshot is made from all registered files at or below the current
directory.  For each file, the version level of its latest
version becomes part of the named configuration.
Fvc-retrieve-snapshot
Retrieve the snapshot called NAME.
This function fails if any files are locked at or below the current directory
Otherwise, all registered files are checked out (unlocked) at their version
levels in the snapshot.
Fvc-print-log
List the change log of the current buffer in a window.
Fvc-revert-buffer
Revert the current buffer's file back to the latest checked-in version.
This asks for confirmation if the buffer contents are not identical
to that version.
Fvc-cancel-version
Get rid of most recently checked in version of this file.
A prefix argument means do not revert the buffer afterwards.
Fvc-update-change-log
Find change log file and add entries from recent RCS logs.
The mark is left at the end of the text prepended to the change log.
With prefix arg of C-u, only find log entries for the current buffer's file.
With any numeric prefix arg, find log entries for all files currently visited.
Otherwise, find log entries for all registered files in the default directory.
From a program, any arguments are passed to the `rcs2log' script.
Fvi-mode
Major mode that acts like the `vi' editor.
The purpose of this mode is to provide you the combined power of vi (namely,
the "cross product" effect of commands and repeat last changes) and Emacs.

This command redefines nearly all keys to look like vi commands.
It records the previous major mode, and any vi command for input
(`i', `a', `s', etc.) switches back to that mode.
Thus, ordinary Emacs (in whatever major mode you had been using)
is "input" mode as far as vi is concerned.

To get back into vi from "input" mode, you must issue this command again.
Therefore, it is recommended that you assign it to a key.

Major differences between this mode and real vi :

* Limitations and unsupported features
  - Search patterns with line offset (e.g. /pat/+3 or /pat/z.) are
    not supported.
  - Ex commands are not implemented; try ':' to get some hints.
  - No line undo (i.e. the 'U' command), but multi-undo is a standard feature.

* Modifications
  - The stopping positions for some point motion commands (word boundary,
    pattern search) are slightly different from standard 'vi'.
    Also, no automatic wrap around at end of buffer for pattern searching.
  - Since changes are done in two steps (deletion then insertion), you need
    to undo twice to completely undo a change command.  But this is not needed
    for undoing a repeated change command.
  - No need to set/unset 'magic', to search for a string with regular expr
    in it just put a prefix arg for the search commands.  Replace cmds too.
  - ^R is bound to incremental backward search, so use ^L to redraw screen.

* Extensions
  - Some standard (or modified) Emacs commands were integrated, such as
    incremental search, query replace, transpose objects, and keyboard macros.
  - In command state, ^X links to the 'ctl-x-map', and ESC can be linked to
    esc-map or set undefined.  These can give you the full power of Emacs.
  - See vi-com-map for those keys that are extensions to standard vi, e.g.
    `vi-name-last-change-or-macro', `vi-verify-spelling', `vi-locate-def',
    `vi-mark-region', and 'vi-quote-words'.  Some of them are quite handy.
  - Use \[vi-switch-mode] to switch among different modes quickly.
  
Syntax table and abbrevs while in vi mode remain as they were in Emacs.
Fview-file
View FILE in View mode, returning to previous buffer when done.
The usual Emacs commands are not available; instead,
a special set of commands (mostly letters and punctuation)
are defined for moving around in the buffer.
Space scrolls forward, Delete scrolls backward.
For list of all View commands, type ? or h while viewing.

This command runs the normal hook `view-hook'.
Fview-file-other-window
View FILE in View mode in other window.
Return to previous buffer when done.
The usual Emacs commands are not available; instead,
a special set of commands (mostly letters and punctuation)
are defined for moving around in the buffer.
Space scrolls forward, Delete scrolls backward.
For list of all View commands, type ? or h while viewing.

This command runs the normal hook `view-hook'.
Fview-buffer
View BUFFER in View mode, returning to previous buffer when done.
The usual Emacs commands are not available; instead,
a special set of commands (mostly letters and punctuation)
are defined for moving around in the buffer.
Space scrolls forward, Delete scrolls backward.
For list of all View commands, type ? or h while viewing.

This command runs the normal hook `view-hook'.
Fview-buffer-other-window
View BUFFER in View mode in another window,
returning to original buffer when done *only* if 
prefix argument NOT-RETURN is nil (which is the default).

The usual Emacs commands are not available in View mode; instead,
a special set of commands (mostly letters and punctuation)
are defined for moving around in the buffer.
Space scrolls forward, Delete scrolls backward.
For list of all View commands, type ? or h while viewing.

This command runs the normal hook `view-hook'.
Fview-mode
Major mode for viewing text but not editing it.
Letters do not insert themselves.  Instead these commands are provided.
Most commands take prefix arguments.  Commands dealing with lines
default to "scroll size" lines (initially size of window).
Search commands default to a repeat count of one.
M-< or <	move to beginning of buffer.
M-> or >	move to end of buffer.
C-v or Space	scroll forward lines.
M-v or DEL	scroll backward lines.
CR or LF	scroll forward one line (backward with prefix argument).
z		like Space except set number of lines for further
		   scrolling commands to scroll by.
C-u and Digits	provide prefix arguments.  `-' denotes negative argument.
=		prints the current line number.
g		goes to line given by prefix argument.
/ or M-C-s	searches forward for regular expression
\ or M-C-r	searches backward for regular expression.
n		searches forward for last regular expression.
p		searches backward for last regular expression.
C-@ or .	set the mark.
x		exchanges point and mark.
C-s or s	do forward incremental search.
C-r or r	do reverse incremental search.
@ or '		return to mark and pops mark ring.
		  Mark ring is pushed at start of every
		  successful search and when jump to line to occurs.
		  The mark is set on jump to buffer start or end.
? or h		provide help message (list of commands).
\[Helper-help]		provides help (list of commands or description of a command).
C-n		moves down lines vertically.
C-p		moves upward lines vertically.
C-l		recenters the screen.
q or C-c	exit view-mode and return to previous buffer.

Entry to this mode runs the normal hook `view-hook'.

\{view-mode-map}
Fvip-mode
Turn on VIP emulation of VI.
Frun-scheme
Run an inferior Scheme process.
Output goes to the buffer `*scheme*'.
With argument, asks for a command line.
Fyow
Return or display a random Zippy quotation.
Fpsychoanalyze-pinhead
Zippy goes to the analyst.
Fmap-y-or-n-p
Ask a series of boolean questions.
Takes args PROMPTER ACTOR LIST, and optional args HELP and ACTION-ALIST.

LIST is a list of objects, or a function of no arguments to return the next
object or nil.

If PROMPTER is a string, the prompt is (format PROMPTER OBJECT).  If not
a string, PROMPTER is a function of one arg (an object from LIST), which
returns a string to be used as the prompt for that object.  If the return
value is not a string, it is eval'd to get the answer; it may be nil to
ignore the object, t to act on the object without asking the user, or a
form to do a more complex prompt.

ACTOR is a function of one arg (an object from LIST),
which gets called with each object that the user answers `yes' for.

If HELP is given, it is a list (OBJECT OBJECTS ACTION),
where OBJECT is a string giving the singular noun for an elt of LIST;
OBJECTS is the plural noun for elts of LIST, and ACTION is a transitive
verb describing ACTOR.  The default is ("object" "objects" "act on").

At the prompts, the user may enter y, Y, or SPC to act on that object;
n, N, or DEL to skip that object; ! to act on all following objects;
ESC or q to exit (skip all following objects); . (period) to act on the
current object and then exit; or \[help-command] to get help.

If ACTION-ALIST is given, it is an alist (KEY FUNCTION HELP) of extra keys
that will be accepted.  KEY is a character; FUNCTION is a function of one
arg (an object from LIST); HELP is a string.  When the user hits KEY,
FUNCTION is called.  If it returns non-nil, the object is considered
"acted upon", and the next object from LIST is processed.  If it returns
nil, the prompt is repeated for the same object.

This function uses `query-replace-map' to define the standard responses,
but not all of the responses which `query-replace' understands
are meaningful here.

Returns the number of actions taken.
Fforward-page
Move forward to page boundary.  With arg, repeat, or go back if negative.
A page boundary is any line whose beginning matches the regexp
`page-delimiter'.
Fbackward-page
Move backward to page boundary.  With arg, repeat, or go fwd if negative.
A page boundary is any line whose beginning matches the regexp
`page-delimiter'.
Fmark-page
Put mark at end of page, point at beginning.
A numeric arg specifies to move forward or backward by that many pages,
thus marking a page other than the one point was originally in.
Fnarrow-to-page
Make text outside current page invisible.
A numeric arg specifies to move forward or backward by that many pages,
thus showing a page other than the one point was originally in.
Fcount-lines-page
Report number of lines on current page, and how many are before or after point.
Fwhat-page
Print page and line number of point.
Vparagraph-start
*Regexp for beginning of a line that starts OR separates paragraphs.
Vparagraph-separate
*Regexp for beginning of a line that separates paragraphs.
If you change this, you may have to change paragraph-start also.
Vsentence-end
*Regexp describing the end of a sentence.
All paragraph boundaries also end sentences, regardless.

In order to be recognized as the end of a sentence, the ending period,
question mark, or exclamation point must be followed by two spaces,
unless it's inside some sort of quotes or parenthesis.
Vpage-delimiter
*Regexp describing line-beginnings that separate pages.
Vparagraph-ignore-fill-prefix
Non-nil means the paragraph commands are not affected by `fill-prefix'.
This is desirable in modes where blank lines are the paragraph delimiters.
Fforward-paragraph
Move forward to end of paragraph.
With arg N, do it N times; negative arg -N means move forward N paragraphs.

A line which `paragraph-start' matches either separates paragraphs
(if `paragraph-separate' matches it also) or is the first line of a paragraph.
A paragraph end is the beginning of a line which is not part of the paragraph
to which the end of the previous line belongs, or the end of the buffer.
Fbackward-paragraph
Move backward to start of paragraph.
With arg N, do it N times; negative arg -N means move forward N paragraphs.

A paragraph start is the beginning of a line which is a
`first-line-of-paragraph' or which is ordinary text and follows a
paragraph-separating line; except: if the first real line of a
paragraph is preceded by a blank line, the paragraph starts at that
blank line.

See `forward-paragraph' for more information.
Fmark-paragraph
Put point at beginning of this paragraph, mark at end.
The paragraph marked is the one that contains point or follows point.
Fkill-paragraph
Kill forward to end of paragraph.
With arg N, kill forward to Nth end of paragraph;
negative arg -N means kill backward to Nth start of paragraph.
Fbackward-kill-paragraph
Kill back to start of paragraph.
With arg N, kill back to Nth start of paragraph;
negative arg -N means kill forward to Nth end of paragraph.
Ftranspose-paragraphs
Interchange this (or next) paragraph with previous one.
Fforward-sentence
Move forward to next `sentence-end'.  With argument, repeat.
With negative argument, move backward repeatedly to `sentence-beginning'.

The variable `sentence-end' is a regular expression that matches ends of
sentences.  Also, every paragraph boundary terminates sentences as well.
Fbackward-sentence
Move backward to start of sentence.  With arg, do it arg times.
See `forward-sentence' for more information.
Fkill-sentence
Kill from point to end of sentence.
With arg, repeat; negative arg -N means kill back to Nth start of sentence.
Fbackward-kill-sentence
Kill back from point to start of sentence.
With arg, repeat, or kill forward to Nth end of sentence if negative arg -N.
Fmark-end-of-sentence
Put mark at end of sentence.  Arg works as in `forward-sentence'.
Ftranspose-sentences
Interchange this (next) and previous sentence.
Vregister-alist
Alist of elements (NAME . CONTENTS), one for each Emacs register.
NAME is a character (a number).  CONTENTS is a string, number,
frame configuration, mark or list.
A list of strings represents a rectangle.
A list of the form (file . NAME) represents the file named NAME.
Fget-register
Return contents of Emacs register named CHAR, or nil if none.
Fset-register
Set contents of Emacs register named CHAR to VALUE.  Returns VALUE.
See the documentation of the variable `register-alist' for possible VALUE.
Fpoint-to-register
Store current location of point in register REGISTER.
With prefix argument, store current frame configuration.
Use \[jump-to-register] to go to that location or restore that configuration.
Argument is a character, naming the register.
Fwindow-configuration-to-register
Store the window configuration of the selected frame in register REGISTER.
Use \[jump-to-register] to restore the configuration.
Argument is a character, naming the register.
Fframe-configuration-to-register
Store the window configuration of all frames in register REGISTER.
Use \[jump-to-register] to restore the configuration.
Argument is a character, naming the register.
Fjump-to-register
Move point to location stored in a register.
If the register contains a file name, find that file.
 (To put a file name in a register, you must use `set-register'.)
If the register contains a window configuration (one frame) or a frame
configuration (all frames), restore that frame or all frames accordingly.
Argument is a character, naming the register.
Fview-register
Display what is contained in register named REGISTER.
REGISTER is a character.
Finsert-register
Insert contents of register REG.  REG is a character.
Normally puts point before and mark after the inserted text.
If optional second arg is non-nil, puts mark before and point after.
Interactively, second arg is non-nil if prefix arg is supplied.
Fcopy-to-register
Copy region into register REG.  With prefix arg, delete as well.
Called from program, takes four args: REG, START, END and DELETE-FLAG.
START and END are buffer positions indicating what to copy.
Fappend-to-register
Append region to text in register REG.  With prefix arg, delete as well.
Called from program, takes four args: REG, START, END and DELETE-FLAG.
START and END are buffer positions indicating what to append.
Fprepend-to-register
Prepend region to text in register REG.  With prefix arg, delete as well.
Called from program, takes four args: REG, START, END and DELETE-FLAG.
START and END are buffer positions indicating what to prepend.
Fcopy-rectangle-to-register
Copy rectangular region into register REG.  With prefix arg, delete as well.
Called from program, takes four args: REG, START, END and DELETE-FLAG.
START and END are buffer positions giving two corners of rectangle.
Vcase-replace
*Non-nil means query-replace should preserve case in replacements.
Fquery-replace
Replace some occurrences of FROM-STRING with TO-STRING.
As each match is found, the user must type a character saying
what to do with it.  For directions, type \[help-command] at that time.

Preserves case in each replacement if  case-replace  and  case-fold-search
are non-nil and FROM-STRING has no uppercase letters.
Third arg DELIMITED (prefix arg if interactive) non-nil means replace
only matches surrounded by word boundaries.

To customize possible responses, change the "bindings" in `query-replace-map'.
Fquery-replace-regexp
Replace some things after point matching REGEXP with TO-STRING.
As each match is found, the user must type a character saying
what to do with it.  For directions, type \[help-command] at that time.

Preserves case in each replacement if  case-replace  and  case-fold-search
are non-nil and REGEXP has no uppercase letters.
Third arg DELIMITED (prefix arg if interactive) non-nil means replace
only matches surrounded by word boundaries.
In TO-STRING, \& means insert what matched REGEXP,
and \=\<n> means insert what matched <n>th \(...\) in REGEXP.
Fmap-query-replace-regexp
Replace some matches for REGEXP with various strings, in rotation.
The second argument TO-STRINGS contains the replacement strings, separated
by spaces.  This command works like `query-replace-regexp' except
that each successive replacement uses the next successive replacement string,
wrapping around from the last such string to the first.

Non-interactively, TO-STRINGS may be a list of replacement strings.

A prefix argument N says to use each replacement string N times
before rotating to the next.
Freplace-string
Replace occurrences of FROM-STRING with TO-STRING.
Preserve case in each match if `case-replace' and `case-fold-search'
are non-nil and FROM-STRING has no uppercase letters.
Third arg DELIMITED (prefix arg if interactive) non-nil means replace
only matches surrounded by word boundaries.

This function is usually the wrong thing to use in a Lisp program.
What you probably want is a loop like this:
  (while (search-forward OLD-STRING nil t)
    (replace-match REPLACEMENT nil t))
which will run faster and will not set the mark or print anything.
Freplace-regexp
Replace things after point matching REGEXP with TO-STRING.
Preserve case in each match if case-replace and case-fold-search
are non-nil and REGEXP has no uppercase letters.
Third arg DELIMITED (prefix arg if interactive) non-nil means replace
only matches surrounded by word boundaries.
In TO-STRING, \& means insert what matched REGEXP,
and \=\<n> means insert what matched <n>th \(...\) in REGEXP.

This function is usually the wrong thing to use in a Lisp program.
What you probably want is a loop like this:
  (while (re-search-forward REGEXP nil t)
    (replace-match REPLACEMENT nil nil))
which will run faster and will not set the mark or print anything.
Vregexp-history
History list for some commands that read regular expressions.
Fkeep-lines
Delete all lines except those containing matches for REGEXP.
A match split across lines preserves all the lines it lies in.
Applies to all lines after point.
Fflush-lines
Delete lines containing matches for REGEXP.
If a match is split across lines, all the lines it lies in are deleted.
Applies to lines after point.
Fhow-many
Print number of matches for REGEXP following point.
Foccur-mode
Major mode for output from \[occur].
Move point to one of the occurrences in this buffer,
then use \[occur-mode-goto-occurrence] to go to the same occurrence
in the buffer that the occurrences were found in.
\{occur-mode-map}
Foccur-mode-goto-occurrence
Go to the line this occurrence was found in, in the buffer it was found in.
Vlist-matching-lines-default-context-lines
*Default number of context lines to include around a `list-matching-lines'
match.  A negative number means to include that many lines before the match.
A positive number means to include that many lines both before and after.
Foccur
Show all lines in the current buffer containing a match for REGEXP.

If a match spreads across multiple lines, all those lines are shown.

Each line is displayed with NLINES lines before and after, or -NLINES
before if NLINES is negative.
NLINES defaults to `list-matching-lines-default-context-lines'.
Interactively it is the prefix arg.

The lines are shown in a buffer named `*Occur*'.
It serves as a menu to find any of the occurrences in this buffer.
\[describe-mode] in that buffer will explain how.
Vquery-replace-help
Help message while in query-replace
Vquery-replace-map
Keymap that defines the responses to questions in `query-replace'.
The "bindings" in this map are not commands; they are answers.
The valid answers include `act', `skip', `act-and-show',
`exit', `act-and-exit', `edit', `delete-and-edit', `recenter',
`automatic', `backup', and `help'.
Fperform-replace
Subroutine of `query-replace'.  Its complexity handles interactive queries.
Don't use this in your own program unless you want to query and set the mark
just as `query-replace' does.  Instead, write a simple loop like this:
  (while (re-search-forward "foo[ 	]+bar" nil t)
    (replace-match "foobar" nil nil))
which will run faster and do exactly what you probably want.
Fopen-line
Insert a newline and leave point before it.
If there is a fill prefix, insert the fill prefix on the new line
if the line would have been empty.
With arg N, insert N newlines.
Fsplit-line
Split current line, moving portion beyond point vertically down.
Fquoted-insert
Read next input character and insert it.
This is useful for inserting control characters.
You may also type up to 3 octal digits, to insert a character with that code.

In overwrite mode, this function inserts the character anyway, and
does not handle octal digits specially.  This means that if you use
overwrite as your normal editing mode, you can use this function to
insert characters when necessary.

In binary overwrite mode, this function does overwrite, and octal
digits are interpreted as a character code.  This is supposed to make
this function useful in editing binary files.
Fdelete-indentation
Join this line to previous and fix up whitespace at join.
If there is a fill prefix, delete it from the beginning of this line.
With argument, join this line to following line.
Ffixup-whitespace
Fixup white space between objects around point.
Leave one space or none, according to the context.
Fdelete-horizontal-space
Delete all spaces and tabs around point.
Fjust-one-space
Delete all spaces and tabs around point, leaving one space.
Fdelete-blank-lines
On blank line, delete all surrounding blank lines, leaving just one.
On isolated blank line, delete that one.
On nonblank line, delete all blank lines that follow it.
Fback-to-indentation
Move point to the first non-whitespace character on this line.
Fnewline-and-indent
Insert a newline, then indent according to major mode.
Indentation is done using the value of `indent-line-function'.
In programming language modes, this is the same as TAB.
In some text modes, where TAB inserts a tab, this command indents to the
column specified by the variable `left-margin'.
Freindent-then-newline-and-indent
Reindent current line, insert newline, then indent the new line.
Indentation of both lines is done according to the current major mode,
which means calling the current value of `indent-line-function'.
In programming language modes, this is the same as TAB.
In some text modes, where TAB inserts a tab, this indents to the
column specified by the variable `left-margin'.
Fbackward-delete-char-untabify
Delete characters backward, changing tabs into spaces.
Delete ARG chars, and kill (save in kill ring) if KILLP is non-nil.
Interactively, ARG is the prefix arg (default 1)
and KILLP is t if prefix arg is was specified.
Fzap-to-char
Kill up to and including ARG'th occurrence of CHAR.
Goes backward if ARG is negative; error if CHAR not found.
Fbeginning-of-buffer
Move point to the beginning of the buffer; leave mark at previous position.
With arg N, put point N/10 of the way from the true beginning.

Don't use this command in Lisp programs!
(goto-char (point-min)) is faster and avoids clobbering the mark.
Fend-of-buffer
Move point to the end of the buffer; leave mark at previous position.
With arg N, put point N/10 of the way from the true end.

Don't use this command in Lisp programs!
(goto-char (point-max)) is faster and avoids clobbering the mark.
Fmark-whole-buffer
Put point at beginning and mark at end of buffer.
You probably should not use this function in Lisp programs;
it is usually a mistake for a Lisp function to use any subroutine
that uses or sets the mark.
Fcount-lines-region
Print number of lines and characters in the region.
Fwhat-line
Print the current line number (in the buffer) of point.
Fcount-lines
Return number of lines between START and END.
This is usually the number of newlines between them,
but can be one more if START is not equal to END
and the greater of them is not at the start of a line.
Fwhat-cursor-position
Print info on cursor position (on screen and within buffer).
Ffundamental-mode
Major mode not specialized for anything in particular.
Other major modes are defined by comparison with this one.
Vread-expression-map
Minibuffer keymap used for reading Lisp expressions.
Feval-expression
Evaluate EXPRESSION and print value in minibuffer.
Value is also consed on to front of the variable `values'.
Fedit-and-eval-command
Prompting with PROMPT, let user edit COMMAND and eval result.
COMMAND is a Lisp expression.  Let user edit that expression in
the minibuffer, then read and evaluate the result.
Frepeat-complex-command
Edit and re-evaluate last complex command, or ARGth from last.
A complex command is one which used the minibuffer.
The command is placed in the minibuffer as a Lisp form for editing.
The result is executed, repeating the command as changed.
If the command has been changed or is not the most recent previous command
it is added to the front of the command history.
You can use the minibuffer history commands \<minibuffer-local-map>\[next-history-element] and \[previous-history-element]
to get different commands to edit and resubmit.
Vminibuffer-history
Default minibuffer history list.
This is used for all minibuffer input
except when an alternate history list is specified.
Vminibuffer-history-sexp-flag
Nonzero when doing history operations on `command-history'.
More generally, indicates that the history list being acted on
contains expressions rather than strings.
Fprevious-matching-history-element
Find the previous history element that matches REGEXP.
(Previous history elements refer to earlier actions.)
With prefix argument N, search for Nth previous match.
If N is negative, find the next or Nth next match.
Fnext-matching-history-element
Find the next history element that matches REGEXP.
(The next history element refers to a more recent action.)
With prefix argument N, search for Nth next match.
If N is negative, find the previous or Nth previous match.
Fnext-history-element
Insert the next element of the minibuffer history into the minibuffer.
Fprevious-history-element
Inserts the previous element of the minibuffer history into the minibuffer.
Fnext-complete-history-element
Get previous element of history which is a completion of minibuffer contents.
Fprevious-complete-history-element
Get next element of history which is a completion of minibuffer contents.
Fgoto-line
Goto line ARG, counting from line 1 at beginning of buffer.
Fundo
Undo some previous changes.
Repeat this command to undo more changes.
A numeric argument serves as a repeat count.
Vpending-undo-list
Within a run of consecutive undo commands, list remaining to be undone.
Fundo-start
Set `pending-undo-list' to the front of the undo list.
The next call to `undo-more' will undo the most recently made change.
Fundo-more
Undo back N undo-boundaries beyond what was already undone recently.
Call `undo-start' to get ready to undo recent changes,
then call `undo-more' one or more times to undo them.
Fshell-command
Execute string COMMAND in inferior shell; display output, if any.
If COMMAND ends in ampersand, execute it asynchronously.
 
Optional second arg non-nil (prefix arg, if interactive)
means insert output in current buffer after point (leave mark after it).
This cannot be done asynchronously.
Fshell-command-on-region
Execute string COMMAND in inferior shell with region as input.
Normally display output (if any) in temp buffer `*Shell Command Output*';
Prefix arg means replace the region with it.
Noninteractive args are START, END, COMMAND, FLAG.
Noninteractively FLAG means insert output in place of text from START to END,
and put point at the end, but don't alter the mark.

If the output is one line, it is displayed in the echo area,
but it is nonetheless available in buffer `*Shell Command Output*'
even though that buffer is not automatically displayed.  If there is no output
or output is inserted in the current buffer then `*Shell Command Output*' is
deleted.
Funiversal-argument
Begin a numeric argument for the following command.
Digits or minus sign following \[universal-argument] make up the numeric argument.
\[universal-argument] following the digits or minus sign ends the argument.
\[universal-argument] without digits or minus sign provides 4 as argument.
Repeating \[universal-argument] without digits or minus sign
 multiplies the argument by 4 each time.
Fdigit-argument
Part of the numeric argument for the next command.
\[universal-argument] following digits or minus sign ends the argument.
Fnegative-argument
Begin a negative numeric argument for the next command.
\[universal-argument] following digits or minus sign ends the argument.
Fforward-to-indentation
Move forward ARG lines and position at first nonblank character.
Fbackward-to-indentation
Move backward ARG lines and position at first nonblank character.
Vkill-whole-line
*If non-nil, `kill-line' with no arg at beg of line kills the whole line.
Fkill-line
Kill the rest of the current line; if no nonblanks there, kill thru newline.
With prefix argument, kill that many lines from point.
Negative arguments kill lines backward.

When calling from a program, nil means "no arg",
a number counts as a prefix arg.

If `kill-whole-line' is non-nil, then kill the whole line
when given no argument at the beginning of a line.
Vinterprogram-cut-function
Function to call to make a killed region available to other programs.

Most window systems provide some sort of facility for cutting and
pasting text between the windows of different programs.
This variable holds a function that Emacs calls whenever text
is put in the kill ring, to make the new kill available to other
programs.

The function takes one or two arguments.
The first argument, TEXT, is a string containing
the text which should be made available.
The second, PUSH, if non-nil means this is a "new" kill;
nil means appending to an "old" kill.
Vinterprogram-paste-function
Function to call to get text cut from other programs.

Most window systems provide some sort of facility for cutting and
pasting text between the windows of different programs.
This variable holds a function that Emacs calls to obtain
text that other programs have provided for pasting.

The function should be called with no arguments.  If the function
returns nil, then no other program has provided such text, and the top
of the Emacs kill ring should be used.  If the function returns a
string, that string should be put in the kill ring as the latest kill.

Note that the function should return a string only if a program other
than Emacs has provided a string for pasting; if Emacs provided the
most recent string, the function should return nil.  If it is
difficult to tell whether Emacs or some other program provided the
current string, it is probably good enough to return nil if the string
is equal (according to `string=') to the last text Emacs provided.
Vkill-ring
List of killed text sequences.
Since the kill ring is supposed to interact nicely with cut-and-paste
facilities offered by window systems, use of this variable should
interact nicely with `interprogram-cut-function' and
`interprogram-paste-function'.  The functions `kill-new',
`kill-append', and `current-kill' are supposed to implement this
interaction; you may want to use them instead of manipulating the kill
ring directly.
Vkill-ring-max
*Maximum length of kill ring before oldest elements are thrown away.
Vkill-ring-yank-pointer
The tail of the kill ring whose car is the last thing yanked.
Fkill-new
Make STRING the latest kill in the kill ring.
Set the kill-ring-yank pointer to point to it.
If `interprogram-cut-function' is non-nil, apply it to STRING.
Fkill-append
Append STRING to the end of the latest kill in the kill ring.
If BEFORE-P is non-nil, prepend STRING to the kill.
If `interprogram-cut-function' is set, pass the resulting kill to
it.
Fcurrent-kill
Rotate the yanking point by N places, and then return that kill.
If N is zero, `interprogram-paste-function' is set, and calling it
returns a string, then that string is added to the front of the
kill ring and returned as the latest kill.
If optional arg DO-NOT-MOVE is non-nil, then don't actually move the 
yanking point; just return the Nth kill forward.
Fkill-region
Kill between point and mark.
The text is deleted but saved in the kill ring.
The command \[yank] can retrieve it from there.
(If you want to kill and then yank immediately, use \[copy-region-as-kill].)
If the buffer is read-only, Emacs will beep and refrain from deleting
the text, but put the text in the kill ring anyway.  This means that
you can use the killing commands to copy text from a read-only buffer.

This is the primitive for programs to kill text (as opposed to deleting it).
Supply two arguments, character numbers indicating the stretch of text
 to be killed.
Any command that calls this function is a "kill command".
If the previous command was also a kill command,
the text killed this time appends to the text killed last time
to make one entry in the kill ring.
Fcopy-region-as-kill
Save the region as if killed, but don't kill it.
If `interprogram-cut-function' is non-nil, also save the text for a window
system cut and paste.
Fkill-ring-save
Save the region as if killed, but don't kill it.
This command is similar to `copy-region-as-kill', except that it gives
visual feedback indicating the extent of the region being copied.
If `interprogram-cut-function' is non-nil, also save the text for a window
system cut and paste.
Fappend-next-kill
Cause following command, if it kills, to append to previous kill.
Fyank-pop
Replace just-yanked stretch of killed text with a different stretch.
This command is allowed only immediately after a `yank' or a `yank-pop'.
At such a time, the region contains a stretch of reinserted
previously-killed text.  `yank-pop' deletes that text and inserts in its
place a different stretch of killed text.

With no argument, the previous kill is inserted.
With argument N, insert the Nth previous kill.
If N is negative, this is a more recent kill.

The sequence of kills wraps around, so that after the oldest one
comes the newest one.
Fyank
Reinsert the last stretch of killed text.
More precisely, reinsert the stretch of killed text most recently
killed OR yanked.  Put point at end, and set mark at beginning.
With just C-u as argument, same but put point at beginning (and mark at end).
With argument N, reinsert the Nth most recently killed stretch of killed
text.
See also the command \[yank-pop].
Frotate-yank-pointer
Rotate the yanking point in the kill ring.
With argument, rotate that many kills forward (or backward, if negative).
Finsert-buffer
Insert after point the contents of BUFFER.
Puts mark after the inserted text.
BUFFER may be a buffer or a buffer name.
Fappend-to-buffer
Append to specified buffer the text of the region.
It is inserted into that buffer before its point.

When calling from a program, give three arguments:
BUFFER (or buffer name), START and END.
START and END specify the portion of the current buffer to be copied.
Fprepend-to-buffer
Prepend to specified buffer the text of the region.
It is inserted into that buffer after its point.

When calling from a program, give three arguments:
BUFFER (or buffer name), START and END.
START and END specify the portion of the current buffer to be copied.
Fcopy-to-buffer
Copy to specified buffer the text of the region.
It is inserted into that buffer, replacing existing text there.

When calling from a program, give three arguments:
BUFFER (or buffer name), START and END.
START and END specify the portion of the current buffer to be copied.
Vmark-even-if-inactive
*Non-nil means you can use the mark even when inactive.
This option makes a difference in Transient Mark mode.
When the option is non-nil, deactivation of the mark
turns off region highlighting, but commands that use the mark
behave as if the mark were still active.
Fmark
Return this buffer's mark value as integer; error if mark inactive.
If optional argument FORCE is non-nil, access the mark value
even if the mark is not currently active, and return nil
if there is no mark at all.

If you are using this in an editing command, you are most likely making
a mistake; see the documentation of `set-mark'.
Fdeactivate-mark
Deactivate the mark by setting `mark-active' to nil.
Also runs the hook `deactivate-mark-hook'.
Fset-mark
Set this buffer's mark to POS.  Don't use this function!
That is to say, don't use this function unless you want
the user to see that the mark has moved, and you want the previous
mark position to be lost.

Normally, when a new mark is set, the old one should go on the stack.
This is why most applications should use push-mark, not set-mark.

Novice Emacs Lisp programmers often try to use the mark for the wrong
purposes.  The mark saves a location for the user's convenience.
Most editing commands should not alter the mark.
To remember a location for internal use in the Lisp program,
store it in a Lisp variable.  Example:

   (let ((beg (point))) (forward-line 1) (delete-region beg (point))).
Vmark-ring
The list of saved former marks of the current buffer,
most recent first.
Vmark-ring-max
*Maximum size of mark ring.  Start discarding off end if gets this big.
Fset-mark-command
Set mark at where point is, or jump to mark.
With no prefix argument, set mark, and push old mark position on mark ring.
With argument, jump to mark, and pop a new position for mark off the ring.

Novice Emacs Lisp programmers often try to use the mark for the wrong
purposes.  See the documentation of `set-mark' for more information.
Fpush-mark
Set mark at LOCATION (point, by default) and push old mark on mark ring.
Display `Mark set' unless the optional second arg NOMSG is non-nil.
In Transient Mark mode, activate mark if optional third arg ACTIVATE non-nil.

Novice Emacs Lisp programmers often try to use the mark for the wrong
purposes.  See the documentation of `set-mark' for more information.

In Transient Mark mode, this does not activate the mark.
Fpop-mark
Pop off mark ring into the buffer's actual mark.
Does not set point.  Does nothing if mark ring is empty.
Fexchange-point-and-mark
Put the mark where point is now, and point where the mark is now.
This command works even when the mark is not active,
and it reactivates the mark.
Ftransient-mark-mode
Toggle Transient Mark mode.
With arg, turn Transient Mark mode on if arg is positive, off otherwise.

In Transient Mark mode, changing the buffer "deactivates" the mark.
While the mark is active, the region is highlighted.
Vnext-line-add-newlines
*If non-nil, `next-line' inserts newline to avoid `end of buffer' error.
Fnext-line
Move cursor vertically down ARG lines.
If there is no character in the target line exactly under the current column,
the cursor is positioned after the character in that line which spans this
column, or at the end of the line if it is not long enough.
If there is no line in the buffer after this one, behavior depends on the
value of next-line-add-newlines.  If non-nil, a newline character is inserted
to create a line and the cursor moves to that line, otherwise the cursor is
moved to the end of the buffer (if already at the end of the buffer, an error
is signaled).

The command \[set-goal-column] can be used to create
a semipermanent goal column to which this command always moves.
Then it does not try to move vertically.  This goal column is stored
in `goal-column', which is nil when there is none.

If you are thinking of using this in a Lisp program, consider
using `forward-line' instead.  It is usually easier to use
and more reliable (no dependence on goal column, etc.).
Fprevious-line
Move cursor vertically up ARG lines.
If there is no character in the target line exactly over the current column,
the cursor is positioned after the character in that line which spans this
column, or at the end of the line if it is not long enough.

The command \[set-goal-column] can be used to create
a semipermanent goal column to which this command always moves.
Then it does not try to move vertically.

If you are thinking of using this in a Lisp program, consider using
`forward-line' with a negative argument instead.  It is usually easier
to use and more reliable (no dependence on goal column, etc.).
Vtrack-eol
*Non-nil means vertical motion starting at end of line keeps to ends of lines.
This means moving to the end of each line moved onto.
The beginning of a blank line does not count as the end of a line.
Vgoal-column
*Semipermanent goal column for vertical motion, as set by \[set-goal-column], or nil.
Vtemporary-goal-column
Current goal column for vertical motion.
It is the column where point was
at the start of current run of vertical motion commands.
When the `track-eol' feature is doing its job, the value is 9999.
Fset-goal-column
Set the current horizontal position as a goal for \[next-line] and \[previous-line].
Those commands will move to this position in the line moved to
rather than trying to keep the same horizontal position.
With a non-nil argument, clears out the goal column
so that \[next-line] and \[previous-line] resume vertical motion.
The goal column is stored in the variable `goal-column'.
Vhscroll-step
*The number of columns to try scrolling a window by when point moves out.
If that fails to bring point back on frame, point is centered instead.
If this is zero, point is always centered after it moves off frame.
Fhscroll-point-visible
Scrolls the window horizontally to make point visible.
Ftranspose-chars
Interchange characters around point, moving forward one character.
With prefix arg ARG, effect is to take character before point
and drag it forward past ARG other characters (backward if ARG negative).
If no argument and at end of line, the previous two chars are exchanged.
Ftranspose-words
Interchange words around point, leaving point at end of them.
With prefix arg ARG, effect is to take word before or around point
and drag it forward past ARG other words (backward if ARG negative).
If ARG is zero, the words around or after point and around or after mark
are interchanged.
Ftranspose-sexps
Like \[transpose-words] but applies to sexps.
Does not work on a sexp that point is in the middle of
if it is a list or string.
Ftranspose-lines
Exchange current line and previous line, leaving point after both.
With argument ARG, takes previous line and moves it past ARG lines.
With argument 0, interchanges line point is in with line mark is in.
Vcomment-column
*Column to indent right-margin comments to.
Setting this variable automatically makes it local to the current buffer.
Each mode establishes a different default value for this variable; you
can the value for a particular mode using that mode's hook.
Vcomment-start
*String to insert to start a new comment, or nil if no comment syntax defined.
Vcomment-start-skip
*Regexp to match the start of a comment plus everything up to its body.
If there are any \(...\) pairs, the comment delimiter text is held to begin
at the place matched by the close of the first pair.
Vcomment-end
*String to insert to end a new comment.
Should be an empty string if comments are terminated by end-of-line.
Vcomment-indent-hook
Obsolete variable for function to compute desired indentation for a comment.
This function is called with no args with point at the beginning of
the comment's starting delimiter.
Vcomment-indent-function
Function to compute desired indentation for a comment.
This function is called with no args with point at the beginning of
the comment's starting delimiter.
Findent-for-comment
Indent this line's comment to comment column, or insert an empty comment.
Fset-comment-column
Set the comment column based on point.
With no arg, set the comment column to the current column.
With just minus as arg, kill any comment on this line.
With any other arg, set comment column to indentation of the previous comment
 and then align or create a comment on this line at that column.
Fkill-comment
Kill the comment on this line, if any.
With argument, kill comments on that many lines starting with this one.
Fcomment-region
Comment the region; third arg numeric means use ARG comment characters.
If ARG is negative, delete that many comment characters instead.
Comments are terminated on each line, even for syntax in which newline does
not end the comment.  Blank lines do not get comments.
Fbackward-word
Move backward until encountering the end of a word.
With argument, do this that many times.
In programs, it is faster to call `forward-word' with negative arg.
Fmark-word
Set mark arg words away from point.
Fkill-word
Kill characters forward until encountering the end of a word.
With argument, do this that many times.
Fbackward-kill-word
Kill characters backward until encountering the end of a word.
With argument, do this that many times.
Fcurrent-word
Return the word point is on as a string, if it's between two
word-constituent characters. If not, but it immediately follows one,
move back first.  Otherwise, if point precedes a word constituent,
move forward first.  Otherwise, move backwards until a word constituent
is found and get that word; if you reach a newline first, move forward
instead.
Vfill-prefix
*String for filling to insert at front of new line, or nil for none.
Setting this variable automatically makes it local to the current buffer.
Vauto-fill-inhibit-regexp
*Regexp to match lines which should not be auto-filled.
Vcomment-multi-line
*Non-nil means \[indent-new-comment-line] should continue same comment
on new line, with no new terminator or starter.
This is obsolete because you might as well use \[newline-and-indent].
Findent-new-comment-line
Break line at point and indent, continuing comment if presently within one.
The body of the continued comment is indented under the previous comment line.

This command is intended for styles where you write a comment per line,
starting a new comment (and terminating it if necessary) on each line.
If you want to continue one comment across several lines, use \[newline-and-indent].
Fauto-fill-mode
Toggle auto-fill mode.
With arg, turn auto-fill mode on if and only if arg is positive.
In auto-fill mode, inserting a space at a column beyond  fill-column
automatically breaks the line at a previous space.
Fturn-on-auto-fill
Unconditionally turn on Auto Fill mode.
Fset-fill-column
Set `fill-column' to current column, or to argument if given.
The variable `fill-column' has a separate value for each buffer.
Fset-selective-display
Set `selective-display' to ARG; clear it if no arg.
When the value of `selective-display' is a number > 0,
lines whose indentation is >= that value are not displayed.
The variable `selective-display' has a separate value for each buffer.
Voverwrite-mode-textual
The string displayed in the mode line when in overwrite mode.
Voverwrite-mode-binary
The string displayed in the mode line when in binary overwrite mode.
Foverwrite-mode
Toggle overwrite mode.
With arg, turn overwrite mode on iff arg is positive.
In overwrite mode, printing characters typed in replace existing text
on a one-for-one basis, rather than pushing it to the right.  At the
end of a line, such characters extend the line.  Before a tab,
such characters insert until the tab is filled in.
\[quoted-insert] still inserts characters in overwrite mode; this
is supposed to make it easier to insert characters when necessary.
Fbinary-overwrite-mode
Toggle binary overwrite mode.
With arg, turn binary overwrite mode on iff arg is positive.
In binary overwrite mode, printing characters typed in replace
existing text.  Newlines are not treated specially, so typing at the
end of a line joins the line to the next, with the typed character
between them.  Typing before a tab character simply replaces the tab
with the character typed.
\[quoted-insert] replaces the text at the cursor, just as ordinary
typing characters do.

Note that binary overwrite mode is not its own minor mode; it is a
specialization of overwrite-mode, entered by setting the
`overwrite-mode' variable to `overwrite-mode-binary'.
Vline-number-mode
*Non-nil means display line number in mode line.
Fline-number-mode
Toggle Line Number mode.
With arg, turn Line Number mode on iff arg is positive.
When Line Number mode is enabled, the line number appears
in the mode line.
Vblink-matching-paren
*Non-nil means show matching open-paren when close-paren is inserted.
Vblink-matching-paren-distance
*If non-nil, is maximum distance to search for matching open-paren.
Fblink-matching-open
Move cursor momentarily to the beginning of the sexp before point.
Fkeyboard-quit
Signal a  quit  condition.
During execution of Lisp code, this character causes a quit directly.
At top-level, as an editor command, this simply beeps.
Fset-variable
Set VARIABLE to VALUE.  VALUE is a Lisp object.
When using this interactively, supply a Lisp expression for VALUE.
If you want VALUE to be a string, you must surround it with doublequotes.

If VARIABLE has a `variable-interactive' property, that is used as if
it were the arg to `interactive' (which see) to interactively read the value.
Fcompletion-mode
Major mode for buffers showing lists of possible completions.
Type \<completion-mode-map>\[mouse-choose-completion] to select
a completion with the mouse.
Vcommand-line-processed
t once command line has been processed
Vinhibit-startup-message
*Non-nil inhibits the initial startup messages.
This is for use in your personal init file, once you are familiar
with the contents of the startup message.
Vinhibit-default-init
*Non-nil inhibits loading the `default' library.
Vcommand-switch-alist
Alist of command-line switches.
Elements look like (SWITCH-STRING . HANDLER-FUNCTION).
HANDLER-FUNCTION receives switch name as sole arg;
remaining command-line args are in the variable `command-line-args-left'.
Vcommand-line-functions
List of functions to process unrecognized command-line arguments.
Each function should access the dynamically bound variables
argi (the current argument) and command-line-args-left (the remaining
arguments).  The function should return non-nil only if it recognizes and
processes argi.  If it does so, it may consume successive arguments by
altering command-line-args-left to remove them.
Vbefore-init-hook
Functions to call after handling urgent options but before loading init file.
The frame system uses this to open frames to display messages while
Emacs loads the user's initialization file.
Vafter-init-hook
Functions to call after loading the init file (`~/.emacs').
The call is not protected by a condition-case, so you can set `debug-on-error'
in `.emacs', and put all the actual code on `after-init-hook'.
Vterm-setup-hook
Functions to be called after loading terminal-specific lisp code.
See `run-hooks'.  This variable exists for users to set,
so as to override the definitions made by the terminal-specific file.
Emacs never sets this variable itself.
Vkeyboard-type
The brand of keyboard you are using.  This variable is used to define
the proper function and keypad keys for use under X.  It is used in a
fashion analogous to the environment value TERM.
Vwindow-setup-hook
Function called to initialize window system display.
Emacs calls this after processing the command line arguments and loading
the user's init file.

Users should not set this variable; use term-setup-hook instead.
Vinitial-major-mode
Major mode command symbol to use for the initial *scratch* buffer.
Vinit-file-user
Identity of user whose `.emacs' file is or was read.
The value may be the null string or a string containing a user's name.
If the value is a null string, it means that the init file was taken from
the user that originally logged in.

In all cases, `(concat "~" init-file-user "/")' evaluates to the
directory name of the directory where the `.emacs' file was looked for.
Flambda
Return a lambda expression.
A call of the form (lambda ARGS DOCSTRING INTERACTIVE BODY) is
self-quoting; the result of evaluating the lambda expression is the
expression itself.  The lambda expression may then be treated as a
function, i. e. stored as the function value of a symbol, passed to
funcall or mapcar, etcetera.
ARGS should take the same form as an argument list for a `defun'.
DOCSTRING should be a string, as described for `defun'.  It may be omitted.
INTERACTIVE should be a call to the function `interactive', which see.
It may also be omitted.
BODY should be a list of lisp expressions.
Fone-window-p
Returns non-nil if there is only one window.
Optional arg NOMINI non-nil means don't count the minibuffer
even if it is active.
Fwalk-windows
Cycle through all visible windows, calling PROC for each one.
PROC is called with a window as argument.
Optional second arg MINIBUF t means count the minibuffer window
even if not active.  If MINIBUF is neither t nor nil it means
not to count the minibuffer even if it is active.

Optional third arg ALL-FRAMES, if t, means include all frames.
ALL-FRAMES nil or omitted means cycle within the selected frame,
but include the minibuffer window (if MINIBUF says so) that that
frame uses, even if it is on another frame.
If ALL-FRAMES is neither nil nor t, stick strictly to the selected frame.
Fsuppress-keymap
Make MAP override all normally self-inserting keys to be undefined.
Normally, as an exception, digits and minus-sign are set to make prefix args,
but optional second arg NODIGITS non-nil treats them like other chars.
Fsubstitute-key-definition
Replace OLDDEF with NEWDEF for any keys in KEYMAP now defined as OLDDEF.
In other words, OLDDEF is replaced with NEWDEF where ever it appears.
If optional fourth argument OLDMAP is specified, we redefine
in KEYMAP as NEWDEF those chars which are defined as OLDDEF in OLDMAP.
Fdefine-key-after
Add binding in KEYMAP for KEY => DEFINITION, right after AFTER's binding.
This is like `define-key' except that the binding for KEY is placed
just after the binding for the event AFTER, instead of at the beginning
of the map.
The order matters when the keymap is used as a menu.
KEY must contain just one event type--it must be a string or vector
of length 1.
Fkeyboard-translate
Translate character FROM to TO at a low level.
This function creates a `keyboard-translate-table' if necessary
and then modifies one entry in it.
Vglobal-map
Default global keymap mapping Emacs keyboard input into commands.
The value is a keymap which is usually (but not necessarily) Emacs's
global map.
Vesc-map
Default keymap for ESC (meta) commands.
The normal global definition of the character ESC indirects to this keymap.
Vctl-x-map
Default keymap for C-x commands.
The normal global definition of the character C-x indirects to this keymap.
Vctl-x-4-map
Keymap for subcommands of C-x 4
Vctl-x-5-map
Keymap for frame commands.
Flistify-key-sequence
Convert a key sequence to a list of events.
Feventp
True if the argument is an event object.
Fevent-modifiers
Returns a list of symbols representing the modifier keys in event EVENT.
The elements of the list may include `meta', `control',
`shift', `hyper', `super', `alt', `click', `drag', and `down'.
Fevent-basic-type
Returns the basic type of the given event (all modifiers removed).
The value is an ASCII printing character (not upper case) or a symbol.
Fmouse-movement-p
Return non-nil if OBJECT is a mouse movement event.
Fevent-start
Return the starting position of EVENT.
If EVENT is a mouse press or a mouse click, this returns the location
of the event.
If EVENT is a drag, this returns the drag's starting position.
The return value is of the form
   (WINDOW BUFFER-POSITION (COL . ROW) TIMESTAMP)
The `posn-' functions access elements of such lists.
Fevent-end
Return the ending location of EVENT.  EVENT should be a click or drag event.
If EVENT is a click event, this function is the same as `event-start'.
The return value is of the form
   (WINDOW BUFFER-POSITION (COL . ROW) TIMESTAMP)
The `posn-' functions access elements of such lists.
Fposn-window
Return the window in POSITION.
POSITION should be a list of the form
   (WINDOW BUFFER-POSITION (COL . ROW) TIMESTAMP)
as returned by the `event-start' and `event-end' functions.
Fposn-point
Return the buffer location in POSITION.
POSITION should be a list of the form
   (WINDOW BUFFER-POSITION (COL . ROW) TIMESTAMP)
as returned by the `event-start' and `event-end' functions.
Fposn-col-row
Return the row and column in POSITION.
POSITION should be a list of the form
   (WINDOW BUFFER-POSITION (COL . ROW) TIMESTAMP)
as returned by the `event-start' and `event-end' functions.
Fposn-timestamp
Return the timestamp of POSITION.
POSITION should be a list of the form
   (WINDOW BUFFER-POSITION (COL . ROW) TIMESTAMP)
as returned by the `event-start' and `event-end' functions.
Fbaud-rate
Obsolete function returning the value of the `baud-rate' variable.
Please convert your programs to use the variable `baud-rate' directly.
Frun-hooks
Takes hook names and runs each one in turn.  Major mode functions use this.
Each argument should be a symbol, a hook variable.
These symbols are processed in the order specified.
If a hook symbol has a non-nil value, that value may be a function
or a list of functions to be called to run the hook.
If the value is a function, it is called with no arguments.
If it is a list, the elements are called, in order, with no arguments.
Vrun-hooks
Variable by which C primitives find the function `run-hooks'.
Don't change it.
Fadd-hook
Add to the value of HOOK the function FUNCTION unless already present (it
becomes the first hook on the list unless optional APPEND is non-nil, in
which case it becomes the last).  HOOK should be a symbol, and FUNCTION may be
any valid function.  HOOK's value should be a list of functions, not a single
function.  If HOOK is void, it is first set to nil.
Feval-after-load
Arrange that, if FILE is ever loaded, FORM will be run at that time.
This makes or adds to an entry on `after-load-alist'.
FILE should be the name of a library, with no directory name.
Feval-next-after-load
Read the following input sexp, and run it whenever FILE is loaded.
This makes or adds to an entry on `after-load-alist'.
FILE should be the name of a library, with no directory name.
Fread-quoted-char
Like `read-char', except that if the first character read is an octal
digit, we read up to two more octal digits and return the character
represented by the octal number consisting of those digits.
Optional argument PROMPT specifies a string to use to prompt the user.
Fforce-mode-line-update
Force the mode-line of the current buffer to be redisplayed.
With optional non-nil ALL then force then force redisplay of all mode-lines.
Fmomentary-string-display
Momentarily display STRING in the buffer at POS.
Display remains until next character is typed.
If the char is EXIT-CHAR (optional third arg, default is SPC) it is swallowed;
otherwise it is then available as input (as a command if nothing else).
Display MESSAGE (optional fourth arg) in the echo area.
If MESSAGE is nil, instructions to type EXIT-CHAR are displayed there.
Fignore
Do nothing.
Accept any number of arguments, but ignore them.
Ferror
Signal an error, making error message by passing all args to `format'.
Fuser-original-login-name
Return user's login name from original login.
This tries to remain unaffected by `su', by looking in environment variables.
Fstart-process-shell-command
Start a program in a subprocess.  Return the process object for it.
Args are NAME BUFFER COMMAND &rest COMMAND-ARGS.
NAME is name for process.  It is modified if necessary to make it unique.
BUFFER is the buffer or (buffer-name) to associate with the process.
 Process output goes at end of that buffer, unless you specify
 an output stream or filter function to handle the output.
 BUFFER may be also nil, meaning that this process is not associated
 with any buffer
Third arg is command name, the name of a shell command.
Remaining arguments are the arguments for the command.
Wildcards and redirection are handle as usual in the shell.
Fsave-match-data
Execute the BODY forms, restoring the global value of the match data.
Vtext-mode-syntax-table
Syntax table used while in text mode.
Vtext-mode-abbrev-table
Abbrev table used while in text mode.
Vtext-mode-map
Keymap for Text mode.
Many other modes, such as Mail mode, Outline mode and Indented Text mode,
inherit all the commands defined in this map.
Ftext-mode
Major mode for editing text intended for humans to read.  Special commands:\{text-mode-map}
Turning on Text mode calls the value of the variable `text-mode-hook',
if that value is non-nil.
Vindented-text-mode-map
Keymap for Indented Text mode.
All the commands defined in Text mode are inherited unless overridden.
Findented-text-mode
Major mode for editing indented text intended for humans to read.\{indented-text-mode-map}
Turning on `indented-text-mode' calls the value of the variable
`text-mode-hook', if that value is non-nil.
Fcenter-paragraph
Center each nonblank line in the paragraph at or after point.
See `center-line' for more info.
Fcenter-region
Center each nonblank line starting in the region.
See `center-line' for more info.
Fcenter-line
Center the line point is on, within the width specified by `fill-column'.
This means adjusting the indentation so that it equals
the distance between the end of the text and `fill-column'.
Vvc-master-templates
*Where to look for version-control master files.
The first pair corresponding to a given back end is used as a template
when creating new masters.
Vvc-make-backup-files
*If non-nil, backups of registered files are made according to
the make-backup-files variable.  Otherwise, prevents backups being made.
Vvc-rcs-status
*If non-nil, revision and locks on RCS working file displayed in modeline.
Otherwise, not displayed.
Vvc-file-prop-obarray
Obarray for per-file properties.
Fvc-name
Return the master name of a file, nil if it is not registered.
Fvc-backend-deduce
Return the version-control type of a file, nil if it is not registered.
Fvc-toggle-read-only
Change read-only status of current buffer, perhaps via version control.
If the buffer is visiting a file registered with version control,
then check the file in or out.  Otherwise, just change the read-only flag
of the buffer.
Fvc-mode-line
Set `vc-mode' to display type of version control for FILE.
The value is set in the current buffer, which should be the buffer
visiting FILE.
Fvc-file-not-found-hook
When file is not found, try to check it out from RCS or SCCS.
Returns t if checkout was successful, nil otherwise.
Freplace-char-in-string
Replace in string STR character C1 with character C2 and return STR.
This function does *not* copy the string.
Fmake-legal-file-name
Turn FN into a legal file name and return the modified copy of the string.
The characters * and ? will be replaced with _.
Fmake-auto-save-file-name
Return file name to use for auto-saves of current buffer.
Does not consider auto-save-visited-file-name; that is checked
before calling this function.
This has been redefined for customization.
See also auto-save-file-name-p.
Fmake-backup-file-name
Create the non-numeric backup file name for FILE.
This is a separate function so you can redefine it for customization.
Fsplit-file-name
Split NAME into directory part, base name part and extension.
Return a list containing three elements. If a part is empty, the list element
is nil.
Fadd-to-fat-file-name
Concatenate PREFIX, FILE and SUFFIX, then make it FAT compatible.
It is assumed that FILE is already compatible with the FAT file system.
Femx-dired-kur-ls-setup
Customize dired to Kai Uwe Rommel's ls for OS/2.
Fcmd
Run CMD.EXE with I/O through buffer *cmd*.
Femx-forward-to-word
Move forward until encountering the beginning of a word.
With argument, do this that many times.
Femx-backward-to-word
Move backward until encountering the beginning of a word.
With argument, do this that many times.
Femx-beginning-of-buffer
Move to the beginning of the buffer without setting mark.
Femx-end-of-buffer
Move to end of the buffer without setting mark.
Femx-scroll-line-up
Scroll up by one line.
With argument, do this that many times.
Femx-scroll-line-down
Scroll down by one line.
With argument, do this that many times.
Femx-kill-left-line
Kill from the beginning of the line to point.
Femx-kill-word
Delete characters until encountering the beginning of a word.
With argument, do this that many times.
Femx-copy-line-as-kill
Copy current line as kill.
With argument, copy that many lines starting with the current line.
Femx-dup-line
Duplicate current line.
Set mark to the beginning of the new line.
With argument, do this that many times.
Femx-copy-region
Copy region to point.
With argument, do this that many times.
Femx-yank-line
Yank as line: Move to beginning of current line and yank.
Insert newline if not present. The argument is passed to the yank command.
Femx-match-paren
Go to the matching parenthesis if on parenthesis.
This function uses the syntax table.
Femx-toggle-case-fold-search
Toggle and display the case-fold-search variable.
Vemx-search-string
Search string for emx-search-forward and emx-search-backward.
Vemx-search-re
Non-nil means use regular expression for emx-search-forward and -backward.
Vemx-search-goto-first-line
*Non-nil means display match at the top of the window.
Femx-search-forward
Search forward for a string.
If prefixed by \[universal-argument], ask for search string.
If prefixed by \[universal-argument] \[universal-argument], use regular expression.
Femx-search-backward
Search backward for a string.
If prefixed by \[universal-argument], ask for search string.
If prefixed by \[universal-argument] \[universal-argument], use
regular expression.
Femx-search-fb
Search forward or backward for a string.
If the first argument is nil, ask for the string.
The second argument is search-forward or search-backward.
The third argument is re-search-forward or re-search-backward.
See also the documentation of the emx-search-goto-first-line variable.
Femx-search-forward-at-point
Search forward for name around or before point.
Femx-search-backward-at-point
Search backward for name around or before point.
Femx-search-forward-region
Search forward for string given by region.
With prefix arg, use regular expression.
Femx-search-backward-region
Search backward for string given by region.
With prefix arg, use regular expression.
Femx-buffer-file-name
Display the name of the file visited in current buffer.
Femx-extract-file-name
Return the file name around or before point.
If AT-POINT is not nil, the file names starts at point, that is, characters
before point are ignored.
Femx-find-file-at-point
Find file whose name is around or before point.
With prefix argument find file whose name starts at point.
Femx-find-file-region
Find file whose name is given by region.
Femx-fill-paragraph
Fill paragraph at or before point using em's notion of a paragraph.
Prefix arg means justify as well.
Paragraphs are separated by blank lines. The indentation of the first
line is used for indenting the entire paragraph. If there are two
consecutive blanks (or a tab) in the first line of the paragraphs,
everything to the left of these blanks (or the tab) is left as-is and
the paragraph is indented to the first non-blank character after the
first two consecutive blanks of the first line.
Vemx-add-number
The number used by the emx-add-number command.
Vemx-add-number-adjust
*Non-nil if emx-add-number should adjust columns.
This is done by adding or removing blanks if the length of the number
has changed.
Femx-add-number
Add a constant to the decimal number at point.
With prefix arg, add that constant. Otherwise add previously used constant.
If there is no previous constant, ask for the constant. To make emx-add-number
ask for a number, use a prefix arg of zero (M-0).
The constant is stored in the emx-add-number variable.

If emx-add-number-adjust is non-nil, blanks are added or removed to keep
columns aligned if the length of the number in the buffer has changed by
adding the constant.

This command is useful for moving controls by adding to coordinates in .rc
files.
Femx-add-number-2
Add NUMBER to the number at point.
Femx-toggle-debug-on-error
Toggle and display the debug-on-error variable.
Femx-function-key
Define a PC function key.
CODE is the scan code, EVENT is the event for that key (a vector).
Fcount-windows
Returns the number of visible windows.
Optional arg NO-MINI non-nil means don't count the minibuffer
even if it is active.
Fbalance-windows
Makes all visible windows the same height (approximately).
Vsplit-window-keep-point
*If non-nil, split windows keeps the original point in both children.
This is often more convenient for editing.
If nil, adjust point in each of the two windows to minimize redisplay.
This is convenient on slow terminals, but point can move strangely.
Fsplit-window-vertically
Split current window into two windows, one above the other.
The uppermost window gets ARG lines and the other gets the rest.
With no argument, split equally or close to it.
Both windows display the same buffer now current.

If the variable split-window-keep-point is non-nil, both new windows
will get the same value of point as the current window.  This is often
more convenient for editing.

Otherwise, we chose window starts so as to minimize the amount of
redisplay; this is convenient on slow terminals.  The new selected
window is the one that the current value of point appears in.  The
value of point can change if the text around point is hidden by the
new mode line.
Fsplit-window-horizontally
Split current window into two windows side by side.
This window becomes the leftmost of the two, and gets
ARG columns.  No arg means split equally.
Fenlarge-window-horizontally
Make current window ARG columns wider.
Fshrink-window-horizontally
Make current window ARG columns narrower.
Fshrink-window-if-larger-than-buffer
Shrink the WINDOW to be as small as possible to display its contents.
Do nothing if the buffer contains more lines than the present window height,
or if some of the window's contents are scrolled out of view.
Vemacs-version
Version numbers of this version of Emacs.
Vemacs-build-time
Time at which Emacs was dumped out.
Femacs-version
Return string describing the version of Emacs that is running.
If optional argument HERE is non-nil, insert string at point.