-This is ../info/lispref.info, produced by makeinfo version 4.0 from
+This is ../info/lispref.info, produced by makeinfo version 4.6 from
lispref/lispref.texi.
INFO-DIR-SECTION XEmacs Editor
Foundation instead of in the original English.
\1f
-File: lispref.info, Node: Handling Errors, Next: Error Symbols, Prev: Processing of Errors, Up: Errors
+File: lispref.info, Node: Index, Prev: Standard Hooks, Up: Top
-Writing Code to Handle Errors
-.............................
-
- The usual effect of signaling an error is to terminate the command
-that is running and return immediately to the XEmacs editor command
-loop. You can arrange to trap errors occurring in a part of your
-program by establishing an error handler, with the special form
-`condition-case'. A simple example looks like this:
-
- (condition-case nil
- (delete-file filename)
- (error nil))
-
-This deletes the file named FILENAME, catching any error and returning
-`nil' if an error occurs.
-
- The second argument of `condition-case' is called the "protected
-form". (In the example above, the protected form is a call to
-`delete-file'.) The error handlers go into effect when this form
-begins execution and are deactivated when this form returns. They
-remain in effect for all the intervening time. In particular, they are
-in effect during the execution of functions called by this form, in
-their subroutines, and so on. This is a good thing, since, strictly
-speaking, errors can be signaled only by Lisp primitives (including
-`signal' and `error') called by the protected form, not by the
-protected form itself.
-
- The arguments after the protected form are handlers. Each handler
-lists one or more "condition names" (which are symbols) to specify
-which errors it will handle. The error symbol specified when an error
-is signaled also defines a list of condition names. A handler applies
-to an error if they have any condition names in common. In the example
-above, there is one handler, and it specifies one condition name,
-`error', which covers all errors.
-
- The search for an applicable handler checks all the established
-handlers starting with the most recently established one. Thus, if two
-nested `condition-case' forms offer to handle the same error, the inner
-of the two will actually handle it.
-
- When an error is handled, control returns to the handler. Before
-this happens, XEmacs unbinds all variable bindings made by binding
-constructs that are being exited and executes the cleanups of all
-`unwind-protect' forms that are exited. Once control arrives at the
-handler, the body of the handler is executed.
-
- After execution of the handler body, execution continues by returning
-from the `condition-case' form. Because the protected form is exited
-completely before execution of the handler, the handler cannot resume
-execution at the point of the error, nor can it examine variable
-bindings that were made within the protected form. All it can do is
-clean up and proceed.
-
- `condition-case' is often used to trap errors that are predictable,
-such as failure to open a file in a call to `insert-file-contents'. It
-is also used to trap errors that are totally unpredictable, such as
-when the program evaluates an expression read from the user.
-
- Even when an error is handled, the debugger may still be called if
-the variable `debug-on-signal' (*note Error Debugging::) is non-`nil'.
-Note that this may yield unpredictable results with code that traps
-expected errors as normal part of its operation. Do not set
-`debug-on-signal' unless you know what you are doing.
-
- Error signaling and handling have some resemblance to `throw' and
-`catch', but they are entirely separate facilities. An error cannot be
-caught by a `catch', and a `throw' cannot be handled by an error
-handler (though using `throw' when there is no suitable `catch' signals
-an error that can be handled).
-
- - Special Form: condition-case var protected-form handlers...
- This special form establishes the error handlers HANDLERS around
- the execution of PROTECTED-FORM. If PROTECTED-FORM executes
- without error, the value it returns becomes the value of the
- `condition-case' form; in this case, the `condition-case' has no
- effect. The `condition-case' form makes a difference when an
- error occurs during PROTECTED-FORM.
-
- Each of the HANDLERS is a list of the form `(CONDITIONS BODY...)'.
- Here CONDITIONS is an error condition name to be handled, or a
- list of condition names; BODY is one or more Lisp expressions to
- be executed when this handler handles an error. Here are examples
- of handlers:
-
- (error nil)
-
- (arith-error (message "Division by zero"))
-
- ((arith-error file-error)
- (message
- "Either division by zero or failure to open a file"))
-
- Each error that occurs has an "error symbol" that describes what
- kind of error it is. The `error-conditions' property of this
- symbol is a list of condition names (*note Error Symbols::). Emacs
- searches all the active `condition-case' forms for a handler that
- specifies one or more of these condition names; the innermost
- matching `condition-case' handles the error. Within this
- `condition-case', the first applicable handler handles the error.
-
- After executing the body of the handler, the `condition-case'
- returns normally, using the value of the last form in the handler
- body as the overall value.
-
- The argument VAR is a variable. `condition-case' does not bind
- this variable when executing the PROTECTED-FORM, only when it
- handles an error. At that time, it binds VAR locally to a list of
- the form `(ERROR-SYMBOL . DATA)', giving the particulars of the
- error. The handler can refer to this list to decide what to do.
- For example, if the error is for failure opening a file, the file
- name is the second element of DATA--the third element of VAR.
-
- If VAR is `nil', that means no variable is bound. Then the error
- symbol and associated data are not available to the handler.
-
- Here is an example of using `condition-case' to handle the error
-that results from dividing by zero. The handler prints out a warning
-message and returns a very large number.
-
- (defun safe-divide (dividend divisor)
- (condition-case err
- ;; Protected form.
- (/ dividend divisor)
- ;; The handler.
- (arith-error ; Condition.
- (princ (format "Arithmetic error: %s" err))
- 1000000)))
- => safe-divide
-
- (safe-divide 5 0)
- -| Arithmetic error: (arith-error)
- => 1000000
-
-The handler specifies condition name `arith-error' so that it will
-handle only division-by-zero errors. Other kinds of errors will not be
-handled, at least not by this `condition-case'. Thus,
-
- (safe-divide nil 3)
- error--> Wrong type argument: integer-or-marker-p, nil
-
- Here is a `condition-case' that catches all kinds of errors,
-including those signaled with `error':
-
- (setq baz 34)
- => 34
-
- (condition-case err
- (if (eq baz 35)
- t
- ;; This is a call to the function `error'.
- (error "Rats! The variable %s was %s, not 35" 'baz baz))
- ;; This is the handler; it is not a form.
- (error (princ (format "The error was: %s" err))
- 2))
- -| The error was: (error "Rats! The variable baz was 34, not 35")
- => 2
-
-\1f
-File: lispref.info, Node: Error Symbols, Prev: Handling Errors, Up: Errors
-
-Error Symbols and Condition Names
-.................................
-
- When you signal an error, you specify an "error symbol" to specify
-the kind of error you have in mind. Each error has one and only one
-error symbol to categorize it. This is the finest classification of
-errors defined by the XEmacs Lisp language.
-
- These narrow classifications are grouped into a hierarchy of wider
-classes called "error conditions", identified by "condition names".
-The narrowest such classes belong to the error symbols themselves: each
-error symbol is also a condition name. There are also condition names
-for more extensive classes, up to the condition name `error' which
-takes in all kinds of errors. Thus, each error has one or more
-condition names: `error', the error symbol if that is distinct from
-`error', and perhaps some intermediate classifications.
-
- In other words, each error condition "inherits" from another error
-condition, with `error' sitting at the top of the inheritance hierarchy.
-
- - Function: define-error error-symbol error-message &optional
- inherits-from
- This function defines a new error, denoted by ERROR-SYMBOL.
- ERROR-MESSAGE is an informative message explaining the error, and
- will be printed out when an unhandled error occurs. ERROR-SYMBOL
- is a sub-error of INHERITS-FROM (which defaults to `error').
-
- `define-error' internally works by putting on ERROR-SYMBOL an
- `error-message' property whose value is ERROR-MESSAGE, and an
- `error-conditions' property that is a list of ERROR-SYMBOL
- followed by each of its super-errors, up to and including `error'.
- You will sometimes see code that sets this up directly rather than
- calling `define-error', but you should _not_ do this yourself,
- unless you wish to maintain compatibility with FSF Emacs, which
- does not provide `define-error'.
-
- Here is how we define a new error symbol, `new-error', that belongs
-to a range of errors called `my-own-errors':
-
- (define-error 'my-own-errors "A whole range of errors" 'error)
- (define-error 'new-error "A new error" 'my-own-errors)
-
-`new-error' has three condition names: `new-error', the narrowest
-classification; `my-own-errors', which we imagine is a wider
-classification; and `error', which is the widest of all.
-
- Note that it is not legal to try to define an error unless its
-super-error is also defined. For instance, attempting to define
-`new-error' before `my-own-errors' are defined will signal an error.
-
- The error string should start with a capital letter but it should
-not end with a period. This is for consistency with the rest of Emacs.
-
- Naturally, XEmacs will never signal `new-error' on its own; only an
-explicit call to `signal' (*note Signaling Errors::) in your code can
-do this:
-
- (signal 'new-error '(x y))
- error--> A new error: x, y
-
- This error can be handled through any of the three condition names.
-This example handles `new-error' and any other errors in the class
-`my-own-errors':
-
- (condition-case foo
- (bar nil t)
- (my-own-errors nil))
-
- The significant way that errors are classified is by their condition
-names--the names used to match errors with handlers. An error symbol
-serves only as a convenient way to specify the intended error message
-and list of condition names. It would be cumbersome to give `signal' a
-list of condition names rather than one error symbol.
-
- By contrast, using only error symbols without condition names would
-seriously decrease the power of `condition-case'. Condition names make
-it possible to categorize errors at various levels of generality when
-you write an error handler. Using error symbols alone would eliminate
-all but the narrowest level of classification.
-
- *Note Standard Errors::, for a list of all the standard error symbols
-and their conditions.
-
-\1f
-File: lispref.info, Node: Cleanups, Prev: Errors, Up: Nonlocal Exits
-
-Cleaning Up from Nonlocal Exits
--------------------------------
-
- The `unwind-protect' construct is essential whenever you temporarily
-put a data structure in an inconsistent state; it permits you to ensure
-the data are consistent in the event of an error or throw.
-
- - Special Form: unwind-protect body cleanup-forms...
- `unwind-protect' executes the BODY with a guarantee that the
- CLEANUP-FORMS will be evaluated if control leaves BODY, no matter
- how that happens. The BODY may complete normally, or execute a
- `throw' out of the `unwind-protect', or cause an error; in all
- cases, the CLEANUP-FORMS will be evaluated.
-
- If the BODY forms finish normally, `unwind-protect' returns the
- value of the last BODY form, after it evaluates the CLEANUP-FORMS.
- If the BODY forms do not finish, `unwind-protect' does not return
- any value in the normal sense.
-
- Only the BODY is actually protected by the `unwind-protect'. If
- any of the CLEANUP-FORMS themselves exits nonlocally (e.g., via a
- `throw' or an error), `unwind-protect' is _not_ guaranteed to
- evaluate the rest of them. If the failure of one of the
- CLEANUP-FORMS has the potential to cause trouble, then protect it
- with another `unwind-protect' around that form.
-
- The number of currently active `unwind-protect' forms counts,
- together with the number of local variable bindings, against the
- limit `max-specpdl-size' (*note Local Variables::).
-
- For example, here we make an invisible buffer for temporary use, and
-make sure to kill it before finishing:
-
- (save-excursion
- (let ((buffer (get-buffer-create " *temp*")))
- (set-buffer buffer)
- (unwind-protect
- BODY
- (kill-buffer buffer))))
-
-You might think that we could just as well write `(kill-buffer
-(current-buffer))' and dispense with the variable `buffer'. However,
-the way shown above is safer, if BODY happens to get an error after
-switching to a different buffer! (Alternatively, you could write
-another `save-excursion' around the body, to ensure that the temporary
-buffer becomes current in time to kill it.)
-
- Here is an actual example taken from the file `ftp.el'. It creates
-a process (*note Processes::) to try to establish a connection to a
-remote machine. As the function `ftp-login' is highly susceptible to
-numerous problems that the writer of the function cannot anticipate, it
-is protected with a form that guarantees deletion of the process in the
-event of failure. Otherwise, XEmacs might fill up with useless
-subprocesses.
-
- (let ((win nil))
- (unwind-protect
- (progn
- (setq process (ftp-setup-buffer host file))
- (if (setq win (ftp-login process host user password))
- (message "Logged in")
- (error "Ftp login failed")))
- (or win (and process (delete-process process)))))
-
- This example actually has a small bug: if the user types `C-g' to
-quit, and the quit happens immediately after the function
-`ftp-setup-buffer' returns but before the variable `process' is set,
-the process will not be killed. There is no easy way to fix this bug,
-but at least it is very unlikely.
-
- Here is another example which uses `unwind-protect' to make sure to
-kill a temporary buffer. In this example, the value returned by
-`unwind-protect' is used.
-
- (defun shell-command-string (cmd)
- "Return the output of the shell command CMD, as a string."
- (save-excursion
- (set-buffer (generate-new-buffer " OS*cmd"))
- (shell-command cmd t)
- (unwind-protect
- (buffer-string)
- (kill-buffer (current-buffer)))))
-
-\1f
-File: lispref.info, Node: Variables, Next: Functions, Prev: Control Structures, Up: Top
-
-Variables
-*********
-
- A "variable" is a name used in a program to stand for a value.
-Nearly all programming languages have variables of some sort. In the
-text of a Lisp program, variables are written using the syntax for
-symbols.
-
- In Lisp, unlike most programming languages, programs are represented
-primarily as Lisp objects and only secondarily as text. The Lisp
-objects used for variables are symbols: the symbol name is the variable
-name, and the variable's value is stored in the value cell of the
-symbol. The use of a symbol as a variable is independent of its use as
-a function name. *Note Symbol Components::.
-
- The Lisp objects that constitute a Lisp program determine the textual
-form of the program--it is simply the read syntax for those Lisp
-objects. This is why, for example, a variable in a textual Lisp program
-is written using the read syntax for the symbol that represents the
-variable.
+Index
+*****
* Menu:
-* Global Variables:: Variable values that exist permanently, everywhere.
-* Constant Variables:: Certain "variables" have values that never change.
-* Local Variables:: Variable values that exist only temporarily.
-* Void Variables:: Symbols that lack values.
-* Defining Variables:: A definition says a symbol is used as a variable.
-* Accessing Variables:: Examining values of variables whose names
- are known only at run time.
-* Setting Variables:: Storing new values in variables.
-* Variable Scoping:: How Lisp chooses among local and global values.
-* Buffer-Local Variables:: Variable values in effect only in one buffer.
-* Variable Aliases:: Making one variable point to another.
-
-\1f
-File: lispref.info, Node: Global Variables, Next: Constant Variables, Up: Variables
-
-Global Variables
-================
-
- The simplest way to use a variable is "globally". This means that
-the variable has just one value at a time, and this value is in effect
-(at least for the moment) throughout the Lisp system. The value remains
-in effect until you specify a new one. When a new value replaces the
-old one, no trace of the old value remains in the variable.
-
- You specify a value for a symbol with `setq'. For example,
-
- (setq x '(a b))
-
-gives the variable `x' the value `(a b)'. Note that `setq' does not
-evaluate its first argument, the name of the variable, but it does
-evaluate the second argument, the new value.
-
- Once the variable has a value, you can refer to it by using the
-symbol by itself as an expression. Thus,
-
- x => (a b)
-
-assuming the `setq' form shown above has already been executed.
-
- If you do another `setq', the new value replaces the old one:
-
- x
- => (a b)
- (setq x 4)
- => 4
- x
- => 4
-
-\1f
-File: lispref.info, Node: Constant Variables, Next: Local Variables, Prev: Global Variables, Up: Variables
-
-Variables That Never Change
-===========================
-
- In XEmacs Lisp, some symbols always evaluate to themselves: the two
-special symbols `nil' and `t', as well as "keyword symbols", that is,
-symbols whose name begins with the character ``:''. These symbols
-cannot be rebound, nor can their value cells be changed. An attempt to
-change the value of `nil' or `t' signals a `setting-constant' error.
-
- nil == 'nil
- => nil
- (setq nil 500)
- error--> Attempt to set constant symbol: nil
-
-\1f
-File: lispref.info, Node: Local Variables, Next: Void Variables, Prev: Constant Variables, Up: Variables
-
-Local Variables
-===============
-
- Global variables have values that last until explicitly superseded
-with new values. Sometimes it is useful to create variable values that
-exist temporarily--only while within a certain part of the program.
-These values are called "local", and the variables so used are called
-"local variables".
-
- For example, when a function is called, its argument variables
-receive new local values that last until the function exits. The `let'
-special form explicitly establishes new local values for specified
-variables; these last until exit from the `let' form.
-
- Establishing a local value saves away the previous value (or lack of
-one) of the variable. When the life span of the local value is over,
-the previous value is restored. In the mean time, we say that the
-previous value is "shadowed" and "not visible". Both global and local
-values may be shadowed (*note Scope::).
-
- If you set a variable (such as with `setq') while it is local, this
-replaces the local value; it does not alter the global value, or
-previous local values that are shadowed. To model this behavior, we
-speak of a "local binding" of the variable as well as a local value.
-
- The local binding is a conceptual place that holds a local value.
-Entry to a function, or a special form such as `let', creates the local
-binding; exit from the function or from the `let' removes the local
-binding. As long as the local binding lasts, the variable's value is
-stored within it. Use of `setq' or `set' while there is a local
-binding stores a different value into the local binding; it does not
-create a new binding.
-
- We also speak of the "global binding", which is where (conceptually)
-the global value is kept.
-
- A variable can have more than one local binding at a time (for
-example, if there are nested `let' forms that bind it). In such a
-case, the most recently created local binding that still exists is the
-"current binding" of the variable. (This is called "dynamic scoping";
-see *Note Variable Scoping::.) If there are no local bindings, the
-variable's global binding is its current binding. We also call the
-current binding the "most-local existing binding", for emphasis.
-Ordinary evaluation of a symbol always returns the value of its current
-binding.
-
- The special forms `let' and `let*' exist to create local bindings.
-
- - Special Form: let (bindings...) forms...
- This special form binds variables according to BINDINGS and then
- evaluates all of the FORMS in textual order. The `let'-form
- returns the value of the last form in FORMS.
-
- Each of the BINDINGS is either (i) a symbol, in which case that
- symbol is bound to `nil'; or (ii) a list of the form `(SYMBOL
- VALUE-FORM)', in which case SYMBOL is bound to the result of
- evaluating VALUE-FORM. If VALUE-FORM is omitted, `nil' is used.
-
- All of the VALUE-FORMs in BINDINGS are evaluated in the order they
- appear and _before_ any of the symbols are bound. Here is an
- example of this: `Z' is bound to the old value of `Y', which is 2,
- not the new value, 1.
-
- (setq Y 2)
- => 2
- (let ((Y 1)
- (Z Y))
- (list Y Z))
- => (1 2)
-
- - Special Form: let* (bindings...) forms...
- This special form is like `let', but it binds each variable right
- after computing its local value, before computing the local value
- for the next variable. Therefore, an expression in BINDINGS can
- reasonably refer to the preceding symbols bound in this `let*'
- form. Compare the following example with the example above for
- `let'.
-
- (setq Y 2)
- => 2
- (let* ((Y 1)
- (Z Y)) ; Use the just-established value of `Y'.
- (list Y Z))
- => (1 1)
-
- Here is a complete list of the other facilities that create local
-bindings:
-
- * Function calls (*note Functions::).
-
- * Macro calls (*note Macros::).
-
- * `condition-case' (*note Errors::).
-
- Variables can also have buffer-local bindings (*note Buffer-Local
-Variables::). These kinds of bindings work somewhat like ordinary local
-bindings, but they are localized depending on "where" you are in Emacs,
-rather than localized in time.
-
- - Variable: max-specpdl-size
- This variable defines the limit on the total number of local
- variable bindings and `unwind-protect' cleanups (*note Nonlocal
- Exits::) that are allowed before signaling an error (with data
- `"Variable binding depth exceeds max-specpdl-size"').
-
- This limit, with the associated error when it is exceeded, is one
- way that Lisp avoids infinite recursion on an ill-defined function.
-
- The default value is 3000.
-
- `max-lisp-eval-depth' provides another limit on depth of nesting.
- *Note Eval::.
-
-\1f
-File: lispref.info, Node: Void Variables, Next: Defining Variables, Prev: Local Variables, Up: Variables
-
-When a Variable is "Void"
-=========================
-
- If you have never given a symbol any value as a global variable, we
-say that that symbol's global value is "void". In other words, the
-symbol's value cell does not have any Lisp object in it. If you try to
-evaluate the symbol, you get a `void-variable' error rather than a
-value.
-
- Note that a value of `nil' is not the same as void. The symbol
-`nil' is a Lisp object and can be the value of a variable just as any
-other object can be; but it is _a value_. A void variable does not
-have any value.
-
- After you have given a variable a value, you can make it void once
-more using `makunbound'.
-
- - Function: makunbound symbol
- This function makes the current binding of SYMBOL void.
- Subsequent attempts to use this symbol's value as a variable will
- signal the error `void-variable', unless or until you set it again.
-
- `makunbound' returns SYMBOL.
-
- (makunbound 'x) ; Make the global value
- ; of `x' void.
- => x
- x
- error--> Symbol's value as variable is void: x
-
- If SYMBOL is locally bound, `makunbound' affects the most local
- existing binding. This is the only way a symbol can have a void
- local binding, since all the constructs that create local bindings
- create them with values. In this case, the voidness lasts at most
- as long as the binding does; when the binding is removed due to
- exit from the construct that made it, the previous or global
- binding is reexposed as usual, and the variable is no longer void
- unless the newly reexposed binding was void all along.
-
- (setq x 1) ; Put a value in the global binding.
- => 1
- (let ((x 2)) ; Locally bind it.
- (makunbound 'x) ; Void the local binding.
- x)
- error--> Symbol's value as variable is void: x
- x ; The global binding is unchanged.
- => 1
-
- (let ((x 2)) ; Locally bind it.
- (let ((x 3)) ; And again.
- (makunbound 'x) ; Void the innermost-local binding.
- x)) ; And refer: it's void.
- error--> Symbol's value as variable is void: x
-
- (let ((x 2))
- (let ((x 3))
- (makunbound 'x)) ; Void inner binding, then remove it.
- x) ; Now outer `let' binding is visible.
- => 2
-
- A variable that has been made void with `makunbound' is
-indistinguishable from one that has never received a value and has
-always been void.
-
- You can use the function `boundp' to test whether a variable is
-currently void.
-
- - Function: boundp variable
- `boundp' returns `t' if VARIABLE (a symbol) is not void; more
- precisely, if its current binding is not void. It returns `nil'
- otherwise.
-
- (boundp 'abracadabra) ; Starts out void.
- => nil
- (let ((abracadabra 5)) ; Locally bind it.
- (boundp 'abracadabra))
- => t
- (boundp 'abracadabra) ; Still globally void.
- => nil
- (setq abracadabra 5) ; Make it globally nonvoid.
- => 5
- (boundp 'abracadabra)
- => t
-
-\1f
-File: lispref.info, Node: Defining Variables, Next: Accessing Variables, Prev: Void Variables, Up: Variables
-
-Defining Global Variables
-=========================
-
- You may announce your intention to use a symbol as a global variable
-with a "variable definition": a special form, either `defconst' or
-`defvar'.
-
- In XEmacs Lisp, definitions serve three purposes. First, they inform
-people who read the code that certain symbols are _intended_ to be used
-a certain way (as variables). Second, they inform the Lisp system of
-these things, supplying a value and documentation. Third, they provide
-information to utilities such as `etags' and `make-docfile', which
-create data bases of the functions and variables in a program.
-
- The difference between `defconst' and `defvar' is primarily a matter
-of intent, serving to inform human readers of whether programs will
-change the variable. XEmacs Lisp does not restrict the ways in which a
-variable can be used based on `defconst' or `defvar' declarations.
-However, it does make a difference for initialization: `defconst'
-unconditionally initializes the variable, while `defvar' initializes it
-only if it is void.
-
- One would expect user option variables to be defined with
-`defconst', since programs do not change them. Unfortunately, this has
-bad results if the definition is in a library that is not preloaded:
-`defconst' would override any prior value when the library is loaded.
-Users would like to be able to set user options in their init files,
-and override the default values given in the definitions. For this
-reason, user options must be defined with `defvar'.
-
- - Special Form: defvar symbol [value [doc-string]]
- This special form defines SYMBOL as a value and initializes it.
- The definition informs a person reading your code that SYMBOL is
- used as a variable that programs are likely to set or change. It
- is also used for all user option variables except in the preloaded
- parts of XEmacs. Note that SYMBOL is not evaluated; the symbol to
- be defined must appear explicitly in the `defvar'.
-
- If SYMBOL already has a value (i.e., it is not void), VALUE is not
- even evaluated, and SYMBOL's value remains unchanged. If SYMBOL
- is void and VALUE is specified, `defvar' evaluates it and sets
- SYMBOL to the result. (If VALUE is omitted, the value of SYMBOL
- is not changed in any case.)
-
- When you evaluate a top-level `defvar' form with `C-M-x' in Emacs
- Lisp mode (`eval-defun'), a special feature of `eval-defun'
- evaluates it as a `defconst'. The purpose of this is to make sure
- the variable's value is reinitialized, when you ask for it
- specifically.
-
- If SYMBOL has a buffer-local binding in the current buffer,
- `defvar' sets the default value, not the local value. *Note
- Buffer-Local Variables::.
-
- If the DOC-STRING argument appears, it specifies the documentation
- for the variable. (This opportunity to specify documentation is
- one of the main benefits of defining the variable.) The
- documentation is stored in the symbol's `variable-documentation'
- property. The XEmacs help functions (*note Documentation::) look
- for this property.
-
- If the first character of DOC-STRING is `*', it means that this
- variable is considered a user option. This lets users set the
- variable conveniently using the commands `set-variable' and
- `edit-options'.
-
- For example, this form defines `foo' but does not set its value:
-
- (defvar foo)
- => foo
-
- The following example sets the value of `bar' to `23', and gives
- it a documentation string:
-
- (defvar bar 23
- "The normal weight of a bar.")
- => bar
-
- The following form changes the documentation string for `bar',
- making it a user option, but does not change the value, since `bar'
- already has a value. (The addition `(1+ 23)' is not even
- performed.)
-
- (defvar bar (1+ 23)
- "*The normal weight of a bar.")
- => bar
- bar
- => 23
-
- Here is an equivalent expression for the `defvar' special form:
-
- (defvar SYMBOL VALUE DOC-STRING)
- ==
- (progn
- (if (not (boundp 'SYMBOL))
- (setq SYMBOL VALUE))
- (put 'SYMBOL 'variable-documentation 'DOC-STRING)
- 'SYMBOL)
-
- The `defvar' form returns SYMBOL, but it is normally used at top
- level in a file where its value does not matter.
-
- - Special Form: defconst symbol [value [doc-string]]
- This special form defines SYMBOL as a value and initializes it.
- It informs a person reading your code that SYMBOL has a global
- value, established here, that will not normally be changed or
- locally bound by the execution of the program. The user, however,
- may be welcome to change it. Note that SYMBOL is not evaluated;
- the symbol to be defined must appear explicitly in the `defconst'.
-
- `defconst' always evaluates VALUE and sets the global value of
- SYMBOL to the result, provided VALUE is given. If SYMBOL has a
- buffer-local binding in the current buffer, `defconst' sets the
- default value, not the local value.
-
- *Please note:* Don't use `defconst' for user option variables in
- libraries that are not standardly preloaded. The user should be
- able to specify a value for such a variable in the `.emacs' file,
- so that it will be in effect if and when the library is loaded
- later.
-
- Here, `pi' is a constant that presumably ought not to be changed
- by anyone (attempts by the Indiana State Legislature
- notwithstanding). As the second form illustrates, however, this
- is only advisory.
-
- (defconst pi 3.1415 "Pi to five places.")
- => pi
- (setq pi 3)
- => pi
- pi
- => 3
-
- - Function: user-variable-p variable
- This function returns `t' if VARIABLE is a user option--a variable
- intended to be set by the user for customization--and `nil'
- otherwise. (Variables other than user options exist for the
- internal purposes of Lisp programs, and users need not know about
- them.)
-
- User option variables are distinguished from other variables by the
- first character of the `variable-documentation' property. If the
- property exists and is a string, and its first character is `*',
- then the variable is a user option.
-
- If a user option variable has a `variable-interactive' property, the
-`set-variable' command uses that value to control reading the new value
-for the variable. The property's value is used as if it were the
-argument to `interactive'.
-
- *Warning:* If the `defconst' and `defvar' special forms are used
-while the variable has a local binding, they set the local binding's
-value; the global binding is not changed. This is not what we really
-want. To prevent it, use these special forms at top level in a file,
-where normally no local binding is in effect, and make sure to load the
-file before making a local binding for the variable.
-
-\1f
-File: lispref.info, Node: Accessing Variables, Next: Setting Variables, Prev: Defining Variables, Up: Variables
-
-Accessing Variable Values
-=========================
-
- The usual way to reference a variable is to write the symbol which
-names it (*note Symbol Forms::). This requires you to specify the
-variable name when you write the program. Usually that is exactly what
-you want to do. Occasionally you need to choose at run time which
-variable to reference; then you can use `symbol-value'.
-
- - Function: symbol-value symbol
- This function returns the value of SYMBOL. This is the value in
- the innermost local binding of the symbol, or its global value if
- it has no local bindings.
-
- (setq abracadabra 5)
- => 5
- (setq foo 9)
- => 9
-
- ;; Here the symbol `abracadabra'
- ;; is the symbol whose value is examined.
- (let ((abracadabra 'foo))
- (symbol-value 'abracadabra))
- => foo
-
- ;; Here the value of `abracadabra',
- ;; which is `foo',
- ;; is the symbol whose value is examined.
- (let ((abracadabra 'foo))
- (symbol-value abracadabra))
- => 9
-
- (symbol-value 'abracadabra)
- => 5
-
- A `void-variable' error is signaled if SYMBOL has neither a local
- binding nor a global value.
-
-\1f
-File: lispref.info, Node: Setting Variables, Next: Variable Scoping, Prev: Accessing Variables, Up: Variables
-
-How to Alter a Variable Value
-=============================
-
- The usual way to change the value of a variable is with the special
-form `setq'. When you need to compute the choice of variable at run
-time, use the function `set'.
-
- - Special Form: setq [symbol form]...
- This special form is the most common method of changing a
- variable's value. Each SYMBOL is given a new value, which is the
- result of evaluating the corresponding FORM. The most-local
- existing binding of the symbol is changed.
-
- `setq' does not evaluate SYMBOL; it sets the symbol that you
- write. We say that this argument is "automatically quoted". The
- `q' in `setq' stands for "quoted."
-
- The value of the `setq' form is the value of the last FORM.
-
- (setq x (1+ 2))
- => 3
- x ; `x' now has a global value.
- => 3
- (let ((x 5))
- (setq x 6) ; The local binding of `x' is set.
- x)
- => 6
- x ; The global value is unchanged.
- => 3
-
- Note that the first FORM is evaluated, then the first SYMBOL is
- set, then the second FORM is evaluated, then the second SYMBOL is
- set, and so on:
-
- (setq x 10 ; Notice that `x' is set before
- y (1+ x)) ; the value of `y' is computed.
- => 11
-
- - Function: set symbol value
- This function sets SYMBOL's value to VALUE, then returns VALUE.
- Since `set' is a function, the expression written for SYMBOL is
- evaluated to obtain the symbol to set.
-
- The most-local existing binding of the variable is the binding
- that is set; shadowed bindings are not affected.
-
- (set one 1)
- error--> Symbol's value as variable is void: one
- (set 'one 1)
- => 1
- (set 'two 'one)
- => one
- (set two 2) ; `two' evaluates to symbol `one'.
- => 2
- one ; So it is `one' that was set.
- => 2
- (let ((one 1)) ; This binding of `one' is set,
- (set 'one 3) ; not the global value.
- one)
- => 3
- one
- => 2
-
- If SYMBOL is not actually a symbol, a `wrong-type-argument' error
- is signaled.
-
- (set '(x y) 'z)
- error--> Wrong type argument: symbolp, (x y)
-
- Logically speaking, `set' is a more fundamental primitive than
- `setq'. Any use of `setq' can be trivially rewritten to use
- `set'; `setq' could even be defined as a macro, given the
- availability of `set'. However, `set' itself is rarely used;
- beginners hardly need to know about it. It is useful only for
- choosing at run time which variable to set. For example, the
- command `set-variable', which reads a variable name from the user
- and then sets the variable, needs to use `set'.
-
- Common Lisp note: In Common Lisp, `set' always changes the
- symbol's special value, ignoring any lexical bindings. In
- XEmacs Lisp, all variables and all bindings are (in effect)
- special, so `set' always affects the most local existing
- binding.
-
- One other function for setting a variable is designed to add an
-element to a list if it is not already present in the list.
-
- - Function: add-to-list symbol element
- This function sets the variable SYMBOL by consing ELEMENT onto the
- old value, if ELEMENT is not already a member of that value. It
- returns the resulting list, whether updated or not. The value of
- SYMBOL had better be a list already before the call.
-
- The argument SYMBOL is not implicitly quoted; `add-to-list' is an
- ordinary function, like `set' and unlike `setq'. Quote the
- argument yourself if that is what you want.
-
- Here's a scenario showing how to use `add-to-list':
-
- (setq foo '(a b))
- => (a b)
-
- (add-to-list 'foo 'c) ;; Add `c'.
- => (c a b)
-
- (add-to-list 'foo 'b) ;; No effect.
- => (c a b)
-
- foo ;; `foo' was changed.
- => (c a b)
-
- An equivalent expression for `(add-to-list 'VAR VALUE)' is this:
-
- (or (member VALUE VAR)
- (setq VAR (cons VALUE VAR)))
-
-\1f
-File: lispref.info, Node: Variable Scoping, Next: Buffer-Local Variables, Prev: Setting Variables, Up: Variables
-
-Scoping Rules for Variable Bindings
-===================================
-
- A given symbol `foo' may have several local variable bindings,
-established at different places in the Lisp program, as well as a global
-binding. The most recently established binding takes precedence over
-the others.
-
- Local bindings in XEmacs Lisp have "indefinite scope" and "dynamic
-extent". "Scope" refers to _where_ textually in the source code the
-binding can be accessed. Indefinite scope means that any part of the
-program can potentially access the variable binding. "Extent" refers
-to _when_, as the program is executing, the binding exists. Dynamic
-extent means that the binding lasts as long as the activation of the
-construct that established it.
-
- The combination of dynamic extent and indefinite scope is called
-"dynamic scoping". By contrast, most programming languages use
-"lexical scoping", in which references to a local variable must be
-located textually within the function or block that binds the variable.
-
- Common Lisp note: Variables declared "special" in Common Lisp are
- dynamically scoped, like variables in XEmacs Lisp.
-
-* Menu:
-
-* Scope:: Scope means where in the program a value is visible.
- Comparison with other languages.
-* Extent:: Extent means how long in time a value exists.
-* Impl of Scope:: Two ways to implement dynamic scoping.
-* Using Scoping:: How to use dynamic scoping carefully and avoid problems.
-
-\1f
-File: lispref.info, Node: Scope, Next: Extent, Up: Variable Scoping
-
-Scope
------
-
- XEmacs Lisp uses "indefinite scope" for local variable bindings.
-This means that any function anywhere in the program text might access a
-given binding of a variable. Consider the following function
-definitions:
-
- (defun binder (x) ; `x' is bound in `binder'.
- (foo 5)) ; `foo' is some other function.
-
- (defun user () ; `x' is used in `user'.
- (list x))
-
- In a lexically scoped language, the binding of `x' in `binder' would
-never be accessible in `user', because `user' is not textually
-contained within the function `binder'. However, in dynamically scoped
-XEmacs Lisp, `user' may or may not refer to the binding of `x'
-established in `binder', depending on circumstances:
-
- * If we call `user' directly without calling `binder' at all, then
- whatever binding of `x' is found, it cannot come from `binder'.
-
- * If we define `foo' as follows and call `binder', then the binding
- made in `binder' will be seen in `user':
-
- (defun foo (lose)
- (user))
-
- * If we define `foo' as follows and call `binder', then the binding
- made in `binder' _will not_ be seen in `user':
-
- (defun foo (x)
- (user))
-
- Here, when `foo' is called by `binder', it binds `x'. (The
- binding in `foo' is said to "shadow" the one made in `binder'.)
- Therefore, `user' will access the `x' bound by `foo' instead of
- the one bound by `binder'.
-
-\1f
-File: lispref.info, Node: Extent, Next: Impl of Scope, Prev: Scope, Up: Variable Scoping
-
-Extent
-------
-
- "Extent" refers to the time during program execution that a variable
-name is valid. In XEmacs Lisp, a variable is valid only while the form
-that bound it is executing. This is called "dynamic extent". "Local"
-or "automatic" variables in most languages, including C and Pascal,
-have dynamic extent.
-
- One alternative to dynamic extent is "indefinite extent". This
-means that a variable binding can live on past the exit from the form
-that made the binding. Common Lisp and Scheme, for example, support
-this, but XEmacs Lisp does not.
-
- To illustrate this, the function below, `make-add', returns a
-function that purports to add N to its own argument M. This would work
-in Common Lisp, but it does not work as intended in XEmacs Lisp,
-because after the call to `make-add' exits, the variable `n' is no
-longer bound to the actual argument 2.
-
- (defun make-add (n)
- (function (lambda (m) (+ n m)))) ; Return a function.
- => make-add
- (fset 'add2 (make-add 2)) ; Define function `add2'
- ; with `(make-add 2)'.
- => (lambda (m) (+ n m))
- (add2 4) ; Try to add 2 to 4.
- error--> Symbol's value as variable is void: n
-
- Some Lisp dialects have "closures", objects that are like functions
-but record additional variable bindings. XEmacs Lisp does not have
-closures.
-
-\1f
-File: lispref.info, Node: Impl of Scope, Next: Using Scoping, Prev: Extent, Up: Variable Scoping
-
-Implementation of Dynamic Scoping
----------------------------------
-
- A simple sample implementation (which is not how XEmacs Lisp actually
-works) may help you understand dynamic binding. This technique is
-called "deep binding" and was used in early Lisp systems.
-
- Suppose there is a stack of bindings: variable-value pairs. At entry
-to a function or to a `let' form, we can push bindings on the stack for
-the arguments or local variables created there. We can pop those
-bindings from the stack at exit from the binding construct.
-
- We can find the value of a variable by searching the stack from top
-to bottom for a binding for that variable; the value from that binding
-is the value of the variable. To set the variable, we search for the
-current binding, then store the new value into that binding.
-
- As you can see, a function's bindings remain in effect as long as it
-continues execution, even during its calls to other functions. That is
-why we say the extent of the binding is dynamic. And any other function
-can refer to the bindings, if it uses the same variables while the
-bindings are in effect. That is why we say the scope is indefinite.
-
- The actual implementation of variable scoping in XEmacs Lisp uses a
-technique called "shallow binding". Each variable has a standard place
-in which its current value is always found--the value cell of the
-symbol.
-
- In shallow binding, setting the variable works by storing a value in
-the value cell. Creating a new binding works by pushing the old value
-(belonging to a previous binding) on a stack, and storing the local
-value in the value cell. Eliminating a binding works by popping the
-old value off the stack, into the value cell.
-
- We use shallow binding because it has the same results as deep
-binding, but runs faster, since there is never a need to search for a
-binding.
-
-\1f
-File: lispref.info, Node: Using Scoping, Prev: Impl of Scope, Up: Variable Scoping
-
-Proper Use of Dynamic Scoping
------------------------------
-
- Binding a variable in one function and using it in another is a
-powerful technique, but if used without restraint, it can make programs
-hard to understand. There are two clean ways to use this technique:
-
- * Use or bind the variable only in a few related functions, written
- close together in one file. Such a variable is used for
- communication within one program.
-
- You should write comments to inform other programmers that they
- can see all uses of the variable before them, and to advise them
- not to add uses elsewhere.
-
- * Give the variable a well-defined, documented meaning, and make all
- appropriate functions refer to it (but not bind it or set it)
- wherever that meaning is relevant. For example, the variable
- `case-fold-search' is defined as "non-`nil' means ignore case when
- searching"; various search and replace functions refer to it
- directly or through their subroutines, but do not bind or set it.
-
- Then you can bind the variable in other programs, knowing reliably
- what the effect will be.
-
- In either case, you should define the variable with `defvar'. This
-helps other people understand your program by telling them to look for
-inter-function usage. It also avoids a warning from the byte compiler.
-Choose the variable's name to avoid name conflicts--don't use short
-names like `x'.
-
-\1f
-File: lispref.info, Node: Buffer-Local Variables, Next: Variable Aliases, Prev: Variable Scoping, Up: Variables
-
-Buffer-Local Variables
-======================
-
- Global and local variable bindings are found in most programming
-languages in one form or another. XEmacs also supports another, unusual
-kind of variable binding: "buffer-local" bindings, which apply only to
-one buffer. XEmacs Lisp is meant for programming editing commands, and
-having different values for a variable in different buffers is an
-important customization method.
-
-* Menu:
+* " in printing: Output Functions.
+* " in strings: String Type.
+* #$: Docs and Compilation.
+* #@COUNT: Docs and Compilation.
+* $ in display: Truncation.
+* $ in regexp: Syntax of Regexps.
+* %: Arithmetic Operations.
+* % in format: Formatting Strings.
+* & in replacement: Replacing Match.
+* &define (Edebug): Specification List.
+* ¬ (Edebug): Specification List.
+* &optional: Argument List.
+* &optional (Edebug): Specification List.
+* &or (Edebug): Specification List.
+* &rest: Argument List.
+* &rest (Edebug): Specification List.
+* ' for quoting: Quoting.
+* ( in regexp: Syntax of Regexps.
+* (...) in lists: Cons Cell Type.
+* ) in regexp: Syntax of Regexps.
+* *: Arithmetic Operations.
+* * in interactive: Using Interactive.
+* * in regexp: Syntax of Regexps.
+* *? in regexp: Syntax of Regexps.
+* *PQfn: Unimplemented libpq Functions.
+* *PQoidStatus: Unimplemented libpq Functions.
+* *PQsetdb: Unimplemented libpq Functions.
+* *PQsetdbLogin: Unimplemented libpq Functions.
+* *scratch*: Auto Major Mode.
+* +: Arithmetic Operations.
+* + in regexp: Syntax of Regexps.
+* +? in regexp: Syntax of Regexps.
+* , (with Backquote): Backquote.
+* ,@ (with Backquote): Backquote.
+* -: Arithmetic Operations.
+* . in lists: Dotted Pair Notation.
+* . in regexp: Syntax of Regexps.
+* .emacs: Init File.
+* .emacs customization: Major Mode Conventions.
+* /: Arithmetic Operations.
+* /=: Comparison of Numbers.
+* 1+: Arithmetic Operations.
+* 1-: Arithmetic Operations.
+* ; in comment: Comments.
+* <: Comparison of Numbers.
+* <=: Comparison of Numbers.
+* <ESC>: Functions for Key Lookup.
+* =: Comparison of Numbers.
+* >: Comparison of Numbers.
+* >=: Comparison of Numbers.
+* ? in character constant: Character Type.
+* ? in regexp: Syntax of Regexps.
+* ?? in regexp: Syntax of Regexps.
+* @ in interactive: Using Interactive.
+* [ in regexp: Syntax of Regexps.
+* [...] (Edebug): Specification List.
+* \ in character constant: Character Type.
+* \ in display: Truncation.
+* \ in printing: Output Functions.
+* \ in regexp: Syntax of Regexps.
+* \ in replacement: Replacing Match.
+* \ in strings: String Type.
+* \ in symbols: Symbol Type.
+* \' in regexp: Syntax of Regexps.
+* \(?: in regexp: Syntax of Regexps.
+* \< in regexp: Syntax of Regexps.
+* \= in regexp: Syntax of Regexps.
+* \> in regexp: Syntax of Regexps.
+* \` in regexp: Syntax of Regexps.
+* \a: Character Type.
+* \b: Character Type.
+* \B in regexp: Syntax of Regexps.
+* \b in regexp: Syntax of Regexps.
+* \e: Character Type.
+* \f: Character Type.
+* \n: Character Type.
+* \n in print: Output Variables.
+* \N in replacement: Replacing Match.
+* \r: Character Type.
+* \S in regexp: Syntax of Regexps.
+* \s in regexp: Syntax of Regexps.
+* \t: Character Type.
+* \v: Character Type.
+* \W in regexp: Syntax of Regexps.
+* \w in regexp: Syntax of Regexps.
+* \{n,m\} in regexp: Syntax of Regexps.
+* ] in regexp: Syntax of Regexps.
+* ^ in regexp: Syntax of Regexps.
+* _ in interactive: Using Interactive.
+* `: Backquote.
+* ` (Edebug): Debugging Backquote.
+* ` (list substitution): Backquote.
+* abbrev: Abbrevs.
+* abbrev table: Abbrevs.
+* abbrev tables in modes: Major Mode Conventions.
+* abbrev-all-caps: Abbrev Expansion.
+* abbrev-expansion: Abbrev Expansion.
+* abbrev-file-name: Abbrev Files.
+* abbrev-mode: Abbrev Mode.
+* abbrev-prefix-mark: Abbrev Expansion.
+* abbrev-start-location: Abbrev Expansion.
+* abbrev-start-location-buffer: Abbrev Expansion.
+* abbrev-symbol: Abbrev Expansion.
+* abbrev-table-name-list: Abbrev Tables.
+* abbreviate-file-name: Directory Names.
+* abbrevs-changed: Abbrev Files.
+* abort-recursive-edit: Recursive Editing.
+* aborting: Recursive Editing.
+* abs: Arithmetic Operations.
+* absolute file name: Relative File Names.
+* accelerate-menu: Menu Accelerator Functions.
+* accept-process-output: Accepting Output.
+* accessibility of a file: Testing Accessibility.
+* accessible portion (of a buffer): Narrowing.
+* accessible-keymaps: Scanning Keymaps.
+* acos: Math Functions.
+* acosh: Math Functions.
+* activate-menubar-hook: Menubar.
+* activate-popup-menu-hook: Pop-Up Menus.
+* active display table: Active Display Table.
+* active keymap: Active Keymaps.
+* active-minibuffer-window: Minibuffer Misc.
+* add-abbrev: Defining Abbrevs.
+* add-hook: Hooks.
+* add-menu: Modifying Menus.
+* add-menu-button: Modifying Menus.
+* add-menu-item: Modifying Menus.
+* add-name-to-file: Changing File Attributes.
+* add-spec-list-to-specifier: Adding Specifications.
+* add-spec-to-specifier: Adding Specifications.
+* add-submenu: Modifying Menus.
+* add-text-properties: Changing Properties.
+* add-timeout: Timers.
+* add-to-list: Setting Variables.
+* add-tooltalk-message-arg: Elisp Interface for Sending Messages.
+* add-tooltalk-pattern-arg: Elisp Interface for Receiving Messages.
+* add-tooltalk-pattern-attribute: Elisp Interface for Receiving Messages.
+* adding a button to a toolbar: Simple Specifier Usage.
+* address field of register: Cons Cell Type.
+* after-change-function: Change Hooks.
+* after-change-functions: Change Hooks.
+* after-find-file: Subroutines of Visiting.
+* after-init-hook: Init File.
+* after-insert-file-functions: Saving Properties.
+* after-load-alist: Hooks for Loading.
+* after-revert-hook: Reverting.
+* after-save-hook: Saving Buffers.
+* aliases, for variables: Variable Aliases.
+* alist: Association Lists.
+* alist-to-plist: Converting Plists To/From Alists.
+* all-annotations: Locating Annotations.
+* all-completions: Basic Completion.
+* and: Combining Conditions.
+* annotation: Annotations.
+* annotation hooks: Annotation Hooks.
+* annotation-action: Annotation Properties.
+* annotation-data: Annotation Properties.
+* annotation-down-glyph: Annotation Properties.
+* annotation-face: Annotation Properties.
+* annotation-glyph: Annotation Properties.
+* annotation-layout: Annotation Properties.
+* annotation-list: Locating Annotations.
+* annotation-menu: Annotation Properties.
+* annotation-side: Annotation Properties.
+* annotation-visible: Annotation Properties.
+* annotation-width: Annotation Properties.
+* annotationp: Annotation Primitives.
+* annotations-at: Locating Annotations.
+* annotations-in-region: Locating Annotations.
+* anonymous function: Anonymous Functions.
+* anonymous lambda expressions (Edebug): Instrumenting.
+* apostrophe for quoting: Quoting.
+* append: Building Lists.
+* append-to-file: Writing to Files.
+* apply: Calling Functions.
+* apply, and debugging: Internals of Debugger.
+* apropos: Help Functions.
+* aref: Array Functions.
+* argument binding: Argument List.
+* argument descriptors: Using Interactive.
+* argument evaluation form: Using Interactive.
+* argument prompt: Using Interactive.
+* arguments, reading: Minibuffers.
+* arith-error example: Handling Errors.
+* arith-error in division: Arithmetic Operations.
+* arithmetic shift: Bitwise Operations.
+* array: Arrays.
+* array elements: Array Functions.
+* arrayp: Array Functions.
+* ASCII character codes: Character Type.
+* aset: Array Functions.
+* ash: Bitwise Operations.
+* asin: Math Functions.
+* asinh: Math Functions.
+* ask-user-about-lock: File Locks.
+* ask-user-about-supersession-threat: Modification Time.
+* asking the user questions: Yes-or-No Queries.
+* assoc: Association Lists.
+* association list: Association Lists.
+* assq: Association Lists.
+* asynchronous subprocess: Asynchronous Processes.
+* atan: Math Functions.
+* atanh: Math Functions.
+* atom <1>: List-related Predicates.
+* atom: Cons Cell Type.
+* atomic extent: Atomic Extents.
+* atoms: List-related Predicates.
+* attributes of text: Text Properties.
+* Auto Fill mode: Auto Filling.
+* auto-fill-function: Auto Filling.
+* auto-lower-frame: Raising and Lowering.
+* auto-mode-alist: Auto Major Mode.
+* auto-raise-frame: Raising and Lowering.
+* auto-save-default: Auto-Saving.
+* auto-save-file-format: Format Conversion.
+* auto-save-file-name-p: Auto-Saving.
+* auto-save-hook: Auto-Saving.
+* auto-save-interval: Auto-Saving.
+* auto-save-list-file-name: Auto-Saving.
+* auto-save-mode: Auto-Saving.
+* auto-save-timeout: Auto-Saving.
+* auto-save-visited-file-name: Auto-Saving.
+* auto-saving: Auto-Saving.
+* autoload <1>: Domain Specification.
+* autoload: Autoload.
+* autoload errors: Autoload.
+* automatically buffer-local: Intro to Buffer-Local.
+* available fonts: Font Instance Names.
+* back-to-indentation: Motion by Indent.
+* background pixmap: Merging Faces.
+* backquote (Edebug): Debugging Backquote.
+* backquote (list substitution): Backquote.
+* backslash in character constant: Character Type.
+* backslash in strings: String Type.
+* backslash in symbols: Symbol Type.
+* backspace: Character Type.
+* backtrace: Internals of Debugger.
+* backtrace-debug: Internals of Debugger.
+* backtrace-frame: Internals of Debugger.
+* backtracking: Backtracking.
+* backup file: Backup Files.
+* backup files, how to make them: Rename or Copy.
+* backup-buffer: Making Backups.
+* backup-by-copying: Rename or Copy.
+* backup-by-copying-when-linked: Rename or Copy.
+* backup-by-copying-when-mismatch: Rename or Copy.
+* backup-enable-predicate: Making Backups.
+* backup-file-name-p: Backup Names.
+* backup-inhibited: Making Backups.
+* backward-char: Character Motion.
+* backward-delete-char-untabify: Deletion.
+* backward-list: List Motion.
+* backward-prefix-chars: Motion and Syntax.
+* backward-sexp: List Motion.
+* backward-to-indentation: Motion by Indent.
+* backward-word: Word Motion.
+* balancing parentheses: Blinking.
+* barf-if-buffer-read-only: Read Only Buffers.
+* base buffer: Indirect Buffers.
+* base64: Transformations.
+* base64-decode-region: Transformations.
+* base64-decode-string: Transformations.
+* base64-encode-region: Transformations.
+* base64-encode-string: Transformations.
+* batch mode: Batch Mode.
+* batch-byte-compile: Compilation Functions.
+* batch-byte-recompile-directory: Compilation Functions.
+* beep: Beeping.
+* beeping: Beeping.
+* before point, insertion: Insertion.
+* before-change-function: Change Hooks.
+* before-change-functions: Change Hooks.
+* before-init-hook: Init File.
+* before-revert-hook: Reverting.
+* beginning of line: Text Lines.
+* beginning of line in regexp: Syntax of Regexps.
+* beginning-of-buffer: Buffer End Motion.
+* beginning-of-defun: List Motion.
+* beginning-of-line: Text Lines.
+* bell: Beeping.
+* bell character: Character Type.
+* bell-volume: Beeping.
+* binary files and text files: Files and MS-DOS.
+* binary packages: Package Terminology.
+* binary-process-input: MS-DOS Subprocesses.
+* binary-process-output: MS-DOS Subprocesses.
+* bind-text-domain: Level 3 Primitives.
+* binding arguments: Argument List.
+* binding local variables: Local Variables.
+* binding of a key: Keymap Terminology.
+* bit vector: Bit Vectors.
+* bit vector length: Sequence Functions.
+* bit-vector: Bit Vector Functions.
+* bit-vector-p: Bit Vector Functions.
+* bitp: Bit Vector Functions.
+* bitwise and: Bitwise Operations.
+* bitwise exclusive or: Bitwise Operations.
+* bitwise not: Bitwise Operations.
+* bitwise or: Bitwise Operations.
+* blink-matching-open: Blinking.
+* blink-matching-paren: Blinking.
+* blink-matching-paren-delay: Blinking.
+* blink-matching-paren-distance: Blinking.
+* blink-paren-function: Blinking.
+* blink-paren-hook: Blinking.
+* blinking: Blinking.
+* bobp: Near Point.
+* body of function: Lambda Components.
+* bold: Font Instance Characteristics.
+* bolp: Near Point.
+* bookmark-map: Standard Keymaps.
+* boolean: nil and t.
+* boolean-specifier-p: Specifier Types.
+* bootstrapping XEmacs from temacs: Building XEmacs.
+* bottom-gutter: Specifying a Gutter.
+* bottom-gutter-height: Other Gutter Variables.
+* bottom-gutter-visible-p: Other Gutter Variables.
+* bottom-toolbar: Specifying the Toolbar.
+* bottom-toolbar-height: Other Toolbar Variables.
+* bottom-toolbar-visible-p: Other Toolbar Variables.
+* boundp: Void Variables.
+* box diagrams, for lists: Cons Cell Type.
+* box representation for lists: Lists as Boxes.
+* break: Debugger.
+* breakpoints: Breakpoints.
+* bucket (in obarray): Creating Symbols.
+* buffer: Buffers.
+* buffer contents: Text.
+* buffer file name: Buffer File Name.
+* buffer input stream: Input Streams.
+* buffer list: The Buffer List.
+* buffer modification: Buffer Modification.
+* buffer names: Buffer Names.
+* buffer output stream: Output Streams.
+* buffer text notation: Buffer Text Notation.
+* buffer, read-only: Read Only Buffers.
+* buffer-auto-save-file-name: Auto-Saving.
+* buffer-backed-up: Making Backups.
+* buffer-base-buffer: Indirect Buffers.
+* buffer-disable-undo: Maintaining Undo.
+* buffer-enable-undo: Maintaining Undo.
+* buffer-end: Point.
+* buffer-file-format: Format Conversion.
+* buffer-file-name: Buffer File Name.
+* buffer-file-number: Buffer File Name.
+* buffer-file-truename: Buffer File Name.
+* buffer-file-type: Files and MS-DOS.
+* buffer-flush-undo: Maintaining Undo.
+* buffer-glyph-p: Glyph Types.
+* buffer-indirect-children: Indirect Buffers.
+* buffer-invisibility-spec: Invisible Text.
+* buffer-list: The Buffer List.
+* buffer-live-p: Killing Buffers.
+* buffer-local variables: Buffer-Local Variables.
+* buffer-local variables in modes: Major Mode Conventions.
+* buffer-local-variables: Creating Buffer-Local.
+* Buffer-menu-mode-map: Standard Keymaps.
+* buffer-modified-p: Buffer Modification.
+* buffer-modified-tick: Buffer Modification.
+* buffer-name: Buffer Names.
+* buffer-offer-save <1>: Killing Buffers.
+* buffer-offer-save: Saving Buffers.
+* buffer-read-only: Read Only Buffers.
+* buffer-saved-size <1>: Point.
+* buffer-saved-size: Auto-Saving.
+* buffer-size: Point.
+* buffer-string: Buffer Contents.
+* buffer-substring: Buffer Contents.
+* buffer-undo-list: Undo.
+* bufferp: Buffer Basics.
+* buffers menu: Buffers Menu.
+* buffers, controlled in windows: Buffers and Windows.
+* buffers, creating: Creating Buffers.
+* buffers, killing: Killing Buffers.
+* buffers-menu-filter: Menu Filters.
+* buffers-menu-max-size: Buffers Menu.
+* buffers-menu-switch-to-buffer-function: Buffers Menu.
+* building lists: Building Lists.
+* building packages: Building Packages.
+* building XEmacs: Building XEmacs.
+* built-in function: What Is a Function.
+* bury-buffer: The Buffer List.
+* busy-pointer-glyph: Mouse Pointer.
+* button-event-p: Event Predicates.
+* button-press-event-p: Event Predicates.
+* button-release-event-p: Event Predicates.
+* bvconcat: Bit Vector Functions.
+* byte-code <1>: Compilation Functions.
+* byte-code: Byte Compilation.
+* byte-code function: Compiled-Function Objects.
+* byte-code interpreter: Compilation Functions.
+* byte-compile: Compilation Functions.
+* byte-compile-call-tree: Compilation Options.
+* byte-compile-call-tree-sort: Compilation Options.
+* byte-compile-default-warnings: Compilation Options.
+* byte-compile-delete-errors: Compilation Options.
+* byte-compile-dest-file: Compilation Options.
+* byte-compile-dynamic: Dynamic Loading.
+* byte-compile-dynamic-docstrings: Docs and Compilation.
+* byte-compile-emacs19-compatibility: Compilation Options.
+* byte-compile-error-on-warn: Compilation Options.
+* byte-compile-file: Compilation Functions.
+* byte-compile-generate-call-tree: Compilation Options.
+* byte-compile-new-bytecodes: Compilation Options.
+* byte-compile-overwrite-file: Compilation Options.
+* byte-compile-print-gensym: Compilation Options.
+* byte-compile-single-version: Compilation Options.
+* byte-compile-verbose: Compilation Options.
+* byte-compile-warnings: Compilation Options.
+* byte-compiler-options: Compilation Options.
+* byte-compiling macros: Compiling Macros.
+* byte-compiling require: Named Features.
+* byte-optimize: Compilation Options.
+* byte-optimize-log: Compilation Options.
+* byte-recompile-directory: Compilation Functions.
+* byte-recompile-directory-ignore-errors-p: Compilation Functions.
+* byte-recompile-directory-recursively: Compilation Functions.
+* bytes: Strings and Characters.
+* c++-mode-map: Standard Keymaps.
+* C-c: Prefix Keys.
+* C-g: Quitting.
+* C-h: Prefix Keys.
+* C-M-x: Instrumenting.
+* c-mode-abbrev-table: Standard Abbrev Tables.
+* c-mode-map: Standard Keymaps.
+* c-mode-syntax-table: Standard Syntax Tables.
+* C-q: Flow Control.
+* C-s: Flow Control.
+* C-x: Prefix Keys.
+* C-x 4: Prefix Keys.
+* C-x 5: Prefix Keys.
+* C-x a: Prefix Keys.
+* C-x n: Prefix Keys.
+* C-x r: Prefix Keys.
+* caaaar: List Elements.
+* caaadr: List Elements.
+* caaar: List Elements.
+* caadar: List Elements.
+* caaddr: List Elements.
+* caadr: List Elements.
+* caar: List Elements.
+* cadaar: List Elements.
+* cadadr: List Elements.
+* cadar: List Elements.
+* caddar: List Elements.
+* cadddr: List Elements.
+* caddr: List Elements.
+* cadr: List Elements.
+* call stack: Internals of Debugger.
+* call-interactively: Interactive Call.
+* call-process: Synchronous Processes.
+* call-process-region: Synchronous Processes.
+* calling a function: Calling Functions.
+* cancel-debug-on-entry: Function Debugging.
+* canonicalize-inst-list: Adding Specifications.
+* canonicalize-inst-pair: Adding Specifications.
+* canonicalize-lax-plist: Working With Lax Plists.
+* canonicalize-plist: Working With Normal Plists.
+* canonicalize-spec: Adding Specifications.
+* canonicalize-spec-list: Adding Specifications.
+* canonicalize-tag-set: Specifier Tag Functions.
+* capitalization: Character Case.
+* capitalize: Character Case.
+* capitalize-region: Case Changes.
+* capitalize-word: Case Changes.
+* car: List Elements.
+* car-safe: List Elements.
+* case changes: Case Changes.
+* case in replacements: Replacing Match.
+* case-fold-search: Searching and Case.
+* case-replace: Searching and Case.
+* case-table-p: Case Tables.
+* catch: Catch and Throw.
+* category-designator-p: Category Tables.
+* category-table: Category Tables.
+* category-table-p: Category Tables.
+* category-table-value-p: Category Tables.
+* CBREAK: Flow Control.
+* ccl-elapsed-time: Calling CCL.
+* ccl-execute: Calling CCL.
+* ccl-execute-on-string: Calling CCL.
+* ccl-reset-elapsed-time: Calling CCL.
+* cdaaar: List Elements.
+* cdaadr: List Elements.
+* cdaar: List Elements.
+* cdadar: List Elements.
+* cdaddr: List Elements.
+* cdadr: List Elements.
+* cdar: List Elements.
+* cddaar: List Elements.
+* cddadr: List Elements.
+* cddar: List Elements.
+* cdddar: List Elements.
+* cddddr: List Elements.
+* cdddr: List Elements.
+* cddr: List Elements.
+* CDE dt: CDE dt.
+* cdr: List Elements.
+* cdr-safe: List Elements.
+* ceiling: Numeric Conversions.
+* centering point: Vertical Scrolling.
+* cerror: Signaling Errors.
+* change hooks: Change Hooks.
+* change-major-mode-hook: Major Mode Conventions.
+* changing key bindings: Changing Key Bindings.
+* changing to another buffer: Current Buffer.
+* changing window size: Resizing Windows.
+* char table type: Char Table Type.
+* char-after: Near Point.
+* char-before: Near Point.
+* char-charset: MULE Characters.
+* char-equal: Text Comparison.
+* char-int: Character Codes.
+* char-int confoundance disease: Character Type.
+* char-int-p: Character Codes.
+* char-octet: MULE Characters.
+* char-or-char-int-p: Character Codes.
+* char-or-string-p: Predicates for Strings.
+* char-syntax: Syntax Table Functions.
+* char-table-p: Char Tables.
+* char-table-type: Char Table Types.
+* char-table-type-list: Char Table Types.
+* char-to-string: String Conversion.
+* char=: Text Comparison.
+* character arrays: Strings and Characters.
+* character case: Character Case.
+* character descriptor: Character Descriptors.
+* character insertion: Commands for Insertion.
+* character printing: Describing Characters.
+* character set (in regexp): Syntax of Regexps.
+* character to string: String Conversion.
+* character-to-event: Converting Events.
+* characteristics of font instances: Font Instance Characteristics.
+* characterp: Predicates for Characters.
+* characters: Strings and Characters.
+* characters for interactive codes: Interactive Codes.
+* character quote: Syntax Class Table.
+* charset type: Charset Type.
+* charset-ccl-program: Charset Property Functions.
+* charset-chars: Charset Property Functions.
+* charset-description: Charset Property Functions.
+* charset-dimension: Charset Property Functions.
+* charset-direction: Charset Property Functions.
+* charset-from-attributes: Basic Charset Functions.
+* charset-iso-final-char: Charset Property Functions.
+* charset-iso-graphic-plane: Charset Property Functions.
+* charset-list: Basic Charset Functions.
+* charset-name: Charset Property Functions.
+* charset-property: Charset Property Functions.
+* charset-registry: Charset Property Functions.
+* charset-reverse-direction-charset: Basic Charset Functions.
+* charset-width: Charset Property Functions.
+* charsetp: Charsets.
+* check-argument-type: Signaling Errors.
+* check-gutter-button-syntax: Gutter Descriptor Format.
+* check-toolbar-button-syntax: Toolbar Descriptor Format.
+* check-valid-char-table-value: Working With Char Tables.
+* check-valid-inst-list: Specifier Validation Functions.
+* check-valid-instantiator: Specifier Validation Functions.
+* check-valid-plist: Property Lists.
+* check-valid-spec-list: Specifier Validation Functions.
+* child process: Processes.
+* children, of extent: Extent Parents.
+* CL note--allocate more storage: Garbage Collection.
+* CL note--case of letters: Symbol Type.
+* CL note--default optional arg: Argument List.
+* CL note--integers vrs eq: Comparison of Numbers.
+* CL note--lack union, set: Sets And Lists.
+* CL note--only throw in Emacs: Catch and Throw.
+* CL note--rplaca vrs setcar: Modifying Lists.
+* CL note--set local: Setting Variables.
+* CL note--special forms compared: Special Forms.
+* CL note--special variables: Variable Scoping.
+* CL note--symbol in obarrays: Creating Symbols.
+* cl-read: Reading in Edebug.
+* cl-specs.el: Instrumenting.
+* cl.el (Edebug): Instrumenting.
+* cleanup forms: Cleanups.
+* clear-abbrev-table: Abbrev Tables.
+* clear-message: The Echo Area.
+* clear-range-table: Working With Range Tables.
+* clear-visited-file-modtime: Modification Time.
+* close parenthesis: Blinking.
+* close-database: Connecting to a Database.
+* close parenthesis character: Syntax Class Table.
+* closures not available: Extent.
+* clrhash: Working With Hash Tables.
+* codes, interactive, description of: Interactive Codes.
+* coding standards: Tips.
+* coding system type: Coding System Type.
+* coding-category-list: Detection of Textual Encoding.
+* coding-category-system: Detection of Textual Encoding.
+* coding-priority-list: Detection of Textual Encoding.
+* coding-system-base: Basic Coding System Functions.
+* coding-system-doc-string: Coding System Property Functions.
+* coding-system-list: Basic Coding System Functions.
+* coding-system-name: Basic Coding System Functions.
+* coding-system-p: Coding Systems.
+* coding-system-property: Coding System Property Functions.
+* coding-system-type: Coding System Property Functions.
+* color instance type: Color Instance Type.
+* color instances: Color Instances.
+* color-instance-name: Color Instance Properties.
+* color-instance-p: Color Instances.
+* color-instance-rgb-components: Color Instance Properties.
+* color-name: Color Convenience Functions.
+* color-pixmap-image-instance-p: Image Instance Types.
+* color-rgb-components: Color Convenience Functions.
+* color-specifier-p <1>: Color Specifiers.
+* color-specifier-p: Specifier Types.
+* colorize-image-instance: Image Instance Functions.
+* colors: Colors.
+* columns: Columns.
+* Command: Visibility of Frames.
+* command: What Is a Function.
+* command descriptions: A Sample Function Description.
+* command history: Command History.
+* command in keymap: Key Lookup.
+* command line arguments: Command Line Arguments.
+* command line options: Command Line Arguments.
+* command loop: Command Loop.
+* command loop, recursive: Recursive Editing.
+* command-debug-status: Internals of Debugger.
+* command-execute: Interactive Call.
+* command-history: Command History.
+* command-history-map: Standard Keymaps.
+* command-line: Command Line Arguments.
+* command-line-args: Command Line Arguments.
+* command-line-functions: Command Line Arguments.
+* command-line-processed: Command Line Arguments.
+* command-switch-alist: Command Line Arguments.
+* commandp: Interactive Call.
+* commandp example: High-Level Completion.
+* commands, defining: Defining Commands.
+* comment syntax: Syntax Class Table.
+* comments: Comments.
+* comment ender: Syntax Class Table.
+* comment starter: Syntax Class Table.
+* Common Lisp: Lisp History.
+* Common Lisp (Edebug): Instrumenting.
+* compare-buffer-substrings: Comparing Text.
+* comparing buffer text: Comparing Text.
+* comparison of modification time: Modification Time.
+* compilation: Byte Compilation.
+* compilation functions: Compilation Functions.
+* compilation options: Compilation Options.
+* compile-defun: Compilation Functions.
+* compiled function: Compiled-Function Objects.
+* compiled-function-arglist: Compiled-Function Objects.
+* compiled-function-constants: Compiled-Function Objects.
+* compiled-function-doc-string: Compiled-Function Objects.
+* compiled-function-domain: Compiled-Function Objects.
+* compiled-function-instructions: Compiled-Function Objects.
+* compiled-function-interactive: Compiled-Function Objects.
+* compiled-function-p: What Is a Function.
+* compiled-function-stack-depth: Compiled-Function Objects.
+* compiling packages: Makefile.
+* complete key: Keymap Terminology.
+* completing-read: Minibuffer Completion.
+* completion: Completion.
+* completion, file name: File Name Completion.
+* completion, user name: User Name Completion.
+* completion-auto-help: Completion Commands.
+* completion-ignore-case: Basic Completion.
+* completion-ignored-extensions: File Name Completion.
+* complex arguments: Minibuffers.
+* complex command: Command History.
+* complex-buffers-menu-p: Buffers Menu.
+* compose-region: Composite Characters.
+* composite-char-string: Composite Characters.
+* concat: Creating Strings.
+* concatenating lists: Rearrangement.
+* concatenating strings: Creating Strings.
+* cond: Conditionals.
+* condition name: Error Symbols.
+* condition-case: Handling Errors.
+* conditional evaluation: Conditionals.
+* cons: Building Lists.
+* cons cell as box: Lists as Boxes.
+* cons cells: Building Lists.
+* consing: Building Lists.
+* console-device-list: Basic Console Functions.
+* console-disable-input: Console and Device I/O.
+* console-enable-input: Console and Device I/O.
+* console-list: Basic Console Functions.
+* console-live-p: Connecting to a Console or Device.
+* console-type-image-conversion-list: Image Instantiator Conversion.
+* consolep: Consoles and Devices.
+* consoles: Consoles and Devices.
+* consp: List-related Predicates.
+* continuation lines: Truncation.
+* continuation-glyph: Redisplay Glyphs.
+* continue-process: Signals to Processes.
+* control character printing: Describing Characters.
+* control characters: Character Type.
+* control characters in display: Usual Display.
+* control characters, reading: Quoted Character Input.
+* control structures: Control Structures.
+* control-arrow-glyph: Redisplay Glyphs.
+* Control-X-prefix: Prefix Keys.
+* conventions for writing minor modes: Minor Mode Conventions.
+* conversion of image instantiators: Image Instantiator Conversion.
+* conversion of strings: String Conversion.
+* copy-alist: Association Lists.
+* copy-category-table: Category Tables.
+* copy-coding-system: Basic Coding System Functions.
+* copy-event: Working With Events.
+* copy-extent: Detached Extents.
+* copy-face: Basic Face Functions.
+* copy-file: Changing File Attributes.
+* copy-hash-table: Introduction to Hash Tables.
+* copy-keymap: Creating Keymaps.
+* copy-marker: Creating Markers.
+* copy-range-table: Introduction to Range Tables.
+* copy-region-as-kill: Kill Functions.
+* copy-sequence: Sequence Functions.
+* copy-specifier: Other Specification Functions.
+* copy-syntax-table: Syntax Table Functions.
+* copying alists: Association Lists.
+* copying bit vectors: Bit Vector Functions.
+* copying files: Changing File Attributes.
+* copying lists: Building Lists.
+* copying sequences: Sequence Functions.
+* copying strings: Creating Strings.
+* copying vectors: Vector Functions.
+* cos: Math Functions.
+* cosh: Math Functions.
+* count-lines: Text Lines.
+* count-loop: A Sample Function Description.
+* counting columns: Columns.
+* coverage testing: Coverage Testing.
+* create-device-hook: Connecting to a Console or Device.
+* create-file-buffer: Subroutines of Visiting.
+* create-frame-hook: Frame Hooks.
+* create-tooltalk-message: Elisp Interface for Sending Messages.
+* create-tooltalk-pattern: Elisp Interface for Receiving Messages.
+* creating buffers: Creating Buffers.
+* creating keymaps: Creating Keymaps.
+* creating packages: Creating Packages.
+* ctl-arrow: Usual Display.
+* ctl-x-4-map <1>: Standard Keymaps.
+* ctl-x-4-map: Prefix Keys.
+* ctl-x-5-map <1>: Standard Keymaps.
+* ctl-x-5-map: Prefix Keys.
+* ctl-x-map <1>: Standard Keymaps.
+* ctl-x-map: Prefix Keys.
+* cube-root: Math Functions.
+* current binding: Local Variables.
+* current buffer: Current Buffer.
+* current buffer excursion: Excursions.
+* current buffer mark: The Mark.
+* current buffer point and mark (Edebug): Edebug Display Update.
+* current buffer position: Point.
+* current command: Command Loop Info.
+* current stack frame: Using Debugger.
+* current-buffer: Current Buffer.
+* current-case-table: Case Tables.
+* current-column: Columns.
+* current-display-table: Active Display Table.
+* current-fill-column: Margins.
+* current-frame-configuration: Frame Configurations.
+* current-global-map: Active Keymaps.
+* current-indentation: Primitive Indent.
+* current-input-mode: Input Modes.
+* current-justification: Filling.
+* current-keymaps: Active Keymaps.
+* current-kill: Low-Level Kill Ring.
+* current-left-margin: Margins.
+* current-local-map: Active Keymaps.
+* current-menubar: Menubar.
+* current-message: The Echo Area.
+* current-minor-mode-maps: Active Keymaps.
+* current-mouse-event: Command Loop Info.
+* current-prefix-arg: Prefix Command Arguments.
+* current-time: Time of Day.
+* current-time-string: Time of Day.
+* current-time-zone: Time of Day.
+* current-window-configuration: Window Configurations.
+* cursor (mouse): Mouse Pointer.
+* cursor-in-echo-area: The Echo Area.
+* cust-print: Printing in Edebug.
+* cut buffer: X Selections.
+* cyclic ordering of windows: Cyclic Window Ordering.
+* data type: Lisp Data Types.
+* data-directory: Accessing Documentation.
+* database: Databases.
+* database type: Database Type.
+* database-file-name: Other Database Functions.
+* database-last-error: Other Database Functions.
+* database-live-p: Connecting to a Database.
+* database-subtype: Other Database Functions.
+* database-type: Other Database Functions.
+* databasep: Databases.
+* deallocate-event: Working With Events.
+* debug: Invoking the Debugger.
+* debug-allocation: Garbage Collection.
+* debug-allocation-backtrace: Garbage Collection.
+* debug-ignored-errors: Error Debugging.
+* debug-on-entry: Function Debugging.
+* debug-on-error: Error Debugging.
+* debug-on-error use: Processing of Errors.
+* debug-on-next-call: Internals of Debugger.
+* debug-on-quit: Infinite Loops.
+* debug-on-signal: Error Debugging.
+* debug-on-signal use: Handling Errors.
+* debugger <1>: Internals of Debugger.
+* debugger: Debugger.
+* debugger command list: Debugger Commands.
+* debugger-mode-map: Standard Keymaps.
+* debugging errors: Error Debugging.
+* debugging specific functions: Function Debugging.
+* decode-big5-char: Big5 and Shift-JIS Functions.
+* decode-coding-region: Encoding and Decoding Text.
+* decode-shift-jis-char: Big5 and Shift-JIS Functions.
+* decode-time: Time Conversion.
+* decoding file formats: Format Conversion.
+* decompose-region: Composite Characters.
+* decrement field of register: Cons Cell Type.
+* dedicated window: Choosing Window.
+* deep binding: Impl of Scope.
+* def-edebug-spec: Instrumenting Macro Calls.
+* defalias: Defining Functions.
+* default argument string: Interactive Codes.
+* default init file: Init File.
+* default value: Default Value.
+* default-abbrev-mode: Abbrev Mode.
+* default-boundp: Default Value.
+* default-buffer-file-type: Files and MS-DOS.
+* default-case-fold-search: Searching and Case.
+* default-ctl-arrow: Usual Display.
+* default-deselect-frame-hook: Raising and Lowering.
+* default-directory: File Name Expansion.
+* default-file-modes: Changing File Attributes.
+* default-fill-column: Margins.
+* default-frame-name: Frame Name.
+* default-frame-plist: Initial Properties.
+* default-gutter: Specifying a Gutter.
+* default-gutter-height: Other Gutter Variables.
+* default-gutter-position: Specifying a Gutter.
+* default-gutter-visible-p: Other Gutter Variables.
+* default-gutter-width: Other Gutter Variables.
+* default-justification: Filling.
+* default-major-mode: Auto Major Mode.
+* default-menubar: Menubar.
+* default-minibuffer-frame: Minibuffers and Frames.
+* default-modeline-format: Modeline Variables.
+* default-popup-menu: Pop-Up Menus.
+* default-select-frame-hook: Raising and Lowering.
+* default-text-properties: Examining Properties.
+* default-toolbar: Specifying the Toolbar.
+* default-toolbar-height: Other Toolbar Variables.
+* default-toolbar-position: Specifying the Toolbar.
+* default-toolbar-visible-p: Other Toolbar Variables.
+* default-toolbar-width: Other Toolbar Variables.
+* default-truncate-lines: Truncation.
+* default-value: Default Value.
+* default-x-device: Resources.
+* default.el: Start-up Summary.
+* defconst <1>: Domain Specification.
+* defconst: Defining Variables.
+* defcustom: Variable Definitions.
+* defgroup: Group Definitions.
+* define-abbrev: Defining Abbrevs.
+* define-abbrev-table: Abbrev Tables.
+* define-derived-mode: Derived Modes.
+* define-error: Error Symbols.
+* define-function: Defining Functions.
+* define-key: Changing Key Bindings.
+* define-obsolete-function-alias: Obsoleteness.
+* define-obsolete-variable-alias: Obsoleteness.
+* define-prefix-command: Prefix Keys.
+* define-specifier-tag: Specifier Tag Functions.
+* defining a function: Defining Functions.
+* defining commands: Defining Commands.
+* defining-kbd-macro: Keyboard Macros.
+* definition of a symbol: Definitions.
+* defmacro: Defining Macros.
+* defsubst: Inline Functions.
+* defun: Defining Functions.
+* defun-prompt-regexp: List Motion.
+* defvar <1>: Domain Specification.
+* defvar: Defining Variables.
+* defvaralias: Variable Aliases.
+* delete: Sets And Lists.
+* delete previous char: Deletion.
+* delete-annotation: Annotation Primitives.
+* delete-auto-save-file-if-necessary: Auto-Saving.
+* delete-auto-save-files: Auto-Saving.
+* delete-backward-char: Deletion.
+* delete-blank-lines: User-Level Deletion.
+* delete-char: Deletion.
+* delete-device: Connecting to a Console or Device.
+* delete-device-hook: Connecting to a Console or Device.
+* delete-directory: Create/Delete Dirs.
+* delete-exited-processes: Deleting Processes.
+* delete-extent: Creating and Modifying Extents.
+* delete-file: Changing File Attributes.
+* delete-frame: Deleting Frames.
+* delete-frame-hook: Frame Hooks.
+* delete-horizontal-space: User-Level Deletion.
+* delete-indentation: User-Level Deletion.
+* delete-menu-item: Modifying Menus.
+* delete-old-versions: Numbered Backups.
+* delete-other-windows: Deleting Windows.
+* delete-process: Deleting Processes.
+* delete-region: Deletion.
+* delete-to-left-margin: Margins.
+* delete-window: Deleting Windows.
+* delete-windows-on: Deleting Windows.
+* deleting files: Changing File Attributes.
+* deleting processes: Deleting Processes.
+* deleting whitespace: User-Level Deletion.
+* deleting windows: Deleting Windows.
+* deletion of elements: Sets And Lists.
+* deletion of frames: Deleting Frames.
+* deletion vs killing: Deletion.
+* delq: Sets And Lists.
+* demibold: Font Instance Characteristics.
+* describe-bindings: Scanning Keymaps.
+* describe-bindings-internal: Scanning Keymaps.
+* describe-buffer-case-table: Case Tables.
+* describe-mode: Mode Help.
+* describe-prefix-bindings: Help Functions.
+* describe-tooltalk-message: Elisp Interface for Receiving Messages.
+* description for interactive codes: Interactive Codes.
+* description format: Format of Descriptions.
+* deselect-frame-hook: Frame Hooks.
+* destroy-tooltalk-message: Elisp Interface for Sending Messages.
+* destroy-tooltalk-pattern: Elisp Interface for Receiving Messages.
+* destructive-alist-to-plist: Converting Plists To/From Alists.
+* destructive-plist-to-alist: Converting Plists To/From Alists.
+* detach-extent: Detached Extents.
+* detached extent: Detached Extents.
+* detect-coding-region: Detection of Textual Encoding.
+* device-baud-rate <1>: Terminal Output.
+* device-baud-rate: Console and Device I/O.
+* device-class: Console Types and Device Classes.
+* device-frame-list <1>: Basic Device Functions.
+* device-frame-list: Finding All Frames.
+* device-list: Basic Device Functions.
+* device-live-p: Connecting to a Console or Device.
+* device-matches-specifier-tag-set-p: Specifier Tag Functions.
+* device-matching-specifier-tag-list: Specifier Tag Functions.
+* device-or-frame-p: Basic Device Functions.
+* device-or-frame-type: Console Types and Device Classes.
+* device-type: Console Types and Device Classes.
+* device-x-display: Connecting to a Console or Device.
+* devicep: Consoles and Devices.
+* devices: Consoles and Devices.
+* dgettext: Level 3 Primitives.
+* diagrams, boxed, for lists: Cons Cell Type.
+* dialog box: Dialog Boxes.
+* digit-argument: Prefix Command Arguments.
+* ding: Beeping.
+* directory name: Directory Names.
+* directory name abbreviation: Directory Names.
+* directory part (of file name): File Name Components.
+* directory-abbrev-alist: Directory Names.
+* directory-file-name: Directory Names.
+* directory-files: Contents of Directories.
+* directory-oriented functions: Contents of Directories.
+* dired-kept-versions: Numbered Backups.
+* dired-mode-map: Standard Keymaps.
+* disable undo: Maintaining Undo.
+* disable-command: Disabling Commands.
+* disable-menu-item: Modifying Menus.
+* disable-timeout: Timers.
+* disabled: Disabling Commands.
+* disabled command: Disabling Commands.
+* disabled-command-hook: Disabling Commands.
+* disassemble: Disassembly.
+* disassembled byte-code: Disassembly.
+* discard input: Peeking and Discarding.
+* discard-input: Peeking and Discarding.
+* dispatch-event: Dispatching an Event.
+* dispatching an event: Dispatching an Event.
+* display columns: Size and Position.
+* display lines: Size and Position.
+* display order: Extent Endpoints.
+* display table: Display Tables.
+* display update: Refresh Screen.
+* display-buffer: Choosing Window.
+* display-buffer-function: Choosing Window.
+* display-completion-list: Completion Commands.
+* display-error: Processing of Errors.
+* display-message: The Echo Area.
+* display-warning: Warnings.
+* display-warning-minimum-level: Warnings.
+* display-warning-suppressed-classes: Warnings.
+* displaying a buffer: Displaying Buffers.
+* do-auto-save: Auto-Saving.
+* DOC (documentation) file: Documentation Basics.
+* doc-directory: Accessing Documentation.
+* documentation: Accessing Documentation.
+* documentation conventions: Documentation Basics.
+* documentation for major mode: Mode Help.
+* documentation notation: Evaluation Notation.
+* documentation of function: Function Documentation.
+* documentation strings: Documentation.
+* documentation, keys in: Keys in Documentation.
+* documentation-property: Accessing Documentation.
+* documenting packages: Documenting Packages.
+* domain: Level 3 Primitives.
+* domain (in a specifier): Specifiers In-Depth.
+* domain-of: Level 3 Primitives.
+* dotted lists (Edebug): Specification List.
+* dotted pair notation: Dotted Pair Notation.
+* double-quote in strings: String Type.
+* down-list: List Motion.
+* downcase: Character Case.
+* downcase-region: Case Changes.
+* downcase-word: Case Changes.
+* downcasing in lookup-key: Key Sequence Input.
+* drag: Drag Interface.
+* drag and drop: Drag and Drop.
+* Drag API: Drag Interface.
+* dribble file: Recording Input.
+* drop: Drop Interface.
+* Drop API: Drop Interface.
+* dump-emacs: Building XEmacs.
+* duplicable extent: Duplicable Extents.
+* dynamic loading of documentation: Docs and Compilation.
+* dynamic loading of functions: Dynamic Loading.
+* dynamic scoping: Variable Scoping.
+* echo area: The Echo Area.
+* echo-keystrokes <1>: The Echo Area.
+* echo-keystrokes: Command Loop Info.
+* edebug: Embedded Breakpoints.
+* Edebug: Edebug.
+* Edebug execution modes: Edebug Execution Modes.
+* Edebug mode: Edebug.
+* Edebug specification list: Specification List.
+* edebug-`: Debugging Backquote.
+* edebug-all-defs <1>: Edebug Options.
+* edebug-all-defs: Instrumenting.
+* edebug-all-forms <1>: Edebug Options.
+* edebug-all-forms: Instrumenting.
+* edebug-continue-kbd-macro: Edebug Options.
+* edebug-display-freq-count: Coverage Testing.
+* edebug-eval-top-level-form: Instrumenting.
+* edebug-global-break-condition <1>: Edebug Options.
+* edebug-global-break-condition: Global Break Condition.
+* edebug-initial-mode: Edebug Options.
+* edebug-on-error <1>: Edebug Options.
+* edebug-on-error: Trapping Errors.
+* edebug-on-quit <1>: Edebug Options.
+* edebug-on-quit: Trapping Errors.
+* edebug-print-circle <1>: Edebug Options.
+* edebug-print-circle: Printing in Edebug.
+* edebug-print-length <1>: Edebug Options.
+* edebug-print-length: Printing in Edebug.
+* edebug-print-level <1>: Edebug Options.
+* edebug-print-level: Printing in Edebug.
+* edebug-print-trace-after <1>: Edebug Options.
+* edebug-print-trace-after: Tracing.
+* edebug-print-trace-before <1>: Edebug Options.
+* edebug-print-trace-before: Tracing.
+* edebug-save-displayed-buffer-points <1>: Edebug Options.
+* edebug-save-displayed-buffer-points: Edebug Display Update.
+* edebug-save-windows <1>: Edebug Options.
+* edebug-save-windows: Edebug Display Update.
+* edebug-set-global-break-condition: Global Break Condition.
+* edebug-setup-hook: Edebug Options.
+* edebug-test-coverage: Edebug Options.
+* edebug-trace <1>: Edebug Options.
+* edebug-trace: Tracing.
+* edebug-tracing: Tracing.
+* edebug-unwrap: Specification List.
+* edebug-unwrap-results <1>: Edebug Options.
+* edebug-unwrap-results: Debugging Backquote.
+* edit-abbrevs-map: Standard Keymaps.
+* edit-and-eval-command: Object from Minibuffer.
+* edit-menu-filter: Menu Filters.
+* edit-tab-stops-map: Standard Keymaps.
+* editing types: Editing Types.
+* editor command loop: Command Loop.
+* eighth: List Elements.
+* electric-buffer-menu-mode-map: Standard Keymaps.
+* electric-future-map: A Sample Variable Description.
+* electric-history-map: Standard Keymaps.
+* element (of list): Lists.
+* elements of sequences: Sequence Functions.
+* elt: Sequence Functions.
+* emacs-build-time: Building XEmacs.
+* emacs-lisp-file-regexp: Compilation Options.
+* emacs-lisp-mode-map: Standard Keymaps.
+* emacs-lisp-mode-syntax-table: Standard Syntax Tables.
+* emacs-major-version: Building XEmacs.
+* emacs-minor-version: Building XEmacs.
+* emacs-pid: System Environment.
+* emacs-version: Building XEmacs.
+* EMACSLOADPATH environment variable: How Programs Do Loading.
+* embedded breakpoints: Embedded Breakpoints.
+* empty list: Cons Cell Type.
+* enable-command: Disabling Commands.
+* enable-flow-control: Flow Control.
+* enable-flow-control-on: Flow Control.
+* enable-local-eval: Auto Major Mode.
+* enable-local-variables: Auto Major Mode.
+* enable-menu-item: Modifying Menus.
+* enable-recursive-minibuffers: Minibuffer Misc.
+* encode-big5-char: Big5 and Shift-JIS Functions.
+* encode-coding-region: Encoding and Decoding Text.
+* encode-shift-jis-char: Big5 and Shift-JIS Functions.
+* encode-time: Time Conversion.
+* encoding file formats: Format Conversion.
+* end of buffer marker: Creating Markers.
+* end-of-buffer: Buffer End Motion.
+* end-of-defun: List Motion.
+* end-of-file: Input Functions.
+* end-of-line: Text Lines.
+* enlarge-window: Resizing Windows.
+* enlarge-window-horizontally: Resizing Windows.
+* enlarge-window-pixels: Resizing Windows.
+* enqueue-eval-event: Reading One Event.
+* environment: Intro Eval.
+* environment variable access: System Environment.
+* environment variables, subprocesses: Subprocess Creation.
+* eobp: Near Point.
+* eolp: Near Point.
+* eq: Equality Predicates.
+* equal: Equality Predicates.
+* equality: Equality Predicates.
+* erase-buffer: Deletion.
+* error: Signaling Errors.
+* error cleanup: Cleanups.
+* error debugging: Error Debugging.
+* error display: The Echo Area.
+* error handler: Handling Errors.
+* error in debug: Invoking the Debugger.
+* error message notation: Error Messages.
+* error name: Error Symbols.
+* error symbol: Error Symbols.
+* error-conditions: Error Symbols.
+* error-message-string: Processing of Errors.
+* errors: Errors.
+* esc-map: Prefix Keys.
+* ESC-prefix: Prefix Keys.
+* escape <1>: Syntax Class Table.
+* escape: Character Type.
+* escape characters: Output Variables.
+* escape characters in printing: Output Functions.
+* escape sequence: Character Type.
+* eval: Eval.
+* eval, and debugging: Internals of Debugger.
+* eval-and-compile: Eval During Compile.
+* eval-buffer: Eval.
+* eval-current-buffer (Edebug): Instrumenting.
+* eval-defun (Edebug): Instrumenting.
+* eval-event-p: Event Predicates.
+* eval-expression (Edebug): Instrumenting.
+* eval-minibuffer: Object from Minibuffer.
+* eval-region: Eval.
+* eval-region (Edebug): Instrumenting.
+* eval-when-compile: Eval During Compile.
+* evaluated expression argument: Interactive Codes.
+* evaluation: Evaluation.
+* evaluation error: Local Variables.
+* evaluation list (Edebug): Eval List.
+* evaluation notation: Evaluation Notation.
+* evaluation of buffer contents: Eval.
+* event printing: Describing Characters.
+* event-buffer: Window-Level Event Position Info.
+* event-button: Accessing Other Event Info.
+* event-closest-point: Event Text Position Info.
+* event-device: Accessing Other Event Info.
+* event-frame: Frame-Level Event Position Info.
+* event-function: Accessing Other Event Info.
+* event-glyph-extent: Event Glyph Position Info.
+* event-glyph-x-pixel: Event Glyph Position Info.
+* event-glyph-y-pixel: Event Glyph Position Info.
+* event-key: Accessing Other Event Info.
+* event-live-p: Event Predicates.
+* event-matches-key-specifier-p: Key Sequences.
+* event-modifier-bits: Accessing Other Event Info.
+* event-modifiers: Accessing Other Event Info.
+* event-object: Accessing Other Event Info.
+* event-over-border-p: Other Event Position Info.
+* event-over-glyph-p: Event Glyph Position Info.
+* event-over-modeline-p: Event Text Position Info.
+* event-over-text-area-p: Event Text Position Info.
+* event-over-toolbar-p: Event Toolbar Position Info.
+* event-point: Event Text Position Info.
+* event-process: Accessing Other Event Info.
+* event-timestamp: Accessing Other Event Info.
+* event-to-character: Converting Events.
+* event-toolbar-button: Event Toolbar Position Info.
+* event-type: Event Contents.
+* event-window: Window-Level Event Position Info.
+* event-window-x-pixel: Window-Level Event Position Info.
+* event-window-y-pixel: Window-Level Event Position Info.
+* event-x: Event Text Position Info.
+* event-x-pixel: Frame-Level Event Position Info.
+* event-y: Event Text Position Info.
+* event-y-pixel: Frame-Level Event Position Info.
+* eventp: Events.
+* events: Events.
+* events-to-keys: Converting Events.
+* examining windows: Buffers and Windows.
+* examples of using interactive: Interactive Examples.
+* examples, specifier: Simple Specifier Usage.
+* exchange-point-and-mark: The Mark.
+* excursion: Excursions.
+* exec-directory: Subprocess Creation.
+* exec-path: Subprocess Creation.
+* execute program: Subprocess Creation.
+* execute with prefix argument: Interactive Call.
+* execute-extended-command: Interactive Call.
+* execute-kbd-macro: Keyboard Macros.
+* executing-macro: Keyboard Macros.
+* execution speed: Compilation Tips.
+* exit: Recursive Editing.
+* exit recursive editing: Recursive Editing.
+* exit-minibuffer: Minibuffer Misc.
+* exit-recursive-edit: Recursive Editing.
+* exiting XEmacs: Getting Out.
+* exp: Math Functions.
+* expand-abbrev: Abbrev Expansion.
+* expand-file-name: File Name Expansion.
+* expansion of file names: File Name Expansion.
+* expansion of macros: Expansion.
+* expression: Intro Eval.
+* expression prefix: Syntax Class Table.
+* expt: Math Functions.
+* extended-command-history: Minibuffer History.
+* extent <1>: Extents.
+* extent: Variable Scoping.
+* extent children: Extent Parents.
+* extent end position: Extent Endpoints.
+* extent endpoint: Extent Endpoints.
+* extent order: Extent Endpoints.
+* extent parent: Extent Parents.
+* extent priority: Intro to Extents.
+* extent property: Extent Properties.
+* extent replica: Duplicable Extents.
+* extent start position: Extent Endpoints.
+* extent, duplicable: Duplicable Extents.
+* extent, unique: Duplicable Extents.
+* extent-at: Finding Extents.
+* extent-begin-glyph: Extent Properties.
+* extent-begin-glyph-layout: Extent Properties.
+* extent-children: Extent Parents.
+* extent-descendants: Extent Parents.
+* extent-detached-p: Detached Extents.
+* extent-end-glyph: Extent Properties.
+* extent-end-glyph-layout: Extent Properties.
+* extent-end-position: Extent Endpoints.
+* extent-face: Extent Properties.
+* extent-in-region-p: Mapping Over Extents.
+* extent-keymap: Extent Properties.
+* extent-length: Extent Endpoints.
+* extent-list: Finding Extents.
+* extent-live-p: Creating and Modifying Extents.
+* extent-mouse-face: Extent Properties.
+* extent-object: Creating and Modifying Extents.
+* extent-parent: Extent Parents.
+* extent-priority: Extent Properties.
+* extent-properties: Extent Properties.
+* extent-property: Extent Properties.
+* extent-start-position: Extent Endpoints.
+* extentp: Extents.
+* extents, locating: Finding Extents.
+* extents, mapping: Mapping Over Extents.
+* face type: Face Type.
+* face-background: Face Convenience Functions.
+* face-background-instance: Face Convenience Functions.
+* face-background-pixmap: Face Convenience Functions.
+* face-background-pixmap-instance: Face Convenience Functions.
+* face-boolean-specifier-p: Specifier Types.
+* face-differs-from-default-p: Other Face Display Functions.
+* face-equal: Other Face Display Functions.
+* face-font: Face Convenience Functions.
+* face-font-instance: Face Convenience Functions.
+* face-font-name: Face Convenience Functions.
+* face-foreground: Face Convenience Functions.
+* face-foreground-instance: Face Convenience Functions.
+* face-list: Basic Face Functions.
+* face-property: Face Properties.
+* face-property-instance: Face Properties.
+* face-underline-p: Face Convenience Functions.
+* facep: Basic Face Functions.
+* faces: Faces and Window-System Objects.
+* fallback (in a specifier): Specifier Instancing.
+* false: nil and t.
+* fboundp: Function Cells.
+* fceiling: Rounding Operations.
+* featurep: Named Features.
+* features: Named Features.
+* fetch-bytecode: Dynamic Loading.
+* ffloor: Rounding Operations.
+* field width: Formatting Strings.
+* fifth: List Elements.
+* file accessibility: Testing Accessibility.
+* file age: Testing Accessibility.
+* file attributes: File Attributes.
+* file format conversion: Format Conversion.
+* file hard link: Changing File Attributes.
+* file locks: File Locks.
+* file mode specification error: Auto Major Mode.
+* file modes and MS-DOS: Changing File Attributes.
+* file modification time: Testing Accessibility.
+* file name completion subroutines: File Name Completion.
+* file name of buffer: Buffer File Name.
+* file name of directory: Directory Names.
+* file names: File Names.
+* file names in directory: Contents of Directories.
+* file open error: Subroutines of Visiting.
+* file symbolic links: Kinds of Files.
+* file types on MS-DOS: Files and MS-DOS.
+* file with multiple names: Changing File Attributes.
+* file-accessible-directory-p: Testing Accessibility.
+* file-already-exists: Changing File Attributes.
+* file-attributes: File Attributes.
+* file-directory-p: Kinds of Files.
+* file-error: How Programs Do Loading.
+* file-executable-p: Testing Accessibility.
+* file-exists-p: Testing Accessibility.
+* file-local-copy: Magic File Names.
+* file-locked: File Locks.
+* file-locked-p: File Locks.
+* file-menu-filter: Menu Filters.
+* file-modes: File Attributes.
+* file-name-absolute-p: Relative File Names.
+* file-name-all-completions: File Name Completion.
+* file-name-as-directory: Directory Names.
+* file-name-buffer-file-type-alist: Files and MS-DOS.
+* file-name-completion: File Name Completion.
+* file-name-directory: File Name Components.
+* file-name-history: Minibuffer History.
+* file-name-nondirectory: File Name Components.
+* file-name-sans-extension: File Name Components.
+* file-name-sans-versions: File Name Components.
+* file-newer-than-file-p: Testing Accessibility.
+* file-newest-backup: Backup Names.
+* file-nlinks: File Attributes.
+* file-ownership-preserved-p: Testing Accessibility.
+* file-precious-flag: Saving Buffers.
+* file-readable-p: Testing Accessibility.
+* file-regular-p: Kinds of Files.
+* file-relative-name: File Name Expansion.
+* file-supersession: Modification Time.
+* file-symlink-p: Kinds of Files.
+* file-truename: Truenames.
+* file-writable-p: Testing Accessibility.
+* fill-column: Margins.
+* fill-individual-paragraphs: Filling.
+* fill-individual-varying-indent: Filling.
+* fill-paragraph: Filling.
+* fill-paragraph-function: Filling.
+* fill-prefix: Margins.
+* fill-region: Filling.
+* fill-region-as-paragraph: Filling.
+* fillarray: Array Functions.
+* filling a paragraph: Filling.
+* filling, automatic: Auto Filling.
+* filling, explicit: Filling.
+* filter function: Filter Functions.
+* find-backup-file-name: Backup Names.
+* find-buffer-file-type: Files and MS-DOS.
+* find-charset: Basic Charset Functions.
+* find-charset-region: MULE Characters.
+* find-charset-string: MULE Characters.
+* find-coding-system: Basic Coding System Functions.
+* find-file: Visiting Functions.
+* find-file-binary: Files and MS-DOS.
+* find-file-hooks: Visiting Functions.
+* find-file-name-handler: Magic File Names.
+* find-file-noselect: Visiting Functions.
+* find-file-not-found-hooks: Visiting Functions.
+* find-file-other-window: Visiting Functions.
+* find-file-read-only: Visiting Functions.
+* find-file-text: Files and MS-DOS.
+* find-menu-item: Modifying Menus.
+* finding files: Visiting Files.
+* finding windows: Selecting Windows.
+* first: List Elements.
+* first-change-hook: Change Hooks.
+* fixup-whitespace: User-Level Deletion.
+* float: Numeric Conversions.
+* float-output-format: Output Variables.
+* floating-point numbers, printing: Output Variables.
+* floatp: Predicates on Numbers.
+* floor: Numeric Conversions.
+* flow control characters: Flow Control.
+* flush input: Peeking and Discarding.
+* fmakunbound: Function Cells.
+* focus-frame: Input Focus.
+* following-char: Near Point.
+* font instance characteristics: Font Instance Characteristics.
+* font instance name: Font Instance Names.
+* font instance size: Font Instance Size.
+* font instance type: Font Instance Type.
+* font-instance-name: Font Instance Names.
+* font-instance-p: Font Instances.
+* font-instance-properties: Font Instance Characteristics.
+* font-instance-truename: Font Instance Names.
+* font-name: Font Convenience Functions.
+* font-properties: Font Convenience Functions.
+* font-specifier-p <1>: Font Specifiers.
+* font-specifier-p: Specifier Types.
+* font-truename: Font Convenience Functions.
+* fonts <1>: Fonts.
+* fonts: Some Terms.
+* fonts available: Font Instance Names.
+* foo: A Sample Function Description.
+* for: Argument Evaluation.
+* force-cursor-redisplay: Refresh Screen.
+* force-highlight-extent: Extents and Events.
+* forcing redisplay: Waiting.
+* format: Formatting Strings.
+* format definition: Format Conversion.
+* format of keymaps: Format of Keymaps.
+* format of menus: Menu Format.
+* format of the menubar: Menubar Format.
+* format precision: Formatting Strings.
+* format specification: Formatting Strings.
+* format-alist: Format Conversion.
+* format-buffers-menu-line: Buffers Menu.
+* format-find-file: Format Conversion.
+* format-insert-file: Format Conversion.
+* format-time-string: Time Conversion.
+* format-write-file: Format Conversion.
+* formatting strings: Formatting Strings.
+* formfeed: Character Type.
+* forms: Intro Eval.
+* forward-char: Character Motion.
+* forward-comment: Parsing Expressions.
+* forward-line: Text Lines.
+* forward-list: List Motion.
+* forward-sexp: List Motion.
+* forward-to-indentation: Motion by Indent.
+* forward-word: Word Motion.
+* fourth: List Elements.
+* frame: Frames.
+* frame configuration: Frame Configurations.
+* frame hooks: Frame Hooks.
+* frame name: Frame Name.
+* frame of terminal: Basic Windows.
+* frame position: Size and Position.
+* frame size: Size and Position.
+* frame visibility: Visibility of Frames.
+* frame-device: Basic Device Functions.
+* frame-height: Size and Position.
+* frame-highest-window: Frames and Windows.
+* frame-icon-title-format: Frame Titles.
+* frame-iconified-p: Visibility of Frames.
+* frame-leftmost-window: Frames and Windows.
+* frame-list: Finding All Frames.
+* frame-live-p: Deleting Frames.
+* frame-lowest-window: Frames and Windows.
+* frame-name: Frame Name.
+* frame-pixel-height: Size and Position.
+* frame-pixel-width: Size and Position.
+* frame-properties: Property Access.
+* frame-property: Property Access.
+* frame-rightmost-window: Frames and Windows.
+* frame-root-window: Frames and Windows.
+* frame-selected-window: Frames and Windows.
+* frame-title-format: Frame Titles.
+* frame-totally-visible-p: Visibility of Frames.
+* frame-visible-p: Visibility of Frames.
+* frame-width: Size and Position.
+* framep: Frames.
+* free list: Garbage Collection.
+* frequency counts: Coverage Testing.
+* fround: Rounding Operations.
+* fset: Function Cells.
+* ftp-login: Cleanups.
+* ftruncate: Rounding Operations.
+* funcall: Calling Functions.
+* funcall, and debugging: Internals of Debugger.
+* function <1>: Anonymous Functions.
+* function: What Is a Function.
+* function call: Function Forms.
+* function call debugging: Function Debugging.
+* function cell: Symbol Components.
+* function cell in autoload: Autoload.
+* function definition: Function Names.
+* function descriptions: A Sample Function Description.
+* function form evaluation: Function Forms.
+* function input stream: Input Streams.
+* function invocation: Calling Functions.
+* function name: Function Names.
+* function output stream: Output Streams.
+* function quoting: Anonymous Functions.
+* function-interactive: Using Interactive.
+* function-key-map: Translating Input.
+* function-obsoleteness-doc: Obsoleteness.
+* functionals: Calling Functions.
+* functions in modes: Major Mode Conventions.
+* functions, making them interactive: Defining Commands.
+* Fundamental mode: Major Modes.
+* fundamental-mode: Auto Major Mode.
+* fundamental-mode-abbrev-table: Standard Abbrev Tables.
+* garbage collector: Garbage Collection.
+* garbage-collect: Garbage Collection.
+* gc-cons-threshold: Garbage Collection.
+* gc-message: Garbage Collection.
+* gc-pointer-glyph <1>: Garbage Collection.
+* gc-pointer-glyph: Mouse Pointer.
+* generate-new-buffer: Creating Buffers.
+* generate-new-buffer-name: Buffer Names.
+* generic-specifier-p: Specifier Types.
+* get: Object Plists.
+* get-buffer: Buffer Names.
+* get-buffer-create: Creating Buffers.
+* get-buffer-process: Process Buffers.
+* get-buffer-window: Buffers and Windows.
+* get-char-property: Examining Properties.
+* get-char-table: Working With Char Tables.
+* get-charset: Basic Charset Functions.
+* get-coding-system: Basic Coding System Functions.
+* get-database: Working With a Database.
+* get-file-buffer: Buffer File Name.
+* get-largest-window: Selecting Windows.
+* get-lru-window: Selecting Windows.
+* get-process: Process Information.
+* get-range-char-table: Working With Char Tables.
+* get-range-table: Working With Range Tables.
+* get-register: Registers.
+* get-text-property: Examining Properties.
+* get-tooltalk-message-attribute: Elisp Interface for Sending Messages.
+* getenv: System Environment.
+* getf: Other Plists.
+* gethash: Working With Hash Tables.
+* gettext: Level 3 Primitives.
+* global binding: Local Variables.
+* global break condition: Global Break Condition.
+* global keymap: Active Keymaps.
+* global mark ring: The Mark.
+* global variable: Global Variables.
+* global-abbrev-table: Standard Abbrev Tables.
+* global-key-binding: Functions for Key Lookup.
+* global-map: Active Keymaps.
+* global-mark-ring: The Mark.
+* global-mode-string: Modeline Variables.
+* global-popup-menu: Pop-Up Menus.
+* global-set-key: Key Binding Commands.
+* global-unset-key: Key Binding Commands.
+* glyph type: Glyph Type.
+* glyph-ascent: Glyph Dimensions.
+* glyph-baseline: Glyph Convenience Functions.
+* glyph-baseline-instance: Glyph Convenience Functions.
+* glyph-contrib-p: Glyph Convenience Functions.
+* glyph-contrib-p-instance: Glyph Convenience Functions.
+* glyph-descent: Glyph Dimensions.
+* glyph-face: Glyph Convenience Functions.
+* glyph-height: Glyph Dimensions.
+* glyph-image: Glyph Convenience Functions.
+* glyph-image-instance: Glyph Convenience Functions.
+* glyph-property: Glyph Properties.
+* glyph-property-instance: Glyph Properties.
+* glyph-type: Glyph Types.
+* glyph-type-list: Glyph Types.
+* glyph-width: Glyph Dimensions.
+* glyphp: Glyphs.
+* glyphs: Glyphs.
+* goto-char: Character Motion.
+* goto-line: Text Lines.
+* gutter: Gutter.
+* gutter-buttons-captioned-p: Other Gutter Variables.
+* gutter-make-button-list: Gutter Descriptor Format.
+* gutter-specifier-p: Specifying a Gutter.
+* hack-local-variables: Auto Major Mode.
+* handling errors: Handling Errors.
+* hash notation: Printed Representation.
+* hash table: Hash Tables.
+* hash table type: Hash Table Type.
+* hash table, weak: Weak Hash Tables.
+* hash-table-count: Introduction to Hash Tables.
+* hash-table-p: Hash Tables.
+* hash-table-rehash-size: Introduction to Hash Tables.
+* hash-table-rehash-threshold: Introduction to Hash Tables.
+* hash-table-size: Introduction to Hash Tables.
+* hash-table-test: Introduction to Hash Tables.
+* hash-table-weakness: Introduction to Hash Tables.
+* hashing: Creating Symbols.
+* header comments: Library Headers.
+* help for major mode: Mode Help.
+* help-char: Help Functions.
+* help-command: Help Functions.
+* help-form: Help Functions.
+* help-map <1>: Standard Keymaps.
+* help-map: Help Functions.
+* Helper-describe-bindings: Help Functions.
+* Helper-help: Help Functions.
+* Helper-help-map: Standard Keymaps.
+* hide-annotation: Annotation Properties.
+* highlight-extent: Extents and Events.
+* history list: Minibuffer History.
+* history of commands: Command History.
+* HOME environment variable: Subprocess Creation.
+* hooks: Hooks.
+* hooks for loading: Hooks for Loading.
+* hooks for text changes: Change Hooks.
+* horizontal position: Columns.
+* horizontal scrolling: Horizontal Scrolling.
+* hscroll-glyph: Redisplay Glyphs.
+* icon-glyph-p: Glyph Types.
+* iconified frame: Visibility of Frames.
+* iconify-frame: Visibility of Frames.
+* identity: Calling Functions.
+* IEEE floating point: Float Basics.
+* if: Conditionals.
+* ignore: Calling Functions.
+* ignored-local-variables: Auto Major Mode.
+* image instance type: Image Instance Type.
+* image instance types: Image Instance Types.
+* image instances: Image Instances.
+* image instantiator conversion: Image Instantiator Conversion.
+* image specifiers: Image Specifiers.
+* image-instance-background: Image Instance Functions.
+* image-instance-depth: Image Instance Functions.
+* image-instance-domain: Image Instance Functions.
+* image-instance-file-name: Image Instance Functions.
+* image-instance-foreground: Image Instance Functions.
+* image-instance-height: Image Instance Functions.
+* image-instance-hotspot-x: Image Instance Functions.
+* image-instance-hotspot-y: Image Instance Functions.
+* image-instance-mask-file-name: Image Instance Functions.
+* image-instance-name: Image Instance Functions.
+* image-instance-p: Image Instances.
+* image-instance-string: Image Instance Functions.
+* image-instance-type: Image Instance Types.
+* image-instance-type-list: Image Instance Types.
+* image-instance-width: Image Instance Functions.
+* image-instantiator-format-list: Image Specifiers.
+* image-specifier-p <1>: Image Specifiers.
+* image-specifier-p: Specifier Types.
+* implicit progn: Sequencing.
+* inc: Simple Macro.
+* indent-according-to-mode: Mode-Specific Indent.
+* indent-code-rigidly: Region Indent.
+* indent-for-tab-command: Mode-Specific Indent.
+* indent-line-function: Mode-Specific Indent.
+* indent-region: Region Indent.
+* indent-region-function: Region Indent.
+* indent-relative: Relative Indent.
+* indent-relative-maybe: Relative Indent.
+* indent-rigidly: Region Indent.
+* indent-tabs-mode: Primitive Indent.
+* indent-to: Primitive Indent.
+* indent-to-left-margin: Margins.
+* indentation: Indentation.
+* indenting with parentheses: Parsing Expressions.
+* indirect buffers: Indirect Buffers.
+* indirect specifications: Specification List.
+* indirect variables: Variable Aliases.
+* indirect-function: Function Indirection.
+* indirect-variable: Variable Aliases.
+* indirection: Function Indirection.
+* infinite loops: Infinite Loops.
+* infinite recursion: Local Variables.
+* infinity: Float Basics.
+* Info-edit-map: Standard Keymaps.
+* Info-minibuffer-history: Minibuffer History.
+* Info-mode-map: Standard Keymaps.
+* inherit: Syntax Class Table.
+* inheriting a keymap's bindings: Inheritance and Keymaps.
+* inhibit-default-init: Init File.
+* inhibit-file-name-handlers: Magic File Names.
+* inhibit-file-name-operation: Magic File Names.
+* inhibit-quit: Quitting.
+* inhibit-read-only: Read Only Buffers.
+* inhibit-startup-echo-area-message: Start-up Summary.
+* inhibit-startup-message: Start-up Summary.
+* init file: Init File.
+* initial-frame-plist: Initial Properties.
+* initial-gutter-spec: Other Gutter Variables.
+* initial-major-mode: Auto Major Mode.
+* initial-toolbar-spec: Other Toolbar Variables.
+* initialization: Start-up Summary.
+* inline functions: Inline Functions.
+* innermost containing parentheses: Parsing Expressions.
+* input events: Events.
+* input focus: Input Focus.
+* input modes: Input Modes.
+* input stream: Input Streams.
+* input-pending-p: Peeking and Discarding.
+* insert: Insertion.
+* insert-abbrev-table-description: Abbrev Tables.
+* insert-before-markers: Insertion.
+* insert-buffer: Commands for Insertion.
+* insert-buffer-substring: Insertion.
+* insert-char: Insertion.
+* insert-default-directory: Reading File Names.
+* insert-directory: Contents of Directories.
+* insert-directory-program: Contents of Directories.
+* insert-extent: Detached Extents.
+* insert-file-contents: Reading from Files.
+* insert-register: Registers.
+* insert-string: Insertion.
+* inserting killed text: Yank Commands.
+* insertion before point: Insertion.
+* insertion of text: Insertion.
+* inside comment: Parsing Expressions.
+* inside margin: Annotation Basics.
+* inside string: Parsing Expressions.
+* inst-list (in a specifier): Specifiers In-Depth.
+* inst-pair (in a specifier): Specifiers In-Depth.
+* installation-directory: System Environment.
+* instance (in a specifier): Specifiers In-Depth.
+* instancing (in a specifier): Specifiers In-Depth.
+* instantiator (in a specifier): Specifiers In-Depth.
+* int-char: Character Codes.
+* int-to-string: String Conversion.
+* integer to decimal: String Conversion.
+* integer to hexadecimal: Formatting Strings.
+* integer to octal: Formatting Strings.
+* integer to string: String Conversion.
+* integer-char-or-marker-p: Predicates on Markers.
+* integer-or-char-p: Predicates for Characters.
+* integer-or-marker-p: Predicates on Markers.
+* integer-specifier-p: Specifier Types.
+* integerp: Predicates on Numbers.
+* integers: Numbers.
+* interactive: Using Interactive.
+* interactive call: Interactive Call.
+* interactive code description: Interactive Codes.
+* interactive commands (Edebug): Instrumenting.
+* interactive completion: Interactive Codes.
+* interactive function: Defining Commands.
+* interactive, examples of using: Interactive Examples.
+* interactive-p: Interactive Call.
+* intern: Creating Symbols.
+* intern-soft: Creating Symbols.
+* internal-doc-file-name: Accessing Documentation.
+* interning: Creating Symbols.
+* interpreter: Evaluation.
+* interpreter-mode-alist: Auto Major Mode.
+* interprogram-cut-function: Low-Level Kill Ring.
+* interprogram-paste-function: Low-Level Kill Ring.
+* interrupt-process: Signals to Processes.
+* invalid function: Function Indirection.
+* invalid prefix key error: Changing Key Bindings.
+* invalid-function: Function Indirection.
+* invalid-read-syntax: Printed Representation.
+* invalid-regexp: Syntax of Regexps.
+* invert-face: Other Face Display Functions.
+* invisible frame: Visibility of Frames.
+* invisible text: Invisible Text.
+* invisible-text-glyph: Redisplay Glyphs.
+* invocation-directory: System Environment.
+* invocation-name: System Environment.
+* isearch-mode-map: Standard Keymaps.
+* ISO Latin 1: Case Tables.
+* ISO Latin-1 characters (input): Translating Input.
+* iso-syntax: Case Tables.
+* iso-transl: Translating Input.
+* italic: Font Instance Characteristics.
+* iteration: Iteration.
+* itimer-edit-map: Standard Keymaps.
+* joining lists: Rearrangement.
+* just-one-space: User-Level Deletion.
+* justify-current-line: Filling.
+* kept-new-versions: Numbered Backups.
+* kept-old-versions: Numbered Backups.
+* key: Keymap Terminology.
+* key binding: Keymap Terminology.
+* key lookup: Key Lookup.
+* key sequence: Key Sequence Input.
+* key sequence error: Changing Key Bindings.
+* key sequence input: Key Sequence Input.
+* key sequences: Key Sequences.
+* key translation function: Translating Input.
+* key-binding: Functions for Key Lookup.
+* key-description: Describing Characters.
+* key-press-event-p: Event Predicates.
+* key-translation-map: Translating Input.
+* keyboard macro execution: Interactive Call.
+* keyboard macro termination: Beeping.
+* keyboard macros: Keyboard Macros.
+* keyboard macros (Edebug): Edebug Execution Modes.
+* keyboard menu accelerators: Menu Accelerators.
+* keyboard-quit: Quitting.
+* keymap: Keymaps.
+* keymap entry: Key Lookup.
+* keymap format: Format of Keymaps.
+* keymap in keymap: Key Lookup.
+* keymap inheritance: Inheritance and Keymaps.
+* keymap parent: Inheritance and Keymaps.
+* keymap-default-binding: Inheritance and Keymaps.
+* keymap-fullness: Scanning Keymaps.
+* keymap-name: Creating Keymaps.
+* keymap-parents: Inheritance and Keymaps.
+* keymap-prompt: Other Keymap Functions.
+* keymapp: Format of Keymaps.
+* keymaps in modes: Major Mode Conventions.
+* keys in documentation strings: Keys in Documentation.
+* keystroke: Keymap Terminology.
+* keystroke command: What Is a Function.
+* keywordp: Specification List.
+* kill command repetition: Command Loop Info.
+* kill ring: The Kill Ring.
+* kill-all-local-variables: Creating Buffer-Local.
+* kill-append: Low-Level Kill Ring.
+* kill-buffer: Killing Buffers.
+* kill-buffer-hook: Killing Buffers.
+* kill-buffer-query-functions: Killing Buffers.
+* kill-emacs: Killing XEmacs.
+* kill-emacs-hook: Killing XEmacs.
+* kill-emacs-query-functions: Killing XEmacs.
+* kill-local-variable: Creating Buffer-Local.
+* kill-new: Low-Level Kill Ring.
+* kill-process: Signals to Processes.
+* kill-region: Kill Functions.
+* kill-ring: Internals of Kill Ring.
+* kill-ring-max: Internals of Kill Ring.
+* kill-ring-yank-pointer: Internals of Kill Ring.
+* killing buffers: Killing Buffers.
+* killing XEmacs: Killing XEmacs.
+* lambda expression: Lambda Expressions.
+* lambda expression in hook: Hooks.
+* lambda in debug: Invoking the Debugger.
+* lambda in keymap: Key Lookup.
+* lambda list: Lambda Components.
+* lambda-list (Edebug): Specification List.
+* lambda-list-keywordp: Specification List.
+* last-abbrev: Abbrev Expansion.
+* last-abbrev-location: Abbrev Expansion.
+* last-abbrev-text: Abbrev Expansion.
+* last-command: Command Loop Info.
+* last-command-char: Command Loop Info.
+* last-command-event: Command Loop Info.
+* last-input-char: Peeking and Discarding.
+* last-input-event: Peeking and Discarding.
+* last-kbd-macro: Keyboard Macros.
+* Latin-1 character set (input): Translating Input.
+* lax-plist-get: Working With Lax Plists.
+* lax-plist-member: Working With Lax Plists.
+* lax-plist-put: Working With Lax Plists.
+* lax-plist-remprop: Working With Lax Plists.
+* lax-plists-eq: Working With Lax Plists.
+* lax-plists-equal: Working With Lax Plists.
+* layout policy: Annotation Basics.
+* layout types: Annotation Basics.
+* lazy loading: Dynamic Loading.
+* LDAP: LDAP Support.
+* ldap-add: Low-level Operations on a LDAP Server.
+* ldap-add-entries: The High-Level LDAP API.
+* ldap-attribute-syntax-decoders: LDAP Internationalization Variables.
+* ldap-attribute-syntax-encoders: LDAP Internationalization Variables.
+* ldap-attribute-syntaxes-alist: LDAP Internationalization Variables.
+* ldap-close: Opening and Closing a LDAP Connection.
+* ldap-coding-system: LDAP Internationalization Variables.
+* ldap-decode-address: Encoder/Decoder Functions.
+* ldap-decode-attribute: LDAP Internationalization.
+* ldap-decode-boolean: Encoder/Decoder Functions.
+* ldap-decode-string: Encoder/Decoder Functions.
+* ldap-default-attribute-decoder: LDAP Internationalization Variables.
+* ldap-default-base: LDAP Variables.
+* ldap-default-host: LDAP Variables.
+* ldap-default-port: LDAP Variables.
+* ldap-delete: Low-level Operations on a LDAP Server.
+* ldap-delete-entries: The High-Level LDAP API.
+* ldap-encode-address: Encoder/Decoder Functions.
+* ldap-encode-boolean: Encoder/Decoder Functions.
+* ldap-encode-string: Encoder/Decoder Functions.
+* ldap-host: The LDAP Lisp Object.
+* ldap-host-parameters-alist: LDAP Variables.
+* ldap-ignore-attribute-codings: LDAP Internationalization Variables.
+* ldap-live-p: The LDAP Lisp Object.
+* ldap-modify: Low-level Operations on a LDAP Server.
+* ldap-modify-entries: The High-Level LDAP API.
+* ldap-open: Opening and Closing a LDAP Connection.
+* ldap-search-basic: Low-level Operations on a LDAP Server.
+* ldap-search-entries: The High-Level LDAP API.
+* ldap-verbose: LDAP Variables.
+* ldapp: The LDAP Lisp Object.
+* left-gutter: Specifying a Gutter.
+* left-gutter-visible-p: Other Gutter Variables.
+* left-gutter-width: Other Gutter Variables.
+* left-margin: Margins.
+* left-margin-width: Margin Primitives.
+* left-toolbar: Specifying the Toolbar.
+* left-toolbar-visible-p: Other Toolbar Variables.
+* left-toolbar-width: Other Toolbar Variables.
+* length: Sequence Functions.
+* let: Local Variables.
+* let*: Local Variables.
+* let-specifier: Adding Specifications.
+* lexical binding (Edebug): Edebug Eval.
+* lexical comparison: Text Comparison.
+* library <1>: Loading.
+* library: Package Terminology.
+* library compilation: Compilation Functions.
+* library header comments: Library Headers.
+* line wrapping: Truncation.
+* lines: Text Lines.
+* lines in region: Text Lines.
+* linking files: Changing File Attributes.
+* Lisp debugger: Debugger.
+* Lisp expression motion: List Motion.
+* Lisp history: Lisp History.
+* Lisp library: Loading.
+* Lisp nesting error: Eval.
+* Lisp object: Lisp Data Types.
+* Lisp printer: Output Functions.
+* Lisp reader: Streams Intro.
+* lisp-interaction-mode-map: Standard Keymaps.
+* lisp-mode-abbrev-table: Standard Abbrev Tables.
+* lisp-mode-map: Standard Keymaps.
+* lisp-mode.el: Example Major Modes.
+* list <1>: Building Lists.
+* list: Lists.
+* list elements: List Elements.
+* list form evaluation: Classifying Lists.
+* list in keymap: Key Lookup.
+* list length: Sequence Functions.
+* list motion: List Motion.
+* list structure: Cons Cells.
+* list-buffers: The Buffer List.
+* list-buffers-directory: Buffer File Name.
+* list-fonts: Font Instance Names.
+* list-processes: Process Information.
+* listp: List-related Predicates.
+* lists and cons cells: Cons Cells.
+* lists as sets: Sets And Lists.
+* lists represented as boxes: Lists as Boxes.
+* literal evaluation: Self-Evaluating Forms.
+* lmessage: The Echo Area.
+* ln: Changing File Attributes.
+* load: How Programs Do Loading.
+* load error with require: Named Features.
+* load errors: How Programs Do Loading.
+* load-average: System Environment.
+* load-default-sounds: Beeping.
+* load-history: Unloading.
+* load-ignore-elc-files: How Programs Do Loading.
+* load-in-progress: How Programs Do Loading.
+* load-path: How Programs Do Loading.
+* load-read-function: How Programs Do Loading.
+* load-sound-file: Beeping.
+* load-warn-when-source-newer: How Programs Do Loading.
+* load-warn-when-source-only: How Programs Do Loading.
+* loading: Loading.
+* loading hooks: Hooks for Loading.
+* loadup.el: Building XEmacs.
+* local binding: Local Variables.
+* local keymap: Active Keymaps.
+* local variables: Local Variables.
+* local-abbrev-table: Standard Abbrev Tables.
+* local-key-binding: Functions for Key Lookup.
+* local-set-key: Key Binding Commands.
+* local-unset-key: Key Binding Commands.
+* local-variable-p: Creating Buffer-Local.
+* local-write-file-hooks: Saving Buffers.
+* local.rules: Local.rules File.
+* locale (in a specifier): Specifiers In-Depth.
+* locate-file: How Programs Do Loading.
+* locate-file-clear-hashing: How Programs Do Loading.
+* lock-buffer: File Locks.
+* log: Math Functions.
+* log-message-ignore-labels: The Echo Area.
+* log-message-ignore-regexps: The Echo Area.
+* log-message-max-size: The Echo Area.
+* log-warning-minimum-level: Warnings.
+* log-warning-suppressed-classes: Warnings.
+* log10: Math Functions.
+* logand: Bitwise Operations.
+* logb: Float Basics.
+* logical and: Bitwise Operations.
+* logical exclusive or: Bitwise Operations.
+* logical inclusive or: Bitwise Operations.
+* logical not: Bitwise Operations.
+* logical shift: Bitwise Operations.
+* logior: Bitwise Operations.
+* lognot: Bitwise Operations.
+* logxor: Bitwise Operations.
+* looking-at: Regexp Search.
+* lookup-key: Functions for Key Lookup.
+* loops, infinite: Infinite Loops.
+* lower case: Character Case.
+* lower-frame: Raising and Lowering.
+* lowering a frame: Raising and Lowering.
+* lsh: Bitwise Operations.
+* lwarn: Warnings.
+* M-x: Interactive Call.
+* Maclisp: Lisp History.
+* macro: What Is a Function.
+* macro argument evaluation: Argument Evaluation.
+* macro call: Expansion.
+* macro call evaluation: Macro Forms.
+* macro compilation: Compilation Functions.
+* macro descriptions: A Sample Function Description.
+* macro expansion: Expansion.
+* macroexpand: Expansion.
+* macros: Macros.
+* magic file names: Magic File Names.
+* mail-host-address: System Environment.
+* major mode: Major Modes.
+* major mode hook: Major Mode Conventions.
+* major mode keymap: Active Keymaps.
+* major-mode: Mode Help.
+* make-abbrev-table: Abbrev Tables.
+* make-annotation: Annotation Primitives.
+* make-auto-save-file-name: Auto-Saving.
+* make-backup-file-name: Backup Names.
+* make-backup-files: Making Backups.
+* make-bit-vector: Bit Vector Functions.
+* make-boolean-specifier: Creating Specifiers.
+* make-byte-code: Compiled-Function Objects.
+* make-char: MULE Characters.
+* make-char-table: Working With Char Tables.
+* make-charset: Basic Charset Functions.
+* make-coding-system: Basic Coding System Functions.
+* make-color-specifier: Color Specifiers.
+* make-composite-char: Composite Characters.
+* make-device: Connecting to a Console or Device.
+* make-directory: Create/Delete Dirs.
+* make-display-table: Display Table Format.
+* make-display-table-specifier: Creating Specifiers.
+* make-event: Working With Events.
+* make-extent: Creating and Modifying Extents.
+* make-face: Basic Face Functions.
+* make-face-boolean-specifier: Color Specifiers.
+* make-file-part: Creating a Partial File.
+* make-font-instance: Font Instances.
+* make-font-specifier: Font Specifiers.
+* make-frame: Creating Frames.
+* make-frame-invisible: Visibility of Frames.
+* make-frame-visible: Visibility of Frames.
+* make-generic-specifier: Creating Specifiers.
+* make-glyph: Creating Glyphs.
+* make-glyph-internal: Creating Glyphs.
+* make-gutter-size-specifier: Creating Gutter.
+* make-gutter-specifier: Creating Gutter.
+* make-gutter-visible-specifier: Creating Gutter.
+* make-hash-table: Introduction to Hash Tables.
+* make-icon-glyph: Creating Glyphs.
+* make-image-instance: Image Instance Functions.
+* make-image-specifier: Image Specifiers.
+* make-indirect-buffer: Indirect Buffers.
+* make-integer-specifier: Creating Specifiers.
+* make-keymap: Creating Keymaps.
+* make-list: Building Lists.
+* make-local-hook: Hooks.
+* make-local-variable: Creating Buffer-Local.
+* make-marker: Creating Markers.
+* make-natnum-specifier: Creating Specifiers.
+* make-obsolete: Obsoleteness.
+* make-obsolete-variable: Obsoleteness.
+* make-pointer-glyph: Creating Glyphs.
+* make-range-table: Introduction to Range Tables.
+* make-reverse-direction-charset: Basic Charset Functions.
+* make-sparse-keymap: Creating Keymaps.
+* make-specifier: Creating Specifiers.
+* make-specifier-and-init: Creating Specifiers.
+* make-string: Creating Strings.
+* make-symbol: Creating Symbols.
+* make-symbolic-link: Changing File Attributes.
+* make-syntax-table: Syntax Table Functions.
+* make-temp-name: Unique File Names.
+* make-toolbar-specifier: Creating Toolbar.
+* make-tooltalk-message: Elisp Interface for Sending Messages.
+* make-tooltalk-pattern: Elisp Interface for Receiving Messages.
+* make-tty-device: Connecting to a Console or Device.
+* make-variable-buffer-local: Creating Buffer-Local.
+* make-vector: Vector Functions.
+* make-weak-list: Weak Lists.
+* make-x-device: Connecting to a Console or Device.
+* Makefile, package: Makefile.
+* makunbound: Void Variables.
+* Manual-page-minibuffer-history: Minibuffer History.
+* map-char-table: Working With Char Tables.
+* map-database: Working With a Database.
+* map-extent-children: Mapping Over Extents.
+* map-extents: Mapping Over Extents.
+* map-frame-hook: Frame Hooks.
+* map-keymap: Scanning Keymaps.
+* map-range-table: Working With Range Tables.
+* map-specifier: Other Specification Functions.
+* map-y-or-n-p: Multiple Queries.
+* mapatoms: Creating Symbols.
+* mapcar: Mapping Functions.
+* mapcar-extents: Mapping Over Extents.
+* mapconcat: Mapping Functions.
+* maphash: Working With Hash Tables.
+* mapping functions: Mapping Functions.
+* margin: Annotation Basics.
+* margin width: Margin Primitives.
+* mark: The Mark.
+* mark excursion: Excursions.
+* mark ring: The Mark.
+* mark, the: The Mark.
+* mark-marker: The Mark.
+* mark-ring: The Mark.
+* mark-ring-max: The Mark.
+* marker argument: Interactive Codes.
+* marker garbage collection: Overview of Markers.
+* marker input stream: Input Streams.
+* marker output stream: Output Streams.
+* marker relocation: Overview of Markers.
+* marker-buffer: Information from Markers.
+* marker-position: Information from Markers.
+* markerp: Predicates on Markers.
+* markers: Markers.
+* markers as numbers: Overview of Markers.
+* markers vs. extents: Overview of Markers.
+* match data: Match Data.
+* match-beginning: Simple Match Data.
+* match-data: Entire Match Data.
+* match-end: Simple Match Data.
+* match-string: Simple Match Data.
+* mathematical functions: Math Functions.
+* max: Comparison of Numbers.
+* max-lisp-eval-depth: Eval.
+* max-specpdl-size: Local Variables.
+* md5: Transformations.
+* MD5 digests: Transformations.
+* member: Sets And Lists.
+* membership in a list: Sets And Lists.
+* memory allocation: Garbage Collection.
+* memq: Sets And Lists.
+* menu: Menus.
+* menu accelerators: Menu Accelerators.
+* menu filters: Menu Filters.
+* menu format: Menu Format.
+* menu-accelerator-enabled: Menu Accelerator Functions.
+* menu-accelerator-map: Menu Accelerator Functions.
+* menu-accelerator-modifiers: Menu Accelerator Functions.
+* menu-accelerator-prefix: Menu Accelerator Functions.
+* menu-no-selection-hook: Menubar.
+* menubar: Menubar.
+* menubar format: Menubar Format.
+* menubar-configuration: Menu Format.
+* menubar-pointer-glyph: Mouse Pointer.
+* menubar-show-keybindings: Menubar.
+* message: The Echo Area.
+* meta character printing: Describing Characters.
+* meta-prefix-char: Functions for Key Lookup.
+* min: Comparison of Numbers.
+* minibuffer: Minibuffers.
+* minibuffer history: Minibuffer History.
+* minibuffer input: Recursive Editing.
+* minibuffer window: Cyclic Window Ordering.
+* minibuffer-complete: Completion Commands.
+* minibuffer-complete-and-exit: Completion Commands.
+* minibuffer-complete-word: Completion Commands.
+* minibuffer-completion-confirm: Completion Commands.
+* minibuffer-completion-help: Completion Commands.
+* minibuffer-completion-predicate: Completion Commands.
+* minibuffer-completion-table: Completion Commands.
+* minibuffer-depth: Minibuffer Misc.
+* minibuffer-exit-hook: Minibuffer Misc.
+* minibuffer-frame-plist: Initial Properties.
+* minibuffer-help-form: Minibuffer Misc.
+* minibuffer-history: Minibuffer History.
+* minibuffer-local-completion-map <1>: Standard Keymaps.
+* minibuffer-local-completion-map: Completion Commands.
+* minibuffer-local-isearch-map: Standard Keymaps.
+* minibuffer-local-map <1>: Standard Keymaps.
+* minibuffer-local-map: Text from Minibuffer.
+* minibuffer-local-must-match-map <1>: Standard Keymaps.
+* minibuffer-local-must-match-map: Completion Commands.
+* minibuffer-prompt: Minibuffer Misc.
+* minibuffer-prompt-width: Minibuffer Misc.
+* minibuffer-scroll-window: Minibuffer Misc.
+* minibuffer-setup-hook: Minibuffer Misc.
+* minibuffer-window: Minibuffer Misc.
+* minibuffer-window-active-p: Minibuffer Misc.
+* minimum window size: Resizing Windows.
+* minor mode: Minor Modes.
+* minor mode conventions: Minor Mode Conventions.
+* minor-mode-alist: Modeline Variables.
+* minor-mode-key-binding: Functions for Key Lookup.
+* minor-mode-map-alist: Active Keymaps.
+* misc-user-event-p: Event Predicates.
+* mod: Arithmetic Operations.
+* mode: Modes.
+* mode help: Mode Help.
+* mode hook: Major Mode Conventions.
+* mode loading: Major Mode Conventions.
+* mode variable: Minor Mode Conventions.
+* mode-class property: Major Mode Conventions.
+* mode-name: Modeline Variables.
+* mode-popup-menu: Pop-Up Menus.
+* mode-specific-map <1>: Standard Keymaps.
+* mode-specific-map: Prefix Keys.
+* modeline: Modeline Format.
+* modeline construct: Modeline Data.
+* modeline-buffer-identification: Modeline Variables.
+* modeline-format: Modeline Data.
+* modeline-map <1>: Standard Keymaps.
+* modeline-map: Active Keymaps.
+* modeline-modified: Modeline Variables.
+* modeline-pointer-glyph: Mouse Pointer.
+* modeline-process: Modeline Variables.
+* modification flag (of buffer): Buffer Modification.
+* modification of lists: Rearrangement.
+* modification time, comparison of: Modification Time.
+* modify-syntax-entry: Syntax Table Functions.
+* modulus: Arithmetic Operations.
+* momentary-string-display: Temporary Displays.
+* mono-pixmap-image-instance-p: Image Instance Types.
+* motion-event-p: Event Predicates.
+* mouse cursor: Mouse Pointer.
+* mouse pointer: Mouse Pointer.
+* mouse-event-p: Event Predicates.
+* mouse-grabbed-buffer: Active Keymaps.
+* mouse-highlight-priority: Extents and Events.
+* move-marker: Changing Markers.
+* move-to-column: Columns.
+* move-to-left-margin: Margins.
+* move-to-window-line: Screen Lines.
+* MS-DOS and file modes: Changing File Attributes.
+* MS-DOS file types: Files and MS-DOS.
+* MSWindows OLE: MSWindows OLE.
+* multilingual string formatting: Formatting Strings.
+* multiple windows: Basic Windows.
+* named function: Function Names.
+* NaN: Float Basics.
+* narrow-to-page: Narrowing.
+* narrow-to-region: Narrowing.
+* narrowing: Narrowing.
+* natnum-specifier-p: Specifier Types.
+* natnump: Predicates on Numbers.
+* natural numbers: Predicates on Numbers.
+* nconc: Rearrangement.
+* negative infinity: Float Basics.
+* negative-argument: Prefix Command Arguments.
+* network connection: Network.
+* new file message: Subroutines of Visiting.
+* newline <1>: Commands for Insertion.
+* newline: Character Type.
+* newline and Auto Fill mode: Commands for Insertion.
+* newline in print: Output Functions.
+* newline in strings: String Type.
+* newline-and-indent: Mode-Specific Indent.
+* next input: Peeking and Discarding.
+* next-command-event: Reading One Event.
+* next-event: Reading One Event.
+* next-extent: Finding Extents.
+* next-frame: Finding All Frames.
+* next-history-element: Minibuffer Misc.
+* next-matching-history-element: Minibuffer Misc.
+* next-property-change: Property Search.
+* next-screen-context-lines: Vertical Scrolling.
+* next-single-property-change: Property Search.
+* next-window: Cyclic Window Ordering.
+* nil: Constant Variables.
+* nil and lists: Cons Cells.
+* nil in keymap: Key Lookup.
+* nil in lists: Cons Cell Type.
+* nil input stream: Input Streams.
+* nil output stream: Output Streams.
+* nil, uses of: nil and t.
+* ninth: List Elements.
+* nlistp: List-related Predicates.
+* no-catch: Catch and Throw.
+* no-redraw-on-reenter: Refresh Screen.
+* nondirectory part (of file name): File Name Components.
+* noninteractive: Batch Mode.
+* noninteractive use: Batch Mode.
+* nonlocal exits: Nonlocal Exits.
+* nonprinting characters, reading: Quoted Character Input.
+* nontext-pointer-glyph: Mouse Pointer.
+* normal-mode: Auto Major Mode.
+* not: Combining Conditions.
+* not-modified: Buffer Modification.
+* nothing-image-instance-p: Image Instance Types.
+* nreverse: Rearrangement.
+* nth: List Elements.
+* nthcdr: List Elements.
+* null: List-related Predicates.
+* number equality: Comparison of Numbers.
+* number-char-or-marker-p: Predicates on Markers.
+* number-or-marker-p: Predicates on Markers.
+* number-to-string: String Conversion.
+* numberp: Predicates on Numbers.
+* numbers: Numbers.
+* numeric prefix: Formatting Strings.
+* numeric prefix argument: Prefix Command Arguments.
+* numeric prefix argument usage: Interactive Codes.
+* obarray: Creating Symbols.
+* obarray in completion: Basic Completion.
+* objc-mode-map: Standard Keymaps.
+* object: Lisp Data Types.
+* object to string: Output Functions.
+* object-plist: Object Plists.
+* oblique: Font Instance Characteristics.
+* obsolete buffer: Modification Time.
+* occur-mode-map: Standard Keymaps.
+* octal character code: Character Type.
+* octal character input: Quoted Character Input.
+* octal-escape-glyph: Redisplay Glyphs.
+* OffiX DND: OffiX DND.
+* old-eq: Equality Predicates.
+* one-window-p: Splitting Windows.
+* only-global-abbrevs: Defining Abbrevs.
+* open-database: Connecting to a Database.
+* open-dribble-file: Recording Input.
+* open-network-stream: Network.
+* open-termscript: Terminal Output.
+* open parenthesis character: Syntax Class Table.
+* operating system environment: System Environment.
+* option descriptions: A Sample Variable Description.
+* optional arguments: Argument List.
+* options on command line: Command Line Arguments.
+* or: Combining Conditions.
+* order of extents: Extent Endpoints.
+* ordering of windows, cyclic: Cyclic Window Ordering.
+* other-buffer: The Buffer List.
+* other-window: Cyclic Window Ordering.
+* other-window-scroll-buffer: Vertical Scrolling.
+* Outline mode: Substitution.
+* output from processes: Output from Processes.
+* output stream: Output Streams.
+* outside margin: Annotation Basics.
+* overflow: Integer Basics.
+* overlay arrow: Overlay Arrow.
+* overlay-arrow-position: Overlay Arrow.
+* overlay-arrow-string: Overlay Arrow.
+* overriding-local-map <1>: Standard Keymaps.
+* overriding-local-map: Active Keymaps.
+* overriding-terminal-local-map: Active Keymaps.
+* overwrite-mode: Commands for Insertion.
+* package <1>: Package Terminology.
+* package: Packaging.
+* package building: Building Packages.
+* package distributions: Package Terminology.
+* package Makefile: Makefile.
+* package makefile targets: Makefile Targets.
+* package-compile.el: Makefile.
+* package-info: package-info.in.
+* package-info.in: package-info.in.
+* packaging: Packaging.
+* padding: Formatting Strings.
+* page-delimiter: Standard Regexps.
+* paired delimiter: Syntax Class Table.
+* paragraph-separate: Standard Regexps.
+* paragraph-start: Standard Regexps.
+* parent of a keymap: Inheritance and Keymaps.
+* parent process: Processes.
+* parent, of extent: Extent Parents.
+* parenthesis: Cons Cell Type.
+* parenthesis depth: Parsing Expressions.
+* parenthesis matching: Blinking.
+* parenthesis syntax: Syntax Class Table.
+* parse state: Parsing Expressions.
+* parse-partial-sexp: Parsing Expressions.
+* parse-sexp-ignore-comments: Parsing Expressions.
+* parsing: Syntax Tables.
+* partial files: Partial Files.
+* passwd-echo: Reading a Password.
+* passwd-invert-frame-when-keyboard-grabbed: Reading a Password.
+* passwords, reading: Reading a Password.
+* PATH environment variable: Subprocess Creation.
+* path-separator: System Environment.
+* pausing: Waiting.
+* peeking at input: Peeking and Discarding.
+* percent symbol in modeline: Modeline Data.
+* perform-replace: Search and Replace.
+* performance analysis: Coverage Testing.
+* permanent local variable: Creating Buffer-Local.
+* permission: File Attributes.
+* pg-coding-system: libpq Lisp Variables.
+* pg:authtype: libpq Lisp Variables.
+* pg:client-encoding: libpq Lisp Variables.
+* pg:cost-heap: libpq Lisp Variables.
+* pg:cost-index: libpq Lisp Variables.
+* pg:database: libpq Lisp Variables.
+* pg:date-style: libpq Lisp Variables.
+* pg:geqo: libpq Lisp Variables.
+* pg:host: libpq Lisp Variables.
+* pg:options: libpq Lisp Variables.
+* pg:port: libpq Lisp Variables.
+* pg:realm: libpq Lisp Variables.
+* pg:tty: libpq Lisp Variables.
+* pg:tz: libpq Lisp Variables.
+* pg:user: libpq Lisp Variables.
+* pgres::polling-active: libpq Lisp Symbols and DataTypes.
+* pgres::polling-failed: libpq Lisp Symbols and DataTypes.
+* pgres::polling-ok: libpq Lisp Symbols and DataTypes.
+* pgres::polling-reading: libpq Lisp Symbols and DataTypes.
+* pgres::polling-writing: libpq Lisp Symbols and DataTypes.
+* pipes: Asynchronous Processes.
+* play-sound: Beeping.
+* play-sound-file: Beeping.
+* plist: Property Lists.
+* plist, symbol: Symbol Properties.
+* plist-get: Working With Normal Plists.
+* plist-member: Working With Normal Plists.
+* plist-put: Working With Normal Plists.
+* plist-remprop: Working With Normal Plists.
+* plist-to-alist: Converting Plists To/From Alists.
+* plists-eq <1>: Other Plists.
+* plists-eq: Working With Normal Plists.
+* plists-equal <1>: Other Plists.
+* plists-equal: Working With Normal Plists.
+* point: Point.
+* point excursion: Excursions.
+* point in window: Window Point.
+* point with narrowing: Point.
+* point-marker: Creating Markers.
+* point-max: Point.
+* point-max-marker: Creating Markers.
+* point-min: Point.
+* point-min-marker: Creating Markers.
+* pointer (mouse): Mouse Pointer.
+* pointer-glyph-p: Glyph Types.
+* pointer-image-instance-p: Image Instance Types.
+* pop-global-mark: The Mark.
+* pop-mark: The Mark.
+* pop-to-buffer: Displaying Buffers.
+* pop-up menu: Pop-Up Menus.
+* pop-up-frame-function: Choosing Window.
+* pop-up-frame-plist: Choosing Window.
+* pop-up-frames: Choosing Window.
+* pop-up-windows: Choosing Window.
+* popup-buffer-menu: Pop-Up Menus.
+* popup-dialog-box: Dialog Box Functions.
+* popup-menu: Pop-Up Menus.
+* popup-menu-titles: Pop-Up Menus.
+* popup-menu-up-p: Pop-Up Menus.
+* popup-menubar-menu: Pop-Up Menus.
+* popup-mode-menu: Pop-Up Menus.
+* pos-visible-in-window-p: Window Start.
+* position (in buffer): Positions.
+* position argument: Interactive Codes.
+* position in window: Window Point.
+* position of frame: Size and Position.
+* position of window: Position of Window.
+* positive infinity: Float Basics.
+* posix-looking-at: POSIX Regexps.
+* posix-search-backward: POSIX Regexps.
+* posix-search-forward: POSIX Regexps.
+* posix-string-match: POSIX Regexps.
+* post-command-hook: Command Overview.
+* post-gc-hook: Garbage Collection.
+* PostgreSQL: PostgreSQL Support.
+* pq-binary-tuples: libpq Lisp Symbols and DataTypes.
+* pq-clear: Other libpq Functions.
+* pq-client-encoding: Other libpq Functions.
+* pq-cmd-status: libpq Lisp Symbols and DataTypes.
+* pq-cmd-tuples: libpq Lisp Symbols and DataTypes.
+* pq-conn-defaults: Other libpq Functions.
+* pq-connect-poll: Asynchronous Interface Functions.
+* pq-connect-start: Asynchronous Interface Functions.
+* pq-connectdb: Synchronous Interface Functions.
+* pq-consume-input: Asynchronous Interface Functions.
+* pq-env-2-encoding: Other libpq Functions.
+* pq-exec: Synchronous Interface Functions.
+* pq-finish: Other libpq Functions.
+* pq-flush: Asynchronous Interface Functions.
+* pq-fmod: libpq Lisp Symbols and DataTypes.
+* pq-fname: libpq Lisp Symbols and DataTypes.
+* pq-fnumber: libpq Lisp Symbols and DataTypes.
+* pq-fsize: libpq Lisp Symbols and DataTypes.
+* pq-ftype: libpq Lisp Symbols and DataTypes.
+* pq-get-is-null: libpq Lisp Symbols and DataTypes.
+* pq-get-length: libpq Lisp Symbols and DataTypes.
+* pq-get-result: Asynchronous Interface Functions.
+* pq-get-value: libpq Lisp Symbols and DataTypes.
+* pq-is-busy: Asynchronous Interface Functions.
+* pq-is-nonblocking: Asynchronous Interface Functions.
+* pq-lo-close: Unimplemented libpq Functions.
+* pq-lo-creat: Unimplemented libpq Functions.
+* pq-lo-export: Large Object Support.
+* pq-lo-import: Large Object Support.
+* pq-lo-lseek: Unimplemented libpq Functions.
+* pq-lo-open: Unimplemented libpq Functions.
+* pq-lo-read: Unimplemented libpq Functions.
+* pq-lo-tell: Unimplemented libpq Functions.
+* pq-lo-unlink: Unimplemented libpq Functions.
+* pq-lo-write: Unimplemented libpq Functions.
+* pq-make-empty-pgresult: libpq Lisp Symbols and DataTypes.
+* pq-nfields: libpq Lisp Symbols and DataTypes.
+* pq-notifies: Synchronous Interface Functions.
+* pq-ntuples: libpq Lisp Symbols and DataTypes.
+* pq-oid-value: libpq Lisp Symbols and DataTypes.
+* pq-pgconn: libpq Lisp Symbols and DataTypes.
+* pq-res-status: libpq Lisp Symbols and DataTypes.
+* pq-reset: Synchronous Interface Functions.
+* pq-reset-cancel: Asynchronous Interface Functions.
+* pq-reset-poll: Asynchronous Interface Functions.
+* pq-reset-start: Asynchronous Interface Functions.
+* pq-result-error-message: libpq Lisp Symbols and DataTypes.
+* pq-result-status: libpq Lisp Symbols and DataTypes.
+* pq-send-query: Asynchronous Interface Functions.
+* pq-set-client-encoding: Other libpq Functions.
+* pq-set-nonblocking: Asynchronous Interface Functions.
+* PQdisplayTuples: Unimplemented libpq Functions.
+* PQmblen: Unimplemented libpq Functions.
+* PQprint: Unimplemented libpq Functions.
+* PQprintTuples: Unimplemented libpq Functions.
+* PQsetenv: Synchronous Interface Functions.
+* PQsetenvAbort: Asynchronous Interface Functions.
+* PQsetenvPoll: Asynchronous Interface Functions.
+* PQsetenvStart: Asynchronous Interface Functions.
+* PQsocket: Unimplemented libpq Functions.
+* PQtrace: Unimplemented libpq Functions.
+* PQuntrace: Unimplemented libpq Functions.
+* pre-abbrev-expand-hook: Abbrev Expansion.
+* pre-command-hook: Command Overview.
+* pre-gc-hook: Garbage Collection.
+* preceding-char: Near Point.
+* precision of formatted numbers: Formatting Strings.
+* predicates: Type Predicates.
+* prefix argument: Prefix Command Arguments.
+* prefix argument unreading: Peeking and Discarding.
+* prefix command: Prefix Keys.
+* prefix key: Prefix Keys.
+* prefix-arg: Prefix Command Arguments.
+* prefix-help-command: Help Functions.
+* prefix-numeric-value: Prefix Command Arguments.
+* preventing backtracking: Specification List.
+* preventing prefix key: Key Lookup.
+* previous complete subexpression: Parsing Expressions.
+* previous-extent: Finding Extents.
+* previous-frame: Finding All Frames.
+* previous-history-element: Minibuffer Misc.
+* previous-matching-history-element: Minibuffer Misc.
+* previous-property-change: Property Search.
+* previous-single-property-change: Property Search.
+* previous-window: Cyclic Window Ordering.
+* primitive: What Is a Function.
+* primitive type: Lisp Data Types.
+* primitive types: Primitive Types.
+* primitive-undo: Undo.
+* prin1: Output Functions.
+* prin1-to-string: Output Functions.
+* princ: Output Functions.
+* print: Output Functions.
+* print example: Output Streams.
+* print name cell: Symbol Components.
+* print-escape-newlines: Output Variables.
+* print-gensym: Output Variables.
+* print-help-return-message: Help Functions.
+* print-length: Output Variables.
+* print-level: Output Variables.
+* print-readably <1>: Output Variables.
+* print-readably: Printing in Edebug.
+* print-string-length: Output Variables.
+* printed representation: Printed Representation.
+* printed representation for characters: Character Type.
+* printing: Streams Intro.
+* printing (Edebug): Printing in Edebug.
+* printing circular structures: Printing in Edebug.
+* printing floating-point numbers: Output Variables.
+* printing limits: Output Variables.
+* printing notation: Printing Notation.
+* printing readably: Output Variables.
+* printing uninterned symbols: Output Variables.
+* priority of an extent: Intro to Extents.
+* process: Processes.
+* process filter: Filter Functions.
+* process input: Input to Processes.
+* process output: Output from Processes.
+* process sentinel: Sentinels.
+* process signals: Signals to Processes.
+* process window size: Process Window Size.
+* process-buffer: Process Buffers.
+* process-command: Process Information.
+* process-connection-type: Asynchronous Processes.
+* process-environment: System Environment.
+* process-event-p: Event Predicates.
+* process-exit-status: Process Information.
+* process-filter: Filter Functions.
+* process-id: Process Information.
+* process-kill-without-query: Deleting Processes.
+* process-kill-without-query-p: Process Information.
+* process-list: Process Information.
+* process-mark: Process Buffers.
+* process-name: Process Information.
+* process-send-eof: Input to Processes.
+* process-send-region: Input to Processes.
+* process-send-signal: Signals to Processes.
+* process-send-string: Input to Processes.
+* process-sentinel: Sentinels.
+* process-status: Process Information.
+* process-tty-name: Process Information.
+* processp: Processes.
+* profile.el: Compilation Tips.
+* profiling: Compilation Tips.
+* prog1: Sequencing.
+* prog2: Sequencing.
+* progn: Sequencing.
+* program arguments: Subprocess Creation.
+* program directories: Subprocess Creation.
+* programmed completion: Programmed Completion.
+* programming types: Programming Types.
+* properties of strings: String Properties.
+* properties of text: Text Properties.
+* property list: Property Lists.
+* property list cell (symbol): Symbol Components.
+* property list, symbol: Symbol Properties.
+* property lists vs association lists: Plists and Alists.
+* property of an extent: Extent Properties.
+* protected forms: Cleanups.
+* provide: Named Features.
+* providing features: Named Features.
+* PTYs: Asynchronous Processes.
+* punctuation character: Syntax Class Table.
+* pure storage: Pure Storage.
+* pure-bytes-used: Pure Storage.
+* purecopy: Pure Storage.
+* purify-flag: Pure Storage.
+* push-mark: The Mark.
+* put: Object Plists.
+* put-char-table: Working With Char Tables.
+* put-database: Working With a Database.
+* put-range-table: Working With Range Tables.
+* put-text-property: Changing Properties.
+* putf: Other Plists.
+* puthash: Working With Hash Tables.
+* query-replace-history: Minibuffer History.
+* query-replace-map <1>: Standard Keymaps.
+* query-replace-map: Search and Replace.
+* querying the user: Yes-or-No Queries.
+* question mark in character constant: Character Type.
+* quietly-read-abbrev-file: Abbrev Files.
+* quit-flag: Quitting.
+* quit-process: Signals to Processes.
+* quitting: Quitting.
+* quitting from infinite loop: Infinite Loops.
+* quote: Quoting.
+* quote character: Parsing Expressions.
+* quoted character input: Quoted Character Input.
+* quoted-insert suppression: Changing Key Bindings.
+* quoting: Quoting.
+* quoting characters in printing: Output Functions.
+* quoting using apostrophe: Quoting.
+* raise-frame: Raising and Lowering.
+* raising a frame: Raising and Lowering.
+* random: Random Numbers.
+* random numbers: Random Numbers.
+* range table type: Range Table Type.
+* Range Tables: Range Tables.
+* range-table-p: Range Tables.
+* rassoc: Association Lists.
+* rassq: Association Lists.
+* raw prefix argument: Prefix Command Arguments.
+* raw prefix argument usage: Interactive Codes.
+* re-search-backward: Regexp Search.
+* re-search-forward: Regexp Search.
+* read: Input Functions.
+* read command name: Interactive Call.
+* read syntax: Printed Representation.
+* read syntax for characters: Character Type.
+* read-buffer: High-Level Completion.
+* read-char: Reading One Event.
+* read-command: High-Level Completion.
+* read-expression: Object from Minibuffer.
+* read-expression-history: Minibuffer History.
+* read-expression-map: Standard Keymaps.
+* read-file-name: Reading File Names.
+* read-from-minibuffer: Text from Minibuffer.
+* read-from-string: Input Functions.
+* read-key-sequence: Key Sequence Input.
+* read-minibuffer: Object from Minibuffer.
+* read-only buffer: Read Only Buffers.
+* read-only buffers in interactive: Using Interactive.
+* read-passwd: Reading a Password.
+* read-quoted-char: Quoted Character Input.
+* read-quoted-char quitting: Quitting.
+* read-shell-command-map: Standard Keymaps.
+* read-string: Text from Minibuffer.
+* read-variable: High-Level Completion.
+* reading: Streams Intro.
+* reading (Edebug): Reading in Edebug.
+* reading interactive arguments: Interactive Codes.
+* reading symbols: Creating Symbols.
+* rearrangement of lists: Rearrangement.
+* rebinding: Changing Key Bindings.
+* receiving ToolTalk messages: Receiving Messages.
+* recent-auto-save-p: Auto-Saving.
+* recent-keys: Recording Input.
+* recent-keys-ring-size: Recording Input.
+* recenter: Vertical Scrolling.
+* record command history: Interactive Call.
+* recursion: Iteration.
+* recursion-depth: Recursive Editing.
+* recursive command loop: Recursive Editing.
+* recursive editing level: Recursive Editing.
+* recursive evaluation: Intro Eval.
+* recursive-edit: Recursive Editing.
+* redo: Undo.
+* redraw-display: Refresh Screen.
+* redraw-frame: Refresh Screen.
+* redraw-modeline: Modeline Format.
+* refresh display: Refresh Screen.
+* regexp: Regular Expressions.
+* regexp alternative: Syntax of Regexps.
+* regexp grouping: Syntax of Regexps.
+* regexp searching: Regexp Search.
+* regexp-history: Minibuffer History.
+* regexp-quote: Syntax of Regexps.
+* regexps used standardly in editing: Standard Regexps.
+* region argument: Interactive Codes.
+* region, the: The Region.
+* region-active-p: The Region.
+* region-beginning: The Region.
+* region-end: The Region.
+* region-exists-p: The Region.
+* register-alist: Registers.
+* register-ccl-program: Calling CCL.
+* register-tooltalk-pattern: Elisp Interface for Receiving Messages.
+* registers: Registers.
+* regular expression: Regular Expressions.
+* regular expression searching: Regexp Search.
+* regular package: Package Terminology.
+* reindent-then-newline-and-indent: Mode-Specific Indent.
+* relabel-menu-item: Modifying Menus.
+* relative file name: Relative File Names.
+* remainder: Arithmetic Operations.
+* remassoc: Association Lists.
+* remassq: Association Lists.
+* remhash: Working With Hash Tables.
+* remove-database: Working With a Database.
+* remove-face-property: Face Properties.
+* remove-glyph-property: Glyph Properties.
+* remove-hook: Hooks.
+* remove-range-table: Working With Range Tables.
+* remove-specifier: Other Specification Functions.
+* remove-text-properties: Changing Properties.
+* remprop: Object Plists.
+* remrassoc: Association Lists.
+* remrassq: Association Lists.
+* rename-auto-save-file: Auto-Saving.
+* rename-buffer: Buffer Names.
+* rename-file: Changing File Attributes.
+* renaming files: Changing File Attributes.
+* repeated loading: Repeated Loading.
+* replace bindings: Changing Key Bindings.
+* replace characters: Substitution.
+* replace-buffer-in-windows: Displaying Buffers.
+* replace-match: Replacing Match.
+* replacement: Search and Replace.
+* repositioning format arguments: Formatting Strings.
+* require: Named Features.
+* require-final-newline: Saving Buffers.
+* requiring features: Named Features.
+* reset-char-table: Working With Char Tables.
+* resize redisplay: Size and Position.
+* rest arguments: Argument List.
+* restriction (in a buffer): Narrowing.
+* resume (cf. no-redraw-on-reenter): Refresh Screen.
+* return: Character Type.
+* return-tooltalk-message: Elisp Interface for Sending Messages.
+* reveal-annotation: Annotation Properties.
+* reverse: Building Lists.
+* reversing a list: Rearrangement.
+* revert-buffer: Reverting.
+* revert-buffer-function: Reverting.
+* revert-buffer-insert-file-contents-function: Reverting.
+* right-gutter: Specifying a Gutter.
+* right-gutter-visible-p: Other Gutter Variables.
+* right-gutter-width: Other Gutter Variables.
+* right-margin-width: Margin Primitives.
+* right-toolbar: Specifying the Toolbar.
+* right-toolbar-visible-p: Other Toolbar Variables.
+* right-toolbar-width: Other Toolbar Variables.
+* rm: Changing File Attributes.
+* round: Numeric Conversions.
+* rounding in conversions: Numeric Conversions.
+* rounding without conversion: Rounding Operations.
+* rplaca: Modifying Lists.
+* rplacd: Modifying Lists.
+* run time stack: Internals of Debugger.
+* run-emacs-from-temacs: Building XEmacs.
+* run-hooks: Hooks.
+* runnable temacs: Building XEmacs.
+* same-window-buffer-names: Choosing Window.
+* same-window-regexps: Choosing Window.
+* save-abbrevs: Abbrev Files.
+* save-buffer: Saving Buffers.
+* save-current-buffer: Excursions.
+* save-excursion: Excursions.
+* save-excursion (Edebug): Edebug Display Update.
+* save-match-data: Saving Match Data.
+* save-restriction: Narrowing.
+* save-selected-frame: Input Focus.
+* save-selected-window <1>: Excursions.
+* save-selected-window: Selecting Windows.
+* save-some-buffers: Saving Buffers.
+* save-window-excursion: Window Configurations.
+* saving text properties: Saving Properties.
+* saving window information: Window Configurations.
+* scan-lists: Parsing Expressions.
+* scan-sexps: Parsing Expressions.
+* scope: Variable Scoping.
+* screen layout: Window Configuration Type.
+* scroll-conservatively: Vertical Scrolling.
+* scroll-down: Vertical Scrolling.
+* scroll-left: Horizontal Scrolling.
+* scroll-other-window: Vertical Scrolling.
+* scroll-right: Horizontal Scrolling.
+* scroll-step: Vertical Scrolling.
+* scroll-up: Vertical Scrolling.
+* scrollbar-pointer-glyph: Mouse Pointer.
+* scrollbars: Scrollbars.
+* scrolling vertically: Vertical Scrolling.
+* search-backward: String Search.
+* search-failed: String Search.
+* search-forward: String Search.
+* searching: Searching and Matching.
+* searching and case: Searching and Case.
+* searching for regexp: Regexp Search.
+* second: List Elements.
+* select-console: The Selected Console and Device.
+* select-device: The Selected Console and Device.
+* select-frame: Input Focus.
+* select-frame-hook: Frame Hooks.
+* select-window: Selecting Windows.
+* selected frame: Input Focus.
+* selected window: Basic Windows.
+* selected-console: The Selected Console and Device.
+* selected-device: The Selected Console and Device.
+* selected-frame: Input Focus.
+* selected-window: Selecting Windows.
+* selecting a buffer: Current Buffer.
+* selecting windows: Selecting Windows.
+* selection (for X windows): X Selections.
+* selection-pointer-glyph: Mouse Pointer.
+* selective display: Selective Display.
+* selective-display: Selective Display.
+* selective-display-ellipses: Selective Display.
+* self-evaluating form: Self-Evaluating Forms.
+* self-insert-and-exit: Minibuffer Misc.
+* self-insert-command: Commands for Insertion.
+* self-insert-command override: Changing Key Bindings.
+* self-insert-command, minor modes: Keymaps and Minor Modes.
+* self-insertion: Commands for Insertion.
+* send-string-to-terminal: Terminal Output.
+* send-tooltalk-message: Elisp Interface for Sending Messages.
+* sending signals: Signals to Processes.
+* sending ToolTalk messages: Sending Messages.
+* sentence-end: Standard Regexps.
+* sentinel: Sentinels.
+* sequence: Sequences Arrays Vectors.
+* sequence length: Sequence Functions.
+* sequencep: Sequence Functions.
+* set: Setting Variables.
+* set-annotation-action: Annotation Properties.
+* set-annotation-data: Annotation Properties.
+* set-annotation-down-glyph: Annotation Properties.
+* set-annotation-face: Annotation Properties.
+* set-annotation-glyph: Annotation Properties.
+* set-annotation-layout: Annotation Properties.
+* set-annotation-menu: Annotation Properties.
+* set-auto-mode: Auto Major Mode.
+* set-buffer: Current Buffer.
+* set-buffer-auto-saved: Auto-Saving.
+* set-buffer-major-mode: Auto Major Mode.
+* set-buffer-menubar: Menubar.
+* set-buffer-modified-p: Buffer Modification.
+* set-case-syntax: Case Tables.
+* set-case-syntax-delims: Case Tables.
+* set-case-syntax-pair: Case Tables.
+* set-case-table: Case Tables.
+* set-category-table: Category Tables.
+* set-charset-ccl-program: Charset Property Functions.
+* set-charset-registry: Charset Property Functions.
+* set-coding-category-system: Detection of Textual Encoding.
+* set-coding-priority-list: Detection of Textual Encoding.
+* set-console-type-image-conversion-list: Image Instantiator Conversion.
+* set-default: Default Value.
+* set-default-file-modes: Changing File Attributes.
+* set-default-gutter-position: Specifying a Gutter.
+* set-default-toolbar-position: Specifying the Toolbar.
+* set-device-baud-rate <1>: Terminal Output.
+* set-device-baud-rate: Console and Device I/O.
+* set-extent-begin-glyph: Extent Properties.
+* set-extent-begin-glyph-layout: Extent Properties.
+* set-extent-end-glyph: Extent Properties.
+* set-extent-end-glyph-layout: Extent Properties.
+* set-extent-endpoints: Extent Endpoints.
+* set-extent-face: Extent Properties.
+* set-extent-initial-redisplay-function: Extent Properties.
+* set-extent-keymap: Extent Properties.
+* set-extent-mouse-face: Extent Properties.
+* set-extent-parent: Extent Parents.
+* set-extent-priority: Extent Properties.
+* set-extent-properties: Extent Properties.
+* set-extent-property: Extent Properties.
+* set-face-background: Face Convenience Functions.
+* set-face-background-pixmap: Face Convenience Functions.
+* set-face-font: Face Convenience Functions.
+* set-face-foreground: Face Convenience Functions.
+* set-face-property: Face Properties.
+* set-face-underline-p: Face Convenience Functions.
+* set-file-modes: Changing File Attributes.
+* set-frame-configuration: Frame Configurations.
+* set-frame-pointer: Mouse Pointer.
+* set-frame-position: Size and Position.
+* set-frame-properties: Property Access.
+* set-frame-property: Property Access.
+* set-frame-size: Size and Position.
+* set-glyph-baseline: Glyph Convenience Functions.
+* set-glyph-contrib-p: Glyph Convenience Functions.
+* set-glyph-face: Glyph Convenience Functions.
+* set-glyph-image: Glyph Convenience Functions.
+* set-glyph-property: Glyph Properties.
+* set-input-mode: Input Modes.
+* set-keymap-default-binding: Inheritance and Keymaps.
+* set-keymap-name: Creating Keymaps.
+* set-keymap-parents: Inheritance and Keymaps.
+* set-keymap-prompt: Other Keymap Functions.
+* set-left-margin: Margins.
+* set-mark: The Mark.
+* set-marker: Changing Markers.
+* set-match-data: Entire Match Data.
+* set-menubar: Menubar.
+* set-menubar-dirty-flag: Menubar.
+* set-process-buffer: Process Buffers.
+* set-process-filter: Filter Functions.
+* set-process-sentinel: Sentinels.
+* set-process-window-size: Process Window Size.
+* set-recent-keys-ring-size: Recording Input.
+* set-register: Registers.
+* set-right-margin: Margins.
+* set-specifier: Adding Specifications.
+* set-standard-case-table: Case Tables.
+* set-syntax-table: Syntax Table Functions.
+* set-text-properties: Changing Properties.
+* set-tooltalk-message-attribute: Elisp Interface for Sending Messages.
+* set-visited-file-modtime: Modification Time.
+* set-visited-file-name: Buffer File Name.
+* set-weak-list-list: Weak Lists.
+* set-window-buffer: Buffers and Windows.
+* set-window-buffer-dedicated: Choosing Window.
+* set-window-configuration: Window Configurations.
+* set-window-dedicated-p: Choosing Window.
+* set-window-hscroll: Horizontal Scrolling.
+* set-window-point: Window Point.
+* set-window-start: Window Start.
+* setcar: Setcar.
+* setcdr: Setcdr.
+* setenv: System Environment.
+* setplist: Object Plists.
+* setq: Setting Variables.
+* setq-default: Default Value.
+* sets: Sets And Lists.
+* setting modes of files: Changing File Attributes.
+* setting-constant: Constant Variables.
+* seventh: List Elements.
+* sexp motion: List Motion.
+* shadowing of variables: Local Variables.
+* shallow binding: Impl of Scope.
+* shared-lisp-mode-map: Standard Keymaps.
+* Shell mode modeline-format: Modeline Data.
+* shell-command-history: Minibuffer History.
+* shrink-window: Resizing Windows.
+* shrink-window-horizontally: Resizing Windows.
+* shrink-window-pixels: Resizing Windows.
+* side effect: Intro Eval.
+* signal: Signaling Errors.
+* signal-error: Signaling Errors.
+* signal-process: Signals to Processes.
+* signaling errors: Signaling Errors.
+* signals: Signals to Processes.
+* sin: Math Functions.
+* single-file package: Package Terminology.
+* single-key-description: Describing Characters.
+* sinh: Math Functions.
+* sit-for: Waiting.
+* site-init.el: Building XEmacs.
+* site-load.el: Building XEmacs.
+* site-run-file: Init File.
+* site-start.el: Start-up Summary.
+* sixth: List Elements.
+* size of frame: Size and Position.
+* size of window: Size of Window.
+* skip-chars-backward: Skipping Characters.
+* skip-chars-forward: Skipping Characters.
+* skip-syntax-backward: Motion and Syntax.
+* skip-syntax-forward: Motion and Syntax.
+* skipping characters: Skipping Characters.
+* skipping comments: Parsing Expressions.
+* sleep-for: Waiting.
+* Snarf-documentation: Accessing Documentation.
+* sort: Rearrangement.
+* sort-columns: Sorting.
+* sort-fields: Sorting.
+* sort-lines: Sorting.
+* sort-numeric-fields: Sorting.
+* sort-pages: Sorting.
+* sort-paragraphs: Sorting.
+* sort-regexp-fields: Sorting.
+* sort-subr: Sorting.
+* sorting lists: Rearrangement.
+* sorting text: Sorting.
+* sound: Beeping.
+* sound-alist: Beeping.
+* source packages: Package Terminology.
+* special: Major Mode Conventions.
+* special form descriptions: A Sample Function Description.
+* special form evaluation: Special Forms.
+* special forms: Primitive Function Type.
+* special forms (Edebug): Instrumenting.
+* special forms for control structures: Control Structures.
+* special-display-buffer-names: Choosing Window.
+* special-display-frame-plist: Choosing Window.
+* special-display-function: Choosing Window.
+* special-display-popup-frame: Choosing Window.
+* special-display-regexps: Choosing Window.
+* specification (in a specifier): Specifiers In-Depth.
+* specifier: Specifiers.
+* specifier examples: Simple Specifier Usage.
+* specifier type: Specifier Type.
+* specifier, domain: Specifiers In-Depth.
+* specifier, fallback: Specifier Instancing.
+* specifier, inst-list: Specifiers In-Depth.
+* specifier, inst-pair: Specifiers In-Depth.
+* specifier, instance: Specifiers In-Depth.
+* specifier, instancing: Specifiers In-Depth.
+* specifier, instantiator: Specifiers In-Depth.
+* specifier, locale: Specifiers In-Depth.
+* specifier, specification: Specifiers In-Depth.
+* specifier, tag: Specifiers In-Depth.
+* specifier, tag set: Specifiers In-Depth.
+* specifier-fallback: Retrieving Specifications.
+* specifier-instance: Specifier Instancing Functions.
+* specifier-instance-from-inst-list: Specifier Instancing Functions.
+* specifier-locale-type-from-locale: Other Specification Functions.
+* specifier-matching-instance: Specifier Instancing Functions.
+* specifier-spec-list: Retrieving Specifications.
+* specifier-specs: Retrieving Specifications.
+* specifier-tag-list: Specifier Tag Functions.
+* specifier-tag-predicate: Specifier Tag Functions.
+* specifier-type: Specifier Types.
+* specifierp: Specifiers.
+* speedups: Compilation Tips.
+* splicing (with backquote): Backquote.
+* split-height-threshold: Choosing Window.
+* split-line: Commands for Insertion.
+* split-path: Regexp Search.
+* split-string: Regexp Search.
+* split-window: Splitting Windows.
+* split-window-horizontally: Splitting Windows.
+* split-window-vertically: Splitting Windows.
+* splitting windows: Splitting Windows.
+* sqrt: Math Functions.
+* stable sort: Rearrangement.
+* standard regexps used in editing: Standard Regexps.
+* standard-case-table: Case Tables.
+* standard-category-table: Category Tables.
+* standard-input: Input Functions.
+* standard-output: Output Variables.
+* standard-syntax-table: Standard Syntax Tables.
+* standards of coding style: Tips.
+* start up of XEmacs: Start-up Summary.
+* start-process: Asynchronous Processes.
+* start-process-shell-command: Asynchronous Processes.
+* startup.el: Start-up Summary.
+* stop points: Using Edebug.
+* stop-process: Signals to Processes.
+* stopping an infinite loop: Infinite Loops.
+* stopping on events: Global Break Condition.
+* store-match-data: Entire Match Data.
+* stream (for printing): Output Streams.
+* stream (for reading): Input Streams.
+* string: Creating Strings.
+* string equality: Text Comparison.
+* string in keymap: Key Lookup.
+* string input stream: Input Streams.
+* string length: Sequence Functions.
+* string length, maximum when printing: Output Variables.
+* string properties: String Properties.
+* string search: String Search.
+* string to character: String Conversion.
+* string to number: String Conversion.
+* string to object: Input Functions.
+* string, writing a doc string: Documentation Basics.
+* string-equal: Text Comparison.
+* string-lessp: Text Comparison.
+* string-match: Regexp Search.
+* string-modified-tick: Modifying Strings.
+* string-to-char: String Conversion.
+* string-to-int: String Conversion.
+* string-to-number: String Conversion.
+* string<: Text Comparison.
+* string=: Text Comparison.
+* stringp: Predicates for Strings.
+* strings: Strings and Characters.
+* strings, formatting them: Formatting Strings.
+* strings, modifying: Modifying Strings.
+* string quote: Syntax Class Table.
+* subprocess: Processes.
+* subr: What Is a Function.
+* subrp: What Is a Function.
+* subsidiary-coding-system: Basic Coding System Functions.
+* subst-char-in-region: Substitution.
+* substitute-command-keys: Keys in Documentation.
+* substitute-in-file-name: File Name Expansion.
+* substitute-key-definition: Changing Key Bindings.
+* substituting keys in documentation: Keys in Documentation.
+* substring: Creating Strings.
+* subwindow type: Subwindow Type.
+* subwindow-image-instance-p: Image Instance Types.
+* subwindowp: Subwindows.
+* suppress-keymap: Changing Key Bindings.
+* suspend (cf. no-redraw-on-reenter): Refresh Screen.
+* suspend evaluation: Recursive Editing.
+* suspend-emacs: Suspending XEmacs.
+* suspend-hook: Suspending XEmacs.
+* suspend-resume-hook: Suspending XEmacs.
+* suspending XEmacs: Suspending XEmacs.
+* switch-to-buffer: Displaying Buffers.
+* switch-to-buffer-other-window: Displaying Buffers.
+* switches on command line: Command Line Arguments.
+* switching to a buffer: Displaying Buffers.
+* symbol: Symbols.
+* symbol components: Symbol Components.
+* symbol equality: Creating Symbols.
+* symbol evaluation: Symbol Forms.
+* symbol function indirection: Function Indirection.
+* symbol in keymap: Key Lookup.
+* symbol name hashing: Creating Symbols.
+* symbol-function: Function Cells.
+* symbol-name: Creating Symbols.
+* symbol-plist: Object Plists.
+* symbol-value: Accessing Variables.
+* symbolp: Symbols.
+* symbol constituent: Syntax Class Table.
+* synchronous subprocess: Synchronous Processes.
+* syntax classes: Syntax Descriptors.
+* syntax descriptor: Syntax Descriptors.
+* syntax error (Edebug): Backtracking.
+* syntax flags: Syntax Flags.
+* syntax for characters: Character Type.
+* syntax table: Syntax Tables.
+* syntax table example: Example Major Modes.
+* syntax table internals: Syntax Table Internals.
+* syntax tables in modes: Major Mode Conventions.
+* syntax-table: Syntax Table Functions.
+* syntax-table-p: Syntax Basics.
+* system-configuration: System Environment.
+* system-name: System Environment.
+* system-type: System Environment.
+* t: Constant Variables.
+* t and truth: nil and t.
+* t input stream: Input Streams.
+* t output stream: Output Streams.
+* tab: Character Type.
+* tab deletion: Deletion.
+* tab-stop-list: Indent Tabs.
+* tab-to-tab-stop: Indent Tabs.
+* tab-width: Usual Display.
+* tabs stops for indentation: Indent Tabs.
+* tag (in a specifier): Specifiers In-Depth.
+* tag on run time stack: Catch and Throw.
+* tag set (in a specifier): Specifiers In-Depth.
+* tan: Math Functions.
+* tanh: Math Functions.
+* TCP: Network.
+* temacs: Building XEmacs.
+* temp-buffer-show-function: Temporary Displays.
+* temp-directory: Unique File Names.
+* tenth: List Elements.
+* TERM environment variable: Terminal-Specific.
+* term-file-prefix: Terminal-Specific.
+* term-setup-hook: Terminal-Specific.
+* Termcap: Terminal-Specific.
+* terminal frame <1>: Frames.
+* terminal frame: Basic Windows.
+* terminal input: Terminal Input.
+* terminal input modes: Input Modes.
+* terminal output: Terminal Output.
+* terminal-device: Console Types and Device Classes.
+* terminal-specific initialization: Terminal-Specific.
+* terminate keyboard macro: Peeking and Discarding.
+* termscript file: Terminal Output.
+* terpri: Output Functions.
+* testing types: Type Predicates.
+* text: Text.
+* text files and binary files: Files and MS-DOS.
+* text insertion: Insertion.
+* text parsing: Syntax Tables.
+* text properties: Text Properties.
+* text properties in files: Saving Properties.
+* text-char-description: Describing Characters.
+* text-image-instance-p: Image Instance Types.
+* text-mode-abbrev-table: Standard Abbrev Tables.
+* text-mode-map: Standard Keymaps.
+* text-mode-syntax-table: Standard Syntax Tables.
+* text-pointer-glyph: Mouse Pointer.
+* text-properties-at: Examining Properties.
+* text-property-any: Property Search.
+* text-property-not-all: Property Search.
+* third: List Elements.
+* this-command: Command Loop Info.
+* this-command-keys: Command Loop Info.
+* throw: Catch and Throw.
+* throw example: Recursive Editing.
+* tiled windows: Basic Windows.
+* timeout-event-p: Event Predicates.
+* timing programs: Compilation Tips.
+* tips: Tips.
+* toggle-read-only: Read Only Buffers.
+* toolbar: Toolbar.
+* toolbar button type: Toolbar Button Type.
+* toolbar button, adding: Simple Specifier Usage.
+* toolbar-buttons-captioned-p: Other Toolbar Variables.
+* toolbar-make-button-list: Toolbar Descriptor Format.
+* toolbar-map <1>: Standard Keymaps.
+* toolbar-map: Active Keymaps.
+* toolbar-pointer-glyph: Mouse Pointer.
+* toolbar-specifier-p <1>: Specifier Types.
+* toolbar-specifier-p: Specifying the Toolbar.
+* ToolTalk: ToolTalk Support.
+* ToolTalk message: Sending Messages.
+* ToolTalk pattern: Receiving Messages.
+* top-gutter: Specifying a Gutter.
+* top-gutter-height: Other Gutter Variables.
+* top-gutter-visible-p: Other Gutter Variables.
+* top-level: Recursive Editing.
+* top-level form: Loading.
+* top-toolbar: Specifying the Toolbar.
+* top-toolbar-height: Other Toolbar Variables.
+* top-toolbar-visible-p: Other Toolbar Variables.
+* tq-close: Transaction Queues.
+* tq-create: Transaction Queues.
+* tq-enqueue: Transaction Queues.
+* tracing: Tracing.
+* transaction queue: Transaction Queues.
+* transcendental functions: Math Functions.
+* translate-region: Substitution.
+* translating input events: Translating Input.
+* transpose-regions: Transposition.
+* true: nil and t.
+* truename (of file): Truenames.
+* truncate: Numeric Conversions.
+* truncate-lines: Truncation.
+* truncate-partial-width-windows: Truncation.
+* truncation-glyph: Redisplay Glyphs.
+* truth value: nil and t.
+* try-completion: Basic Completion.
+* two's complement: Integer Basics.
+* type: Lisp Data Types.
+* type checking: Type Predicates.
+* type predicates: Type Predicates.
+* type-of: Type Predicates.
+* unbinding keys: Key Binding Commands.
+* undefined: Functions for Key Lookup.
+* undefined in keymap: Key Lookup.
+* undefined key: Keymap Terminology.
+* undo avoidance: Substitution.
+* undo-boundary: Undo.
+* undo-limit: Maintaining Undo.
+* undo-strong-limit: Maintaining Undo.
+* unexec: Building XEmacs.
+* unhandled-file-name-directory: Magic File Names.
+* unintern: Creating Symbols.
+* uninterned symbol: Creating Symbols.
+* uninterned symbols, printing: Output Variables.
+* unique extents: Duplicable Extents.
+* universal-argument: Prefix Command Arguments.
+* unload-feature: Unloading.
+* unloading: Unloading.
+* unlock-buffer: File Locks.
+* unmap-frame-hook: Frame Hooks.
+* unread-command-event: Peeking and Discarding.
+* unread-command-events: Peeking and Discarding.
+* unreading: Input Streams.
+* unregister-tooltalk-pattern: Elisp Interface for Receiving Messages.
+* unwind-protect: Cleanups.
+* unwinding: Cleanups.
+* up-list: List Motion.
+* upcase: Character Case.
+* upcase-region: Case Changes.
+* upcase-word: Case Changes.
+* update display: Refresh Screen.
+* update-directory-autoloads: Autoload.
+* update-file-autoloads: Autoload.
+* upper case: Character Case.
+* upper case key sequence: Key Sequence Input.
+* use-global-map: Active Keymaps.
+* use-hard-newlines: Filling.
+* use-left-overflow: Margin Primitives.
+* use-local-map: Active Keymaps.
+* use-right-overflow: Margin Primitives.
+* user name completion subroutines: User Name Completion.
+* user option: Defining Variables.
+* user-defined error: Error Symbols.
+* user-full-name: User Identification.
+* user-home-directory: User Identification.
+* user-login-name: User Identification.
+* user-mail-address: User Identification.
+* user-name-all-completions: User Name Completion.
+* user-name-completion: User Name Completion.
+* user-name-completion-1: User Name Completion.
+* user-real-login-name: User Identification.
+* user-real-uid: User Identification.
+* user-uid: User Identification.
+* user-variable-p: Defining Variables.
+* user-variable-p example: High-Level Completion.
+* valid-char-table-type-p: Char Table Types.
+* valid-char-table-value-p: Working With Char Tables.
+* valid-device-class-p: Console Types and Device Classes.
+* valid-device-type-p: Console Types and Device Classes.
+* valid-glyph-type-p: Glyph Types.
+* valid-image-instance-type-p: Image Instance Types.
+* valid-image-instantiator-format-p: Image Specifiers.
+* valid-inst-list-p: Specifier Validation Functions.
+* valid-instantiator-p: Specifier Validation Functions.
+* valid-plist-p: Property Lists.
+* valid-spec-list-p: Specifier Validation Functions.
+* valid-specifier-domain-p: Specifier Validation Functions.
+* valid-specifier-locale-p: Specifier Validation Functions.
+* valid-specifier-locale-type-p: Specifier Validation Functions.
+* valid-specifier-tag-p <1>: Specifier Validation Functions.
+* valid-specifier-tag-p: Specifier Tag Functions.
+* valid-specifier-tag-set-p: Specifier Tag Functions.
+* valid-specifier-type-p: Specifier Validation Functions.
+* value cell: Symbol Components.
+* value of expression: Evaluation.
+* values: Eval.
+* variable: Variables.
+* variable aliases: Variable Aliases.
+* variable definition: Defining Variables.
+* variable descriptions: A Sample Variable Description.
+* variable limit error: Local Variables.
+* variable-alias: Variable Aliases.
+* variable-documentation: Documentation Basics.
+* variable-obsoleteness-doc: Obsoleteness.
+* variables, buffer-local: Buffer-Local Variables.
+* variables, indirect: Variable Aliases.
+* vc-mode: Modeline Variables.
+* vconcat: Vector Functions.
+* vector <1>: Vector Functions.
+* vector: Vectors.
+* vector evaluation: Self-Evaluating Forms.
+* vector length: Sequence Functions.
+* vectorp: Vector Functions.
+* verify-visited-file-modtime: Modification Time.
+* version number (in file name): File Name Components.
+* version-control: Numbered Backups.
+* vertical scrolling: Vertical Scrolling.
+* vertical tab: Character Type.
+* vertical-motion: Screen Lines.
+* vertical-motion-pixels: Screen Lines.
+* view-file: Visiting Functions.
+* view-mode-map: Standard Keymaps.
+* view-register: Registers.
+* visible frame: Visibility of Frames.
+* visible-bell: Beeping.
+* visible-frame-list: Finding All Frames.
+* visited file: Buffer File Name.
+* visited file mode: Auto Major Mode.
+* visited-file-modtime: Modification Time.
+* visiting files: Visiting Files.
+* void function: Function Indirection.
+* void function cell: Function Cells.
+* void variable: Void Variables.
+* void-function: Function Cells.
+* void-variable: Void Variables.
+* waiting: Waiting.
+* waiting for command key input: Peeking and Discarding.
+* waiting-for-user-input-p: Sentinels.
+* wakeup: Subprocess Creation.
+* walk-windows: Cyclic Window Ordering.
+* weak hash table: Weak Hash Tables.
+* weak list: Weak Lists.
+* weak list type: Weak List Type.
+* weak-list-list: Weak Lists.
+* weak-list-p: Weak Lists.
+* weak-list-type: Weak Lists.
+* where-is-internal: Scanning Keymaps.
+* while: Iteration.
+* whitespace: Character Type.
+* whitespace character: Syntax Class Table.
+* widen: Narrowing.
+* widening: Narrowing.
+* widget-image-instance-p: Image Instance Types.
+* window: Basic Windows.
+* window configuration (Edebug): Edebug Display Update.
+* window configurations: Window Configurations.
+* window excursions: Excursions.
+* window ordering, cyclic: Cyclic Window Ordering.
+* window point: Window Point.
+* window position <1>: Position of Window.
+* window position: Window Point.
+* window resizing: Resizing Windows.
+* window size: Size of Window.
+* window size, changing: Resizing Windows.
+* window splitting: Splitting Windows.
+* window system types: Window-System Types.
+* window top line: Window Start.
+* window-buffer: Buffers and Windows.
+* window-configuration-p: Window Configurations.
+* window-dedicated-p: Choosing Window.
+* window-displayed-text-pixel-height: Size of Window.
+* window-end: Window Start.
+* window-frame: Frames and Windows.
+* window-height: Size of Window.
+* window-highest-p: Position of Window.
+* window-hscroll: Horizontal Scrolling.
+* window-left-margin-pixel-width: Margin Primitives.
+* window-live-p: Deleting Windows.
+* window-lowest-p: Position of Window.
+* window-min-height: Resizing Windows.
+* window-min-width: Resizing Windows.
+* window-minibuffer-p: Minibuffer Misc.
+* window-pixel-edges: Position of Window.
+* window-pixel-height: Size of Window.
+* window-pixel-width: Size of Window.
+* window-point: Window Point.
+* window-right-margin-pixel-width: Margin Primitives.
+* window-setup-hook: Terminal-Specific.
+* window-size-change-functions: Resizing Windows.
+* window-start: Window Start.
+* window-system objects: Faces and Window-System Objects.
+* window-text-area-pixel-edges: Position of Window.
+* window-text-area-pixel-height: Size of Window.
+* window-text-area-pixel-width: Size of Window.
+* window-width: Size of Window.
+* windowp: Basic Windows.
+* windows, controlling precisely: Buffers and Windows.
+* with-current-buffer: Excursions.
+* with-output-to-temp-buffer: Temporary Displays.
+* with-selected-frame: Input Focus.
+* with-temp-file: Excursions.
+* word search: String Search.
+* word-search-backward: String Search.
+* word-search-forward: String Search.
+* words-include-escapes: Word Motion.
+* word constituent: Syntax Class Table.
+* write-abbrev-file: Abbrev Files.
+* write-char: Output Functions.
+* write-contents-hooks: Saving Buffers.
+* write-file: Saving Buffers.
+* write-file-hooks: Saving Buffers.
+* write-region: Writing to Files.
+* write-region-annotate-functions: Saving Properties.
+* writing a documentation string: Documentation Basics.
+* wrong-number-of-arguments: Argument List.
+* wrong-type-argument: Type Predicates.
+* X: X-Windows.
+* X resource type: X Resource Type.
+* X window frame: Frames.
+* x-allow-sendevents: X Miscellaneous.
+* x-bitmap-file-path <1>: X Miscellaneous.
+* x-bitmap-file-path: Image Specifiers.
+* x-debug-events: X Miscellaneous.
+* x-debug-mode: X Miscellaneous.
+* x-disown-selection: X Selections.
+* x-display-visual-class: Server Data.
+* x-emacs-application-class: Resources.
+* x-find-larger-font: Font Instance Size.
+* x-find-smaller-font: Font Instance Size.
+* x-font-size: Font Instance Size.
+* x-get-cutbuffer: X Selections.
+* x-get-resource: Resources.
+* x-get-selection: X Selections.
+* x-grab-keyboard: Grabs.
+* x-grab-pointer: Grabs.
+* x-library-search-path: X Miscellaneous.
+* x-make-font-bold: Font Instance Characteristics.
+* x-make-font-bold-italic: Font Instance Characteristics.
+* x-make-font-italic: Font Instance Characteristics.
+* x-make-font-unbold: Font Instance Characteristics.
+* x-make-font-unitalic: Font Instance Characteristics.
+* x-own-selection: X Selections.
+* x-put-resource: Resources.
+* x-server-vendor: Server Data.
+* x-server-version: Server Data.
+* x-set-frame-icon-pixmap: Frame Titles.
+* x-store-cutbuffer: X Selections.
+* x-ungrab-keyboard: Grabs.
+* x-ungrab-pointer: Grabs.
+* x-valid-keysym-name-p: X Miscellaneous.
+* x-window-id: X Miscellaneous.
+* X-Windows: X-Windows.
+* XEmacs event standard notation: Describing Characters.
+* xpm-color-symbols: Image Specifiers.
+* y-or-n-p: Yes-or-No Queries.
+* y-or-n-p-maybe-dialog-box: Yes-or-No Queries.
+* yank: Yank Commands.
+* yank suppression: Changing Key Bindings.
+* yank-pop: Yank Commands.
+* yes-or-no questions: Yes-or-No Queries.
+* yes-or-no-p: Yes-or-No Queries.
+* yes-or-no-p-dialog-box: Yes-or-No Queries.
+* yes-or-no-p-maybe-dialog-box: Yes-or-No Queries.
+* zero-length extent: Extent Endpoints.
+* zerop: Predicates on Numbers.
+* zmacs-activate-region: The Region.
+* zmacs-activate-region-hook: The Region.
+* zmacs-deactivate-region: The Region.
+* zmacs-deactivate-region-hook: The Region.
+* zmacs-region-stays: The Region.
+* zmacs-regions: The Region.
+* zmacs-update-region: The Region.
+* zmacs-update-region-hook: The Region.
+* | in regexp: Syntax of Regexps.
-* Intro to Buffer-Local:: Introduction and concepts.
-* Creating Buffer-Local:: Creating and destroying buffer-local bindings.
-* Default Value:: The default value is seen in buffers
- that don't have their own local values.
projects / chise / xemacs-chise.git.1 / blobdiff