-This is ../info/lispref.info, produced by makeinfo version 4.0 from
+This is ../info/lispref.info, produced by makeinfo version 4.0b from
lispref/lispref.texi.
INFO-DIR-SECTION XEmacs Editor
Foundation instead of in the original English.
\1f
-File: lispref.info, Node: Index, Prev: Standard Hooks, Up: Top
+File: lispref.info, Node: Internationalization Terminology, Next: Charsets, Up: MULE
-Index
-*****
+Internationalization Terminology
+================================
+
+ In internationalization terminology, a string of text is divided up
+into "characters", which are the printable units that make up the text.
+A single character is (for example) a capital `A', the number `2', a
+Katakana character, a Hangul character, a Kanji ideograph (an
+"ideograph" is a "picture" character, such as is used in Japanese
+Kanji, Chinese Hanzi, and Korean Hanja; typically there are thousands
+of such ideographs in each language), etc. The basic property of a
+character is that it is the smallest unit of text with semantic
+significance in text processing.
+
+ Human beings normally process text visually, so to a first
+approximation a character may be identified with its shape. Note that
+the same character may be drawn by two different people (or in two
+different fonts) in slightly different ways, although the "basic shape"
+will be the same. But consider the works of Scott Kim; human beings
+can recognize hugely variant shapes as the "same" character.
+Sometimes, especially where characters are extremely complicated to
+write, completely different shapes may be defined as the "same"
+character in national standards. The Taiwanese variant of Hanzi is
+generally the most complicated; over the centuries, the Japanese,
+Koreans, and the People's Republic of China have adopted
+simplifications of the shape, but the line of descent from the original
+shape is recorded, and the meanings and pronunciation of different
+forms of the same character are considered to be identical within each
+language. (Of course, it may take a specialist to recognize the
+related form; the point is that the relations are standardized, despite
+the differing shapes.)
+
+ In some cases, the differences will be significant enough that it is
+actually possible to identify two or more distinct shapes that both
+represent the same character. For example, the lowercase letters `a'
+and `g' each have two distinct possible shapes--the `a' can optionally
+have a curved tail projecting off the top, and the `g' can be formed
+either of two loops, or of one loop and a tail hanging off the bottom.
+Such distinct possible shapes of a character are called "glyphs". The
+important characteristic of two glyphs making up the same character is
+that the choice between one or the other is purely stylistic and has no
+linguistic effect on a word (this is the reason why a capital `A' and
+lowercase `a' are different characters rather than different
+glyphs--e.g. `Aspen' is a city while `aspen' is a kind of tree).
+
+ Note that "character" and "glyph" are used differently here than
+elsewhere in XEmacs.
+
+ A "character set" is essentially a set of related characters. ASCII,
+for example, is a set of 94 characters (or 128, if you count
+non-printing characters). Other character sets are ISO8859-1 (ASCII
+plus various accented characters and other international symbols), JIS
+X 0201 (ASCII, more or less, plus half-width Katakana), JIS X 0208
+(Japanese Kanji), JIS X 0212 (a second set of less-used Japanese Kanji),
+GB2312 (Mainland Chinese Hanzi), etc.
+
+ The definition of a character set will implicitly or explicitly give
+it an "ordering", a way of assigning a number to each character in the
+set. For many character sets, there is a natural ordering, for example
+the "ABC" ordering of the Roman letters. But it is not clear whether
+digits should come before or after the letters, and in fact different
+European languages treat the ordering of accented characters
+differently. It is useful to use the natural order where available, of
+course. The number assigned to any particular character is called the
+character's "code point". (Within a given character set, each
+character has a unique code point. Thus the word "set" is ill-chosen;
+different orderings of the same characters are different character sets.
+Identifying characters is simple enough for alphabetic character sets,
+but the difference in ordering can cause great headaches when the same
+thousands of characters are used by different cultures as in the Hanzi.)
+
+ A code point may be broken into a number of "position codes". The
+number of position codes required to index a particular character in a
+character set is called the "dimension" of the character set. For
+practical purposes, a position code may be thought of as a byte-sized
+index. The printing characters of ASCII, being a relatively small
+character set, is of dimension one, and each character in the set is
+indexed using a single position code, in the range 1 through 94. Use of
+this unusual range, rather than the familiar 33 through 126, is an
+intentional abstraction; to understand the programming issues you must
+break the equation between character sets and encodings.
+
+ JIS X 0208, i.e. Japanese Kanji, has thousands of characters, and is
+of dimension two - every character is indexed by two position codes,
+each in the range 1 through 94. (This number "94" is not a
+coincidence; we shall see that the JIS position codes were chosen so
+that JIS kanji could be encoded without using codes that in ASCII are
+associated with device control functions.) Note that the choice of the
+range here is somewhat arbitrary. You could just as easily index the
+printing characters in ASCII using numbers in the range 0 through 93, 2
+through 95, 3 through 96, etc. In fact, the standardized _encoding_
+for the ASCII _character set_ uses the range 33 through 126.
+
+ An "encoding" is a way of numerically representing characters from
+one or more character sets into a stream of like-sized numerical values
+called "words"; typically these are 8-bit, 16-bit, or 32-bit
+quantities. If an encoding encompasses only one character set, then the
+position codes for the characters in that character set could be used
+directly. (This is the case with the trivial cipher used by children,
+assigning 1 to `A', 2 to `B', and so on.) However, even with ASCII,
+other considerations intrude. For example, why are the upper- and
+lowercase alphabets separated by 8 characters? Why do the digits start
+with `0' being assigned the code 48? In both cases because semantically
+interesting operations (case conversion and numerical value extraction)
+become convenient masking operations. Other artificial aspects (the
+control characters being assigned to codes 0-31 and 127) are historical
+accidents. (The use of 127 for `DEL' is an artifact of the "punch
+once" nature of paper tape, for example.)
+
+ Naive use of the position code is not possible, however, if more than
+one character set is to be used in the encoding. For example, printed
+Japanese text typically requires characters from multiple character sets
+- ASCII, JIS X 0208, and JIS X 0212, to be specific. Each of these is
+indexed using one or more position codes in the range 1 through 94, so
+the position codes could not be used directly or there would be no way
+to tell which character was meant. Different Japanese encodings handle
+this differently - JIS uses special escape characters to denote
+different character sets; EUC sets the high bit of the position codes
+for JIS X 0208 and JIS X 0212, and puts a special extra byte before each
+JIS X 0212 character; etc. (JIS, EUC, and most of the other encodings
+you will encounter in files are 7-bit or 8-bit encodings. There is one
+common 16-bit encoding, which is Unicode; this strives to represent all
+the world's characters in a single large character set. 32-bit
+encodings are often used internally in programs, such as XEmacs with
+MULE support, to simplify the code that manipulates them; however, they
+are not used externally because they are not very space-efficient.)
+
+ A general method of handling text using multiple character sets
+(whether for multilingual text, or simply text in an extremely
+complicated single language like Japanese) is defined in the
+international standard ISO 2022. ISO 2022 will be discussed in more
+detail later (*note ISO 2022::), but for now suffice it to say that text
+needs control functions (at least spacing), and if escape sequences are
+to be used, an escape sequence introducer. It was decided to make all
+text streams compatible with ASCII in the sense that the codes 0-31
+(and 128-159) would always be control codes, never graphic characters,
+and where defined by the character set the `SPC' character would be
+assigned code 32, and `DEL' would be assigned 127. Thus there are 94
+code points remaining if 7 bits are used. This is the reason that most
+character sets are defined using position codes in the range 1 through
+94. Then ISO 2022 compatible encodings are produced by shifting the
+position codes 1 to 94 into character codes 33 to 126, or (if 8 bit
+codes are available) into character codes 161 to 254.
+
+ Encodings are classified as either "modal" or "non-modal". In a
+"modal encoding", there are multiple states that the encoding can be
+in, and the interpretation of the values in the stream depends on the
+current global state of the encoding. Special values in the encoding,
+called "escape sequences", are used to change the global state. JIS,
+for example, is a modal encoding. The bytes `ESC $ B' indicate that,
+from then on, bytes are to be interpreted as position codes for JIS X
+0208, rather than as ASCII. This effect is cancelled using the bytes
+`ESC ( B', which mean "switch from whatever the current state is to
+ASCII". To switch to JIS X 0212, the escape sequence `ESC $ ( D'.
+(Note that here, as is common, the escape sequences do in fact begin
+with `ESC'. This is not necessarily the case, however. Some encodings
+use control characters called "locking shifts" (effect persists until
+cancelled) to switch character sets.)
+
+ A "non-modal encoding" has no global state that extends past the
+character currently being interpreted. EUC, for example, is a
+non-modal encoding. Characters in JIS X 0208 are encoded by setting
+the high bit of the position codes, and characters in JIS X 0212 are
+encoded by doing the same but also prefixing the character with the
+byte 0x8F.
+
+ The advantage of a modal encoding is that it is generally more
+space-efficient, and is easily extendible because there are essentially
+an arbitrary number of escape sequences that can be created. The
+disadvantage, however, is that it is much more difficult to work with
+if it is not being processed in a sequential manner. In the non-modal
+EUC encoding, for example, the byte 0x41 always refers to the letter
+`A'; whereas in JIS, it could either be the letter `A', or one of the
+two position codes in a JIS X 0208 character, or one of the two
+position codes in a JIS X 0212 character. Determining exactly which
+one is meant could be difficult and time-consuming if the previous
+bytes in the string have not already been processed, or impossible if
+they are drawn from an external stream that cannot be rewound.
+
+ Non-modal encodings are further divided into "fixed-width" and
+"variable-width" formats. A fixed-width encoding always uses the same
+number of words per character, whereas a variable-width encoding does
+not. EUC is a good example of a variable-width encoding: one to three
+bytes are used per character, depending on the character set. 16-bit
+and 32-bit encodings are nearly always fixed-width, and this is in fact
+one of the main reasons for using an encoding with a larger word size.
+The advantages of fixed-width encodings should be obvious. The
+advantages of variable-width encodings are that they are generally more
+space-efficient and allow for compatibility with existing 8-bit
+encodings such as ASCII. (For example, in Unicode ASCII characters are
+simply promoted to a 16-bit representation. That means that every
+ASCII character contains a `NUL' byte; evidently all of the standard
+string manipulation functions will lose badly in a fixed-width Unicode
+environment.)
+
+ The bytes in an 8-bit encoding are often referred to as "octets"
+rather than simply as bytes. This terminology dates back to the days
+before 8-bit bytes were universal, when some computers had 9-bit bytes,
+others had 10-bit bytes, etc.
+
+\1f
+File: lispref.info, Node: Charsets, Next: MULE Characters, Prev: Internationalization Terminology, Up: MULE
+
+Charsets
+========
+
+ A "charset" in MULE is an object that encapsulates a particular
+character set as well as an ordering of those characters. Charsets are
+permanent objects and are named using symbols, like faces.
+
+ - Function: charsetp object
+ This function returns non-`nil' if OBJECT is a charset.
* 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.
-* *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 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.
-* 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-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-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 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-dynamic: Dynamic Loading.
-* byte-compile-dynamic-docstrings: Docs and Compilation.
-* byte-compile-file: Compilation Functions.
-* byte-compiling macros: Compiling Macros.
-* byte-compiling require: Named Features.
-* byte-recompile-directory: Compilation Functions.
-* byte-recompile-directory-ignore-errors-p: 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-columns: Charset Property Functions.
-* charset-dimension: Charset Property Functions.
-* charset-direction: Charset Property Functions.
-* charset-doc-string: Charset Property Functions.
-* charset-final: Charset Property Functions.
-* charset-from-attributes: Basic Charset Functions.
-* charset-graphic: 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.
-* charsetp: Charsets.
-* check-argument-type: Signaling Errors.
-* 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-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: 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.
-* 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-size: Compiled-Function Objects.
-* 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.
-* 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-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-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-logical-name: Changing File Attributes.
-* 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.
-* deiconify-frame: Visibility of Frames.
-* 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-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.
-* 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-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.
-* 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-icon-title-format: Frame Titles.
-* frame-iconified-p: Visibility of Frames.
-* frame-list: Finding All Frames.
-* frame-live-p: Deleting Frames.
-* 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-root-window: Frames and Windows.
-* frame-selected-window: Frames and Windows.
-* frame-title-format: Frame Titles.
-* frame-top-window: Frames and Windows.
-* 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: Symbol 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.
-* 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-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-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-close: Opening and Closing a LDAP Connection.
-* ldap-default-base: LDAP Variables.
-* ldap-default-host: LDAP Variables.
-* ldap-default-port: LDAP Variables.
-* ldap-host: The LDAP Lisp Object.
-* ldap-host-parameters-alist: LDAP Variables.
-* ldap-live-p: The LDAP Lisp Object.
-* ldap-open: Opening and Closing a LDAP Connection.
-* ldap-search: The High-Level LDAP API.
-* ldap-search-internal: Searching on a LDAP Server (Low-level).
-* ldapp: The LDAP Lisp Object.
-* 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: Loading.
-* 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.
-* 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-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-composite-char: Composite Characters.
-* make-device: Connecting to a Console or Device.
-* make-directory: Create/Delete Dirs.
-* make-display-table: Display Table Format.
-* make-event: Working With Events.
-* make-extent: Creating and Modifying Extents.
-* make-face: Basic Face Functions.
-* make-file-part: Creating a Partial File.
-* make-font-instance: Font Instances.
-* make-frame: Creating Frames.
-* make-frame-invisible: Visibility of Frames.
-* make-frame-visible: Visibility of Frames.
-* make-glyph: Creating Glyphs.
-* make-glyph-internal: Creating Glyphs.
-* 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-keymap: Creating Keymaps.
-* make-list: Building Lists.
-* make-local-hook: Hooks.
-* make-local-variable: Creating Buffer-Local.
-* make-marker: Creating Markers.
-* 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-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.
-* 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.
-* memory-limit: 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.
-* 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.
-* 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.
-* 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.
-* 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-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: Symbol 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-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.
-* 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-glyph-property: Glyph Properties.
-* remove-hook: Hooks.
-* remove-range-table: Working With Range Tables.
-* remove-specifier: Other Specification Functions.
-* remove-text-properties: Changing Properties.
-* 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-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-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-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: Symbol Plists.
-* setprv: System Environment.
-* 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-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.
-* 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 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-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: Symbol 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-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-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.
-* trim-versions-without-asking: Numbered Backups.
-* 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.
-* 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.
+* Charset Properties:: Properties of a charset.
+* Basic Charset Functions:: Functions for working with charsets.
+* Charset Property Functions:: Functions for accessing charset properties.
+* Predefined Charsets:: Predefined charset objects.
+
+\1f
+File: lispref.info, Node: Charset Properties, Next: Basic Charset Functions, Up: Charsets
+
+Charset Properties
+------------------
+
+ Charsets have the following properties:
+
+`name'
+ A symbol naming the charset. Every charset must have a different
+ name; this allows a charset to be referred to using its name
+ rather than the actual charset object.
+
+`doc-string'
+ A documentation string describing the charset.
+
+`registry'
+ A regular expression matching the font registry field for this
+ character set. For example, both the `ascii' and `latin-iso8859-1'
+ charsets use the registry `"ISO8859-1"'. This field is used to
+ choose an appropriate font when the user gives a general font
+ specification such as `-*-courier-medium-r-*-140-*', i.e. a
+ 14-point upright medium-weight Courier font.
+
+`dimension'
+ Number of position codes used to index a character in the
+ character set. XEmacs/MULE can only handle character sets of
+ dimension 1 or 2. This property defaults to 1.
+
+`chars'
+ Number of characters in each dimension. In XEmacs/MULE, the only
+ allowed values are 94 or 96. (There are a couple of pre-defined
+ character sets, such as ASCII, that do not follow this, but you
+ cannot define new ones like this.) Defaults to 94. Note that if
+ the dimension is 2, the character set thus described is 94x94 or
+ 96x96.
+
+`columns'
+ Number of columns used to display a character in this charset.
+ Only used in TTY mode. (Under X, the actual width of a character
+ can be derived from the font used to display the characters.) If
+ unspecified, defaults to the dimension. (This is almost always the
+ correct value, because character sets with dimension 2 are usually
+ ideograph character sets, which need two columns to display the
+ intricate ideographs.)
+
+`direction'
+ A symbol, either `l2r' (left-to-right) or `r2l' (right-to-left).
+ Defaults to `l2r'. This specifies the direction that the text
+ should be displayed in, and will be left-to-right for most
+ charsets but right-to-left for Hebrew and Arabic. (Right-to-left
+ display is not currently implemented.)
+
+`final'
+ Final byte of the standard ISO 2022 escape sequence designating
+ this charset. Must be supplied. Each combination of (DIMENSION,
+ CHARS) defines a separate namespace for final bytes, and each
+ charset within a particular namespace must have a different final
+ byte. Note that ISO 2022 restricts the final byte to the range
+ 0x30 - 0x7E if dimension == 1, and 0x30 - 0x5F if dimension == 2.
+ Note also that final bytes in the range 0x30 - 0x3F are reserved
+ for user-defined (not official) character sets. For more
+ information on ISO 2022, see *Note Coding Systems::.
+
+`graphic'
+ 0 (use left half of font on output) or 1 (use right half of font on
+ output). Defaults to 0. This specifies how to convert the
+ position codes that index a character in a character set into an
+ index into the font used to display the character set. With
+ `graphic' set to 0, position codes 33 through 126 map to font
+ indices 33 through 126; with it set to 1, position codes 33
+ through 126 map to font indices 161 through 254 (i.e. the same
+ number but with the high bit set). For example, for a font whose
+ registry is ISO8859-1, the left half of the font (octets 0x20 -
+ 0x7F) is the `ascii' charset, while the right half (octets 0xA0 -
+ 0xFF) is the `latin-iso8859-1' charset.
+
+`ccl-program'
+ A compiled CCL program used to convert a character in this charset
+ into an index into the font. This is in addition to the `graphic'
+ property. If a CCL program is defined, the position codes of a
+ character will first be processed according to `graphic' and then
+ passed through the CCL program, with the resulting values used to
+ index the font.
+
+ This is used, for example, in the Big5 character set (used in
+ Taiwan). This character set is not ISO-2022-compliant, and its
+ size (94x157) does not fit within the maximum 96x96 size of
+ ISO-2022-compliant character sets. As a result, XEmacs/MULE
+ splits it (in a rather complex fashion, so as to group the most
+ commonly used characters together) into two charset objects
+ (`big5-1' and `big5-2'), each of size 94x94, and each charset
+ object uses a CCL program to convert the modified position codes
+ back into standard Big5 indices to retrieve a character from a
+ Big5 font.
+
+ Most of the above properties can only be set when the charset is
+initialized, and cannot be changed later. *Note Charset Property
+Functions::.
+
+\1f
+File: lispref.info, Node: Basic Charset Functions, Next: Charset Property Functions, Prev: Charset Properties, Up: Charsets
+
+Basic Charset Functions
+-----------------------
+
+ - Function: find-charset charset-or-name
+ This function retrieves the charset of the given name. If
+ CHARSET-OR-NAME is a charset object, it is simply returned.
+ Otherwise, CHARSET-OR-NAME should be a symbol. If there is no
+ such charset, `nil' is returned. Otherwise the associated charset
+ object is returned.
+
+ - Function: get-charset name
+ This function retrieves the charset of the given name. Same as
+ `find-charset' except an error is signalled if there is no such
+ charset instead of returning `nil'.
+
+ - Function: charset-list
+ This function returns a list of the names of all defined charsets.
+
+ - Function: make-charset name doc-string props
+ This function defines a new character set. This function is for
+ use with MULE support. NAME is a symbol, the name by which the
+ character set is normally referred. DOC-STRING is a string
+ describing the character set. PROPS is a property list,
+ describing the specific nature of the character set. The
+ recognized properties are `registry', `dimension', `columns',
+ `chars', `final', `graphic', `direction', and `ccl-program', as
+ previously described.
+
+ - Function: make-reverse-direction-charset charset new-name
+ This function makes a charset equivalent to CHARSET but which goes
+ in the opposite direction. NEW-NAME is the name of the new
+ charset. The new charset is returned.
+
+ - Function: charset-from-attributes dimension chars final &optional
+ direction
+ This function returns a charset with the given DIMENSION, CHARS,
+ FINAL, and DIRECTION. If DIRECTION is omitted, both directions
+ will be checked (left-to-right will be returned if character sets
+ exist for both directions).
+
+ - Function: charset-reverse-direction-charset charset
+ This function returns the charset (if any) with the same dimension,
+ number of characters, and final byte as CHARSET, but which is
+ displayed in the opposite direction.
+
+\1f
+File: lispref.info, Node: Charset Property Functions, Next: Predefined Charsets, Prev: Basic Charset Functions, Up: Charsets
+
+Charset Property Functions
+--------------------------
+
+ All of these functions accept either a charset name or charset
+object.
+
+ - Function: charset-property charset prop
+ This function returns property PROP of CHARSET. *Note Charset
+ Properties::.
+
+ Convenience functions are also provided for retrieving individual
+properties of a charset.
+
+ - Function: charset-name charset
+ This function returns the name of CHARSET. This will be a symbol.
+
+ - Function: charset-description charset
+ This function returns the documentation string of CHARSET.
+
+ - Function: charset-registry charset
+ This function returns the registry of CHARSET.
+
+ - Function: charset-dimension charset
+ This function returns the dimension of CHARSET.
+
+ - Function: charset-chars charset
+ This function returns the number of characters per dimension of
+ CHARSET.
+
+ - Function: charset-width charset
+ This function returns the number of display columns per character
+ (in TTY mode) of CHARSET.
+
+ - Function: charset-direction charset
+ This function returns the display direction of CHARSET--either
+ `l2r' or `r2l'.
+
+ - Function: charset-iso-final-char charset
+ This function returns the final byte of the ISO 2022 escape
+ sequence designating CHARSET.
+
+ - Function: charset-iso-graphic-plane charset
+ This function returns either 0 or 1, depending on whether the
+ position codes of characters in CHARSET map to the left or right
+ half of their font, respectively.
+
+ - Function: charset-ccl-program charset
+ This function returns the CCL program, if any, for converting
+ position codes of characters in CHARSET into font indices.
+
+ The only property of a charset that can currently be set after the
+charset has been created is the CCL program.
+
+ - Function: set-charset-ccl-program charset ccl-program
+ This function sets the `ccl-program' property of CHARSET to
+ CCL-PROGRAM.
+
+\1f
+File: lispref.info, Node: Predefined Charsets, Prev: Charset Property Functions, Up: Charsets
+
+Predefined Charsets
+-------------------
+
+ The following charsets are predefined in the C code.
+
+ Name Type Fi Gr Dir Registry
+ --------------------------------------------------------------
+ ascii 94 B 0 l2r ISO8859-1
+ control-1 94 0 l2r ---
+ latin-iso8859-1 94 A 1 l2r ISO8859-1
+ latin-iso8859-2 96 B 1 l2r ISO8859-2
+ latin-iso8859-3 96 C 1 l2r ISO8859-3
+ latin-iso8859-4 96 D 1 l2r ISO8859-4
+ cyrillic-iso8859-5 96 L 1 l2r ISO8859-5
+ arabic-iso8859-6 96 G 1 r2l ISO8859-6
+ greek-iso8859-7 96 F 1 l2r ISO8859-7
+ hebrew-iso8859-8 96 H 1 r2l ISO8859-8
+ latin-iso8859-9 96 M 1 l2r ISO8859-9
+ thai-tis620 96 T 1 l2r TIS620
+ katakana-jisx0201 94 I 1 l2r JISX0201.1976
+ latin-jisx0201 94 J 0 l2r JISX0201.1976
+ japanese-jisx0208-1978 94x94 @ 0 l2r JISX0208.1978
+ japanese-jisx0208 94x94 B 0 l2r JISX0208.19(83|90)
+ japanese-jisx0212 94x94 D 0 l2r JISX0212
+ chinese-gb2312 94x94 A 0 l2r GB2312
+ chinese-cns11643-1 94x94 G 0 l2r CNS11643.1
+ chinese-cns11643-2 94x94 H 0 l2r CNS11643.2
+ chinese-big5-1 94x94 0 0 l2r Big5
+ chinese-big5-2 94x94 1 0 l2r Big5
+ korean-ksc5601 94x94 C 0 l2r KSC5601
+ composite 96x96 0 l2r ---
+
+ The following charsets are predefined in the Lisp code.
+
+ Name Type Fi Gr Dir Registry
+ --------------------------------------------------------------
+ arabic-digit 94 2 0 l2r MuleArabic-0
+ arabic-1-column 94 3 0 r2l MuleArabic-1
+ arabic-2-column 94 4 0 r2l MuleArabic-2
+ sisheng 94 0 0 l2r sisheng_cwnn\|OMRON_UDC_ZH
+ chinese-cns11643-3 94x94 I 0 l2r CNS11643.1
+ chinese-cns11643-4 94x94 J 0 l2r CNS11643.1
+ chinese-cns11643-5 94x94 K 0 l2r CNS11643.1
+ chinese-cns11643-6 94x94 L 0 l2r CNS11643.1
+ chinese-cns11643-7 94x94 M 0 l2r CNS11643.1
+ ethiopic 94x94 2 0 l2r Ethio
+ ascii-r2l 94 B 0 r2l ISO8859-1
+ ipa 96 0 1 l2r MuleIPA
+ vietnamese-lower 96 1 1 l2r VISCII1.1
+ vietnamese-upper 96 2 1 l2r VISCII1.1
+
+ For all of the above charsets, the dimension and number of columns
+are the same.
+
+ Note that ASCII, Control-1, and Composite are handled specially.
+This is why some of the fields are blank; and some of the filled-in
+fields (e.g. the type) are not really accurate.
+
+\1f
+File: lispref.info, Node: MULE Characters, Next: Composite Characters, Prev: Charsets, Up: MULE
+
+MULE Characters
+===============
+
+ - Function: make-char charset arg1 &optional arg2
+ This function makes a multi-byte character from CHARSET and octets
+ ARG1 and ARG2.
+
+ - Function: char-charset character
+ This function returns the character set of char CHARACTER.
+
+ - Function: char-octet character &optional n
+ This function returns the octet (i.e. position code) numbered N
+ (should be 0 or 1) of char CHARACTER. N defaults to 0 if omitted.
+
+ - Function: find-charset-region start end &optional buffer
+ This function returns a list of the charsets in the region between
+ START and END. BUFFER defaults to the current buffer if omitted.
+
+ - Function: find-charset-string string
+ This function returns a list of the charsets in STRING.
+
+\1f
+File: lispref.info, Node: Composite Characters, Next: Coding Systems, Prev: MULE Characters, Up: MULE
+
+Composite Characters
+====================
+
+ Composite characters are not yet completely implemented.
+
+ - Function: make-composite-char string
+ This function converts a string into a single composite character.
+ The character is the result of overstriking all the characters in
+ the string.
+
+ - Function: composite-char-string character
+ This function returns a string of the characters comprising a
+ composite character.
+
+ - Function: compose-region start end &optional buffer
+ This function composes the characters in the region from START to
+ END in BUFFER into one composite character. The composite
+ character replaces the composed characters. BUFFER defaults to
+ the current buffer if omitted.
+
+ - Function: decompose-region start end &optional buffer
+ This function decomposes any composite characters in the region
+ from START to END in BUFFER. This converts each composite
+ character into one or more characters, the individual characters
+ out of which the composite character was formed. Non-composite
+ characters are left as-is. BUFFER defaults to the current buffer
+ if omitted.
+
+\1f
+File: lispref.info, Node: Coding Systems, Next: CCL, Prev: Composite Characters, Up: MULE
+
+Coding Systems
+==============
+
+ A coding system is an object that defines how text containing
+multiple character sets is encoded into a stream of (typically 8-bit)
+bytes. The coding system is used to decode the stream into a series of
+characters (which may be from multiple charsets) when the text is read
+from a file or process, and is used to encode the text back into the
+same format when it is written out to a file or process.
+
+ For example, many ISO-2022-compliant coding systems (such as Compound
+Text, which is used for inter-client data under the X Window System) use
+escape sequences to switch between different charsets - Japanese Kanji,
+for example, is invoked with `ESC $ ( B'; ASCII is invoked with `ESC (
+B'; and Cyrillic is invoked with `ESC - L'. See `make-coding-system'
+for more information.
+
+ Coding systems are normally identified using a symbol, and the
+symbol is accepted in place of the actual coding system object whenever
+a coding system is called for. (This is similar to how faces and
+charsets work.)
+
+ - Function: coding-system-p object
+ This function returns non-`nil' if OBJECT is a coding system.
+
+* Menu:
+
+* Coding System Types:: Classifying coding systems.
+* ISO 2022:: An international standard for
+ charsets and encodings.
+* EOL Conversion:: Dealing with different ways of denoting
+ the end of a line.
+* Coding System Properties:: Properties of a coding system.
+* Basic Coding System Functions:: Working with coding systems.
+* Coding System Property Functions:: Retrieving a coding system's properties.
+* Encoding and Decoding Text:: Encoding and decoding text.
+* Detection of Textual Encoding:: Determining how text is encoded.
+* Big5 and Shift-JIS Functions:: Special functions for these non-standard
+ encodings.
+* Predefined Coding Systems:: Coding systems implemented by MULE.
+
+\1f
+File: lispref.info, Node: Coding System Types, Next: ISO 2022, Up: Coding Systems
+
+Coding System Types
+-------------------
+
+ The coding system type determines the basic algorithm XEmacs will
+use to decode or encode a data stream. Character encodings will be
+converted to the MULE encoding, escape sequences processed, and newline
+sequences converted to XEmacs's internal representation. There are
+three basic classes of coding system type: no-conversion, ISO-2022, and
+special.
+
+ No conversion allows you to look at the file's internal
+representation. Since XEmacs is basically a text editor, "no
+conversion" does convert newline conventions by default. (Use the
+'binary coding-system if this is not desired.)
+
+ ISO 2022 (*note ISO 2022::) is the basic international standard
+regulating use of "coded character sets for the exchange of data", ie,
+text streams. ISO 2022 contains functions that make it possible to
+encode text streams to comply with restrictions of the Internet mail
+system and de facto restrictions of most file systems (eg, use of the
+separator character in file names). Coding systems which are not ISO
+2022 conformant can be difficult to handle. Perhaps more important,
+they are not adaptable to multilingual information interchange, with
+the obvious exception of ISO 10646 (Unicode). (Unicode is partially
+supported by XEmacs with the addition of the Lisp package ucs-conv.)
+
+ The special class of coding systems includes automatic detection,
+CCL (a "little language" embedded as an interpreter, useful for
+translating between variants of a single character set),
+non-ISO-2022-conformant encodings like Unicode, Shift JIS, and Big5,
+and MULE internal coding. (NB: this list is based on XEmacs 21.2.
+Terminology may vary slightly for other versions of XEmacs and for GNU
+Emacs 20.)
+
+`no-conversion'
+ No conversion, for binary files, and a few special cases of
+ non-ISO-2022 coding systems where conversion is done by hook
+ functions (usually implemented in CCL). On output, graphic
+ characters that are not in ASCII or Latin-1 will be replaced by a
+ `?'. (For a no-conversion-encoded buffer, these characters will
+ only be present if you explicitly insert them.)
+
+`iso2022'
+ Any ISO-2022-compliant encoding. Among others, this includes JIS
+ (the Japanese encoding commonly used for e-mail), national
+ variants of EUC (the standard Unix encoding for Japanese and other
+ languages), and Compound Text (an encoding used in X11). You can
+ specify more specific information about the conversion with the
+ FLAGS argument.
+
+`ucs-4'
+ ISO 10646 UCS-4 encoding. A 31-bit fixed-width superset of
+ Unicode.
+
+`utf-8'
+ ISO 10646 UTF-8 encoding. A "file system safe" transformation
+ format that can be used with both UCS-4 and Unicode.
+
+`undecided'
+ Automatic conversion. XEmacs attempts to detect the coding system
+ used in the file.
+
+`shift-jis'
+ Shift-JIS (a Japanese encoding commonly used in PC operating
+ systems).
+
+`big5'
+ Big5 (the encoding commonly used for Taiwanese).
+
+`ccl'
+ The conversion is performed using a user-written pseudo-code
+ program. CCL (Code Conversion Language) is the name of this
+ pseudo-code. For example, CCL is used to map KOI8-R characters
+ (an encoding for Russian Cyrillic) to ISO8859-5 (the form used
+ internally by MULE).
+
+`internal'
+ Write out or read in the raw contents of the memory representing
+ the buffer's text. This is primarily useful for debugging
+ purposes, and is only enabled when XEmacs has been compiled with
+ `DEBUG_XEMACS' set (the `--debug' configure option). *Warning*:
+ Reading in a file using `internal' conversion can result in an
+ internal inconsistency in the memory representing a buffer's text,
+ which will produce unpredictable results and may cause XEmacs to
+ crash. Under normal circumstances you should never use `internal'
+ conversion.
+
+\1f
+File: lispref.info, Node: ISO 2022, Next: EOL Conversion, Prev: Coding System Types, Up: Coding Systems
+
+ISO 2022
+========
+
+ This section briefly describes the ISO 2022 encoding standard. A
+more thorough treatment is available in the original document of ISO
+2022 as well as various national standards (such as JIS X 0202).
+
+ Character sets ("charsets") are classified into the following four
+categories, according to the number of characters in the charset:
+94-charset, 96-charset, 94x94-charset, and 96x96-charset. This means
+that although an ISO 2022 coding system may have variable width
+characters, each charset used is fixed-width (in contrast to the MULE
+character set and UTF-8, for example).
+
+ ISO 2022 provides for switching between character sets via escape
+sequences. This switching is somewhat complicated, because ISO 2022
+provides for both legacy applications like Internet mail that accept
+only 7 significant bits in some contexts (RFC 822 headers, for example),
+and more modern "8-bit clean" applications. It also provides for
+compact and transparent representation of languages like Japanese which
+mix ASCII and a national script (even outside of computer programs).
+
+ First, ISO 2022 codified prevailing practice by dividing the code
+space into "control" and "graphic" regions. The code points 0x00-0x1F
+and 0x80-0x9F are reserved for "control characters", while "graphic
+characters" must be assigned to code points in the regions 0x20-0x7F and
+0xA0-0xFF. The positions 0x20 and 0x7F are special, and under some
+circumstances must be assigned the graphic character "ASCII SPACE" and
+the control character "ASCII DEL" respectively.
+
+ The various regions are given the name C0 (0x00-0x1F), GL
+(0x20-0x7F), C1 (0x80-0x9F), and GR (0xA0-0xFF). GL and GR stand for
+"graphic left" and "graphic right", respectively, because of the
+standard method of displaying graphic character sets in tables with the
+high byte indexing columns and the low byte indexing rows. I don't
+find it very intuitive, but these are called "registers".
+
+ An ISO 2022-conformant encoding for a graphic character set must use
+a fixed number of bytes per character, and the values must fit into a
+single register; that is, each byte must range over either 0x20-0x7F, or
+0xA0-0xFF. It is not allowed to extend the range of the repertoire of a
+character set by using both ranges at the same. This is why a standard
+character set such as ISO 8859-1 is actually considered by ISO 2022 to
+be an aggregation of two character sets, ASCII and LATIN-1, and why it
+is technically incorrect to refer to ISO 8859-1 as "Latin 1". Also, a
+single character's bytes must all be drawn from the same register; this
+is why Shift JIS (for Japanese) and Big 5 (for Chinese) are not ISO
+2022-compatible encodings.
+
+ The reason for this restriction becomes clear when you attempt to
+define an efficient, robust encoding for a language like Japanese.
+Like ISO 8859, Japanese encodings are aggregations of several character
+sets. In practice, the vast majority of characters are drawn from the
+"JIS Roman" character set (a derivative of ASCII; it won't hurt to
+think of it as ASCII) and the JIS X 0208 standard "basic Japanese"
+character set including not only ideographic characters ("kanji") but
+syllabic Japanese characters ("kana"), a wide variety of symbols, and
+many alphabetic characters (Roman, Greek, and Cyrillic) as well.
+Although JIS X 0208 includes the whole Roman alphabet, as a 2-byte code
+it is not suited to programming; thus the inclusion of ASCII in the
+standard Japanese encodings.
+
+ For normal Japanese text such as in newspapers, a broad repertoire of
+approximately 3000 characters is used. Evidently this won't fit into
+one byte; two must be used. But much of the text processed by Japanese
+computers is computer source code, nearly all of which is ASCII. A not
+insignificant portion of ordinary text is English (as such or as
+borrowed Japanese vocabulary) or other languages which can represented
+at least approximately in ASCII, as well. It seems reasonable then to
+represent ASCII in one byte, and JIS X 0208 in two. And this is exactly
+what the Extended Unix Code for Japanese (EUC-JP) does. ASCII is
+invoked to the GL register, and JIS X 0208 is invoked to the GR
+register. Thus, each byte can be tested for its character set by
+looking at the high bit; if set, it is Japanese, if clear, it is ASCII.
+Furthermore, since control characters like newline can never be part of
+a graphic character, even in the case of corruption in transmission the
+stream will be resynchronized at every line break, on the order of 60-80
+bytes. This coding system requires no escape sequences or special
+control codes to represent 99.9% of all Japanese text.
+
+ Note carefully the distinction between the character sets (ASCII and
+JIS X 0208), the encoding (EUC-JP), and the coding system (ISO 2022).
+The JIS X 0208 character set is used in three different encodings for
+Japanese, but in ISO-2022-JP it is invoked into GL (so the high bit is
+always clear), in EUC-JP it is invoked into GR (setting the high bit in
+the process), and in Shift JIS the high bit may be set or reset, and the
+significant bits are shifted within the 16-bit character so that the two
+main character sets can coexist with a third (the "halfwidth katakana"
+of JIS X 0201). As the name implies, the ISO-2022-JP encoding is also a
+version of the ISO-2022 coding system.
+
+ In order to systematically treat subsidiary character sets (like the
+"halfwidth katakana" already mentioned, and the "supplementary kanji" of
+JIS X 0212), four further registers are defined: G0, G1, G2, and G3.
+Unlike GL and GR, they are not logically distinguished by internal
+format. Instead, the process of "invocation" mentioned earlier is
+broken into two steps: first, a character set is "designated" to one of
+the registers G0-G3 by use of an "escape sequence" of the form:
+
+ ESC [I] I F
+
+ where I is an intermediate character or characters in the range 0x20
+- 0x3F, and F, from the range 0x30-0x7Fm is the final character
+identifying this charset. (Final characters in the range 0x30-0x3F are
+reserved for private use and will never have a publicly registered
+meaning.)
+
+ Then that register is "invoked" to either GL or GR, either
+automatically (designations to G0 normally involve invocation to GL as
+well), or by use of shifting (affecting only the following character in
+the data stream) or locking (effective until the next designation or
+locking) control sequences. An encoding conformant to ISO 2022 is
+typically defined by designating the initial contents of the G0-G3
+registers, specifying an 7 or 8 bit environment, and specifying whether
+further designations will be recognized.
+
+ Some examples of character sets and the registered final characters
+F used to designate them:
+
+94-charset
+ ASCII (B), left (J) and right (I) half of JIS X 0201, ...
+
+96-charset
+ Latin-1 (A), Latin-2 (B), Latin-3 (C), ...
+
+94x94-charset
+ GB2312 (A), JIS X 0208 (B), KSC5601 (C), ...
+
+96x96-charset
+ none for the moment
+
+ The meanings of the various characters in these sequences, where not
+specified by the ISO 2022 standard (such as the ESC character), are
+assigned by "ECMA", the European Computer Manufacturers Association.
+
+ The meaning of intermediate characters are:
+
+ $ [0x24]: indicate charset of dimension 2 (94x94 or 96x96).
+ ( [0x28]: designate to G0 a 94-charset whose final byte is F.
+ ) [0x29]: designate to G1 a 94-charset whose final byte is F.
+ * [0x2A]: designate to G2 a 94-charset whose final byte is F.
+ + [0x2B]: designate to G3 a 94-charset whose final byte is F.
+ , [0x2C]: designate to G0 a 96-charset whose final byte is F.
+ - [0x2D]: designate to G1 a 96-charset whose final byte is F.
+ . [0x2E]: designate to G2 a 96-charset whose final byte is F.
+ / [0x2F]: designate to G3 a 96-charset whose final byte is F.
+
+ The comma may be used in files read and written only by MULE, as a
+MULE extension, but this is illegal in ISO 2022. (The reason is that
+in ISO 2022 G0 must be a 94-member character set, with 0x20 assigned
+the value SPACE, and 0x7F assigned the value DEL.)
+
+ Here are examples of designations:
+
+ ESC ( B : designate to G0 ASCII
+ ESC - A : designate to G1 Latin-1
+ ESC $ ( A or ESC $ A : designate to G0 GB2312
+ ESC $ ( B or ESC $ B : designate to G0 JISX0208
+ ESC $ ) C : designate to G1 KSC5601
+
+ (The short forms used to designate GB2312 and JIS X 0208 are for
+backwards compatibility; the long forms are preferred.)
+
+ To use a charset designated to G2 or G3, and to use a charset
+designated to G1 in a 7-bit environment, you must explicitly invoke G1,
+G2, or G3 into GL. There are two types of invocation, Locking Shift
+(forever) and Single Shift (one character only).
+
+ Locking Shift is done as follows:
+
+ LS0 or SI (0x0F): invoke G0 into GL
+ LS1 or SO (0x0E): invoke G1 into GL
+ LS2: invoke G2 into GL
+ LS3: invoke G3 into GL
+ LS1R: invoke G1 into GR
+ LS2R: invoke G2 into GR
+ LS3R: invoke G3 into GR
+
+ Single Shift is done as follows:
+
+ SS2 or ESC N: invoke G2 into GL
+ SS3 or ESC O: invoke G3 into GL
+
+ The shift functions (such as LS1R and SS3) are represented by control
+characters (from C1) in 8 bit environments and by escape sequences in 7
+bit environments.
+
+ (#### Ben says: I think the above is slightly incorrect. It appears
+that SS2 invokes G2 into GR and SS3 invokes G3 into GR, whereas ESC N
+and ESC O behave as indicated. The above definitions will not parse
+EUC-encoded text correctly, and it looks like the code in mule-coding.c
+has similar problems.)
+
+ Evidently there are a lot of ISO-2022-compliant ways of encoding
+multilingual text. Now, in the world, there exist many coding systems
+such as X11's Compound Text, Japanese JUNET code, and so-called EUC
+(Extended UNIX Code); all of these are variants of ISO 2022.
+
+ In MULE, we characterize a version of ISO 2022 by the following
+attributes:
+
+ 1. The character sets initially designated to G0 thru G3.
+
+ 2. Whether short form designations are allowed for Japanese and
+ Chinese.
+
+ 3. Whether ASCII should be designated to G0 before control characters.
+
+ 4. Whether ASCII should be designated to G0 at the end of line.
+
+ 5. 7-bit environment or 8-bit environment.
+
+ 6. Whether Locking Shifts are used or not.
+
+ 7. Whether to use ASCII or the variant JIS X 0201-1976-Roman.
+
+ 8. Whether to use JIS X 0208-1983 or the older version JIS X
+ 0208-1976.
+
+ (The last two are only for Japanese.)
+
+ By specifying these attributes, you can create any variant of ISO
+2022.
+
+ Here are several examples:
+
+ ISO-2022-JP -- Coding system used in Japanese email (RFC 1463 #### check).
+ 1. G0 <- ASCII, G1..3 <- never used
+ 2. Yes.
+ 3. Yes.
+ 4. Yes.
+ 5. 7-bit environment
+ 6. No.
+ 7. Use ASCII
+ 8. Use JIS X 0208-1983
+
+ ctext -- X11 Compound Text
+ 1. G0 <- ASCII, G1 <- Latin-1, G2,3 <- never used.
+ 2. No.
+ 3. No.
+ 4. Yes.
+ 5. 8-bit environment.
+ 6. No.
+ 7. Use ASCII.
+ 8. Use JIS X 0208-1983.
+
+ euc-china -- Chinese EUC. Often called the "GB encoding", but that is
+ technically incorrect.
+ 1. G0 <- ASCII, G1 <- GB 2312, G2,3 <- never used.
+ 2. No.
+ 3. Yes.
+ 4. Yes.
+ 5. 8-bit environment.
+ 6. No.
+ 7. Use ASCII.
+ 8. Use JIS X 0208-1983.
+
+ ISO-2022-KR -- Coding system used in Korean email.
+ 1. G0 <- ASCII, G1 <- KSC 5601, G2,3 <- never used.
+ 2. No.
+ 3. Yes.
+ 4. Yes.
+ 5. 7-bit environment.
+ 6. Yes.
+ 7. Use ASCII.
+ 8. Use JIS X 0208-1983.
+
+ MULE creates all of these coding systems by default.
+
+\1f
+File: lispref.info, Node: EOL Conversion, Next: Coding System Properties, Prev: ISO 2022, Up: Coding Systems
+
+EOL Conversion
+--------------
+
+`nil'
+ Automatically detect the end-of-line type (LF, CRLF, or CR). Also
+ generate subsidiary coding systems named `NAME-unix', `NAME-dos',
+ and `NAME-mac', that are identical to this coding system but have
+ an EOL-TYPE value of `lf', `crlf', and `cr', respectively.
+
+`lf'
+ The end of a line is marked externally using ASCII LF. Since this
+ is also the way that XEmacs represents an end-of-line internally,
+ specifying this option results in no end-of-line conversion. This
+ is the standard format for Unix text files.
+
+`crlf'
+ The end of a line is marked externally using ASCII CRLF. This is
+ the standard format for MS-DOS text files.
+
+`cr'
+ The end of a line is marked externally using ASCII CR. This is the
+ standard format for Macintosh text files.
+`t'
+ Automatically detect the end-of-line type but do not generate
+ subsidiary coding systems. (This value is converted to `nil' when
+ stored internally, and `coding-system-property' will return `nil'.)