This is ../../info/elisp, produced by makeinfo version 4.11 from elisp.texi. This is edition 3.0 of the GNU Emacs Lisp Reference Manual, corresponding to Emacs version 23.2. Copyright (C) 1990, 1991, 1992, 1993, 1994, 1995, 1996, 1998, 1999, 2000, 2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008, 2009, 2010 Free Software Foundation, Inc. Permission is granted to copy, distribute and/or modify this document under the terms of the GNU Free Documentation License, Version 1.3 or any later version published by the Free Software Foundation; with the Invariant Sections being "GNU General Public License," with the Front-Cover texts being "A GNU Manual," and with the Back-Cover Texts as in (a) below. A copy of the license is included in the section entitled "GNU Free Documentation License." (a) The FSF's Back-Cover Text is: "You have the freedom to copy and modify this GNU manual. Buying copies from the FSF supports it in developing GNU and promoting software freedom." INFO-DIR-SECTION Emacs START-INFO-DIR-ENTRY * Elisp: (elisp). The Emacs Lisp Reference Manual. END-INFO-DIR-ENTRY  File: elisp, Node: Index, Prev: Standard Hooks, Up: Top Index ***** [index] * Menu: * " in printing: Output Functions. (line 9) * " in strings: Syntax for Strings. (line 6) * #$: Docs and Compilation. (line 48) * #' syntax: Anonymous Functions. (line 81) * #( read syntax: Text Props and Strings. (line 6) * #@COUNT: Docs and Compilation. (line 48) * #COLON read syntax: Symbol Type. (line 59) * #N# read syntax: Circular Objects. (line 6) * #N= read syntax: Circular Objects. (line 6) * $ in display: Truncation. (line 6) * $ in regexp: Regexp Special. (line 160) * %: Arithmetic Operations. (line 114) * % in format: Formatting Strings. (line 26) * & in replacement: Replacing Match. (line 43) * &optional: Argument List. (line 18) * &rest: Argument List. (line 18) * ' for quoting: Quoting. (line 15) * ( in regexp: Regexp Backslash. (line 45) * (...) in lists: Cons Cell Type. (line 25) * (?: in regexp: Regexp Backslash. (line 67) * ) in regexp: Regexp Backslash. (line 45) * *: Arithmetic Operations. (line 69) * * in interactive: Using Interactive. (line 67) * * in regexp: Regexp Special. (line 16) * *scratch*: Auto Major Mode. (line 92) * +: Arithmetic Operations. (line 44) * + in regexp: Regexp Special. (line 48) * , (with backquote): Backquote. (line 20) * ,@ (with backquote): Backquote. (line 39) * -: Arithmetic Operations. (line 55) * . in lists: Dotted Pair Notation. (line 6) * . in regexp: Regexp Special. (line 10) * .emacs: Init File. (line 6) * /: Arithmetic Operations. (line 80) * /=: Comparison of Numbers. (line 57) * /dev/tty: Serial Ports. (line 6) * 1+: Arithmetic Operations. (line 20) * 1-: Arithmetic Operations. (line 41) * 1value: Test Coverage. (line 26) * 2C-mode-map: Prefix Keys. (line 38) * ; in comment: Comments. (line 6) * <: Comparison of Numbers. (line 61) * <=: Comparison of Numbers. (line 65) * : Functions for Key Lookup. (line 84) * in minibuffer: Text from Minibuffer. (line 196) * in minibuffer: Text from Minibuffer. (line 199) * =: Comparison of Numbers. (line 47) * >: Comparison of Numbers. (line 70) * >=: Comparison of Numbers. (line 74) * ? in character constant: Basic Char Syntax. (line 6) * ? in minibuffer: Text from Minibuffer. (line 202) * ? in regexp: Regexp Special. (line 54) * @ in interactive: Using Interactive. (line 70) * [ in regexp: Regexp Special. (line 72) * [...] (Edebug): Specification List. (line 126) * \ in character constant: General Escape Syntax. (line 23) * \ in display: Truncation. (line 6) * \ in printing: Output Functions. (line 9) * \ in regexp: Regexp Special. (line 171) * \ in replacement: Replacing Match. (line 52) * \ in strings: Syntax for Strings. (line 6) * \ in symbols: Symbol Type. (line 23) * \' in regexp: Regexp Backslash. (line 159) * \< in regexp: Regexp Backslash. (line 180) * \= in regexp: Regexp Backslash. (line 163) * \> in regexp: Regexp Backslash. (line 185) * \_< in regexp: Regexp Backslash. (line 190) * \_> in regexp: Regexp Backslash. (line 196) * \` in regexp: Regexp Backslash. (line 155) * \a: Basic Char Syntax. (line 27) * \b: Basic Char Syntax. (line 27) * \B in regexp: Regexp Backslash. (line 176) * \b in regexp: Regexp Backslash. (line 167) * \e: Basic Char Syntax. (line 27) * \f: Basic Char Syntax. (line 27) * \n: Basic Char Syntax. (line 27) * \n in print: Output Variables. (line 18) * \N in replacement: Replacing Match. (line 46) * \r: Basic Char Syntax. (line 27) * \s: Basic Char Syntax. (line 27) * \S in regexp: Regexp Backslash. (line 138) * \s in regexp: Regexp Backslash. (line 130) * \t: Basic Char Syntax. (line 27) * \v: Basic Char Syntax. (line 27) * \W in regexp: Regexp Backslash. (line 127) * \w in regexp: Regexp Backslash. (line 123) * ] in regexp: Regexp Special. (line 72) * ^ in interactive: Using Interactive. (line 75) * ^ in regexp: Regexp Special. (line 133) * `: Backquote. (line 6) * ` (list substitution): Backquote. (line 6) * abbrev: Abbrevs. (line 6) * abbrev tables in modes: Major Mode Conventions. (line 119) * abbrev-all-caps: Abbrev Expansion. (line 56) * abbrev-expand-functions: Abbrev Expansion. (line 94) * abbrev-expansion: Abbrev Expansion. (line 20) * abbrev-file-name: Abbrev Files. (line 16) * abbrev-get: Abbrev Properties. (line 14) * abbrev-insert: Abbrev Expansion. (line 37) * abbrev-minor-mode-table-alist: Standard Abbrev Tables. (line 21) * abbrev-mode: Abbrev Mode. (line 9) * abbrev-prefix-mark: Abbrev Expansion. (line 45) * abbrev-put: Abbrev Properties. (line 11) * abbrev-start-location: Abbrev Expansion. (line 62) * abbrev-start-location-buffer: Abbrev Expansion. (line 70) * abbrev-symbol: Abbrev Expansion. (line 12) * abbrev-table-get: Abbrev Table Properties. (line 14) * abbrev-table-name-list: Abbrev Tables. (line 48) * abbrev-table-p: Abbrev Tables. (line 15) * abbrev-table-put: Abbrev Table Properties. (line 11) * abbreviate-file-name: Directory Names. (line 96) * abbrevs-changed: Abbrev Files. (line 33) * abnormal hook: Hooks. (line 34) * abort-recursive-edit: Recursive Editing. (line 93) * aborting: Recursive Editing. (line 32) * abs: Comparison of Numbers. (line 99) * absolute file name: Relative File Names. (line 6) * accept input from processes: Accepting Output. (line 6) * accept-change-group: Atomic Changes. (line 49) * accept-process-output: Accepting Output. (line 14) * access-file: Testing Accessibility. (line 81) * accessibility of a file: Testing Accessibility. (line 6) * accessible portion (of a buffer): Narrowing. (line 6) * accessible-keymaps: Scanning Keymaps. (line 10) * acos: Math Functions. (line 21) * action (button property): Button Properties. (line 12) * action, customization keyword: Type Keywords. (line 61) * activate-change-group: Atomic Changes. (line 40) * activate-mark-hook: The Mark. (line 179) * activating advice: Activation of Advice. (line 6) * active display table: Active Display Table. (line 6) * active keymap: Active Keymaps. (line 6) * active-minibuffer-window: Minibuffer Windows. (line 10) * ad-activate: Activation of Advice. (line 35) * ad-activate-all: Activation of Advice. (line 49) * ad-activate-regexp: Activation of Advice. (line 60) * ad-add-advice: Computed Advice. (line 12) * ad-deactivate: Activation of Advice. (line 42) * ad-deactivate-all: Activation of Advice. (line 52) * ad-deactivate-regexp: Activation of Advice. (line 65) * ad-default-compilation-action: Activation of Advice. (line 88) * ad-define-subr-args: Advising Primitives. (line 22) * ad-disable-advice: Enabling Advice. (line 21) * ad-disable-regexp: Enabling Advice. (line 34) * ad-do-it: Around-Advice. (line 22) * ad-enable-advice: Enabling Advice. (line 25) * ad-enable-regexp: Enabling Advice. (line 38) * ad-get-arg: Argument Access in Advice. (line 32) * ad-get-args: Argument Access in Advice. (line 35) * ad-return-value: Defining Advice. (line 33) * ad-set-arg: Argument Access in Advice. (line 39) * ad-set-args: Argument Access in Advice. (line 42) * ad-start-advice: Activation of Advice. (line 80) * ad-stop-advice: Activation of Advice. (line 84) * ad-unadvise: Defining Advice. (line 131) * ad-unadvise-all: Defining Advice. (line 134) * ad-update: Activation of Advice. (line 45) * ad-update-all: Activation of Advice. (line 55) * ad-update-regexp: Activation of Advice. (line 71) * adaptive-fill-first-line-regexp: Adaptive Fill. (line 66) * adaptive-fill-function: Adaptive Fill. (line 79) * adaptive-fill-mode: Adaptive Fill. (line 13) * adaptive-fill-regexp: Adaptive Fill. (line 57) * add-hook: Setting Hooks. (line 12) * add-name-to-file: Changing Files. (line 28) * add-text-properties: Changing Properties. (line 25) * add-to-history: Minibuffer History. (line 59) * add-to-invisibility-spec: Invisible Text. (line 63) * add-to-list: List Variables. (line 23) * add-to-ordered-list: List Variables. (line 58) * address field of register: Cons Cell Type. (line 6) * adjust-window-trailing-edge: Resizing Windows. (line 69) * adjusting point: Adjusting Point. (line 6) * advice, activating: Activation of Advice. (line 6) * advice, defining: Defining Advice. (line 6) * advice, enabling and disabling: Enabling Advice. (line 6) * advice, preactivating: Preactivation. (line 6) * advising functions: Advising Functions. (line 6) * advising primitives: Advising Primitives. (line 6) * after-advice: Defining Advice. (line 25) * after-change-functions: Change Hooks. (line 24) * after-change-major-mode-hook: Mode Hooks. (line 47) * after-find-file: Subroutines of Visiting. (line 32) * after-init-hook: Init File. (line 60) * after-init-time: Startup Summary. (line 58) * after-insert-file-functions: Format Conversion Piecemeal. (line 80) * after-load-alist: Hooks for Loading. (line 55) * after-load-functions: Hooks for Loading. (line 10) * after-make-frame-functions: Creating Frames. (line 39) * after-revert-hook: Reverting. (line 84) * after-save-hook: Saving Buffers. (line 132) * after-string (overlay property): Overlay Properties. (line 180) * alist: Association Lists. (line 6) * alist vs. plist: Plists and Alists. (line 6) * all-completions: Basic Completion. (line 104) * alt characters: Other Char Bits. (line 16) * and: Combining Conditions. (line 18) * anonymous function: Anonymous Functions. (line 6) * apostrophe for quoting: Quoting. (line 15) * append: Building Lists. (line 62) * append-to-file: Writing to Files. (line 12) * apply: Calling Functions. (line 53) * apply, and debugging: Internals of Debugger. (line 62) * apply-partially: Calling Functions. (line 88) * apropos: Help Functions. (line 12) * apropos-mode-map: Standard Keymaps. (line 18) * aref: Array Functions. (line 21) * args, customization keyword: Composite Types. (line 207) * argument binding: Argument List. (line 6) * argument lists, features: Argument List. (line 6) * arguments for shell commands: Shell Arguments. (line 6) * arguments, interactive entry: Using Interactive. (line 6) * arguments, reading: Minibuffers. (line 6) * argv: Command-Line Arguments. (line 66) * arith-error example: Handling Errors. (line 149) * arith-error in division: Arithmetic Operations. (line 93) * arithmetic operations: Arithmetic Operations. (line 6) * arithmetic shift: Bitwise Operations. (line 83) * around-advice: Defining Advice. (line 25) * array: Arrays. (line 6) * array elements: Array Functions. (line 21) * arrayp: Array Functions. (line 10) * ASCII character codes: Character Type. (line 6) * ascii-case-table: Case Tables. (line 93) * aset: Array Functions. (line 34) * ash: Bitwise Operations. (line 83) * asin: Math Functions. (line 16) * ask-user-about-lock: File Locks. (line 51) * ask-user-about-supersession-threat: Modification Time. (line 77) * asking the user questions: Yes-or-No Queries. (line 6) * assoc: Association Lists. (line 60) * assoc-default: Association Lists. (line 157) * assoc-string: Text Comparison. (line 122) * association list: Association Lists. (line 6) * assq: Association Lists. (line 100) * assq-delete-all: Association Lists. (line 213) * asynchronous subprocess: Asynchronous Processes. (line 6) * atan: Math Functions. (line 26) * atom: List-related Predicates. (line 16) * atomic changes: Atomic Changes. (line 6) * atoms: Cons Cell Type. (line 22) * attributes of text: Text Properties. (line 6) * Auto Fill mode: Auto Filling. (line 6) * auto-coding-alist: Default Coding Systems. (line 52) * auto-coding-functions: Default Coding Systems. (line 98) * auto-coding-regexp-alist: Default Coding Systems. (line 18) * auto-fill-chars: Auto Filling. (line 36) * auto-fill-function: Auto Filling. (line 15) * auto-hscroll-mode: Horizontal Scrolling. (line 40) * auto-mode-alist: Auto Major Mode. (line 117) * auto-raise-tool-bar-buttons: Tool Bar. (line 148) * auto-resize-tool-bars: Tool Bar. (line 136) * auto-save-default: Auto-Saving. (line 128) * auto-save-file-name-p: Auto-Saving. (line 30) * auto-save-hook: Auto-Saving. (line 125) * auto-save-interval: Auto-Saving. (line 106) * auto-save-list-file-name: Auto-Saving. (line 183) * auto-save-list-file-prefix: Auto-Saving. (line 200) * auto-save-mode: Auto-Saving. (line 23) * auto-save-timeout: Auto-Saving. (line 113) * auto-save-visited-file-name: Auto-Saving. (line 84) * auto-window-vscroll: Vertical Scrolling. (line 52) * autoload: Autoload. (line 6) * autoload cookie: Autoload. (line 93) * autoload errors: Autoload. (line 79) * automatic face assignment: Auto Faces. (line 6) * automatically buffer-local: Intro to Buffer-Local. (line 39) * back-to-indentation: Motion by Indent. (line 10) * backquote (list substitution): Backquote. (line 6) * backslash in character constant: General Escape Syntax. (line 23) * backslash in strings: Syntax for Strings. (line 6) * backslash in symbols: Symbol Type. (line 23) * backspace: Basic Char Syntax. (line 27) * backtrace: Internals of Debugger. (line 21) * backtrace-debug: Internals of Debugger. (line 69) * backtrace-frame: Internals of Debugger. (line 89) * backtracking: Backtracking. (line 6) * backup file: Backup Files. (line 6) * backup files, rename or copy: Rename or Copy. (line 6) * backup-buffer: Making Backups. (line 7) * backup-by-copying: Rename or Copy. (line 30) * backup-by-copying-when-linked: Rename or Copy. (line 38) * backup-by-copying-when-mismatch: Rename or Copy. (line 45) * backup-by-copying-when-privileged-mismatch: Rename or Copy. (line 58) * backup-directory-alist: Making Backups. (line 68) * backup-enable-predicate: Making Backups. (line 44) * backup-file-name-p: Backup Names. (line 11) * backup-inhibited: Making Backups. (line 56) * backups and auto-saving: Backups and Auto-Saving. (line 6) * backward-button: Button Buffer Commands. (line 43) * backward-char: Character Motion. (line 40) * backward-delete-char-untabify: Deletion. (line 70) * backward-delete-char-untabify-method: Deletion. (line 90) * backward-list: List Motion. (line 20) * backward-prefix-chars: Motion and Syntax. (line 35) * backward-sexp: List Motion. (line 52) * backward-to-indentation: Motion by Indent. (line 15) * backward-word: Word Motion. (line 32) * balance-windows: Resizing Windows. (line 152) * balance-windows-area: Resizing Windows. (line 163) * balanced parenthesis motion: List Motion. (line 6) * balancing parentheses: Blinking. (line 6) * balancing window sizes: Resizing Windows. (line 147) * barf-if-buffer-read-only: Read Only Buffers. (line 58) * base 64 encoding: Base 64. (line 6) * base buffer: Indirect Buffers. (line 6) * base coding system: Coding System Basics. (line 44) * base for reading an integer: Integer Basics. (line 22) * base64-decode-region: Base 64. (line 35) * base64-decode-string: Base 64. (line 43) * base64-encode-region: Base 64. (line 12) * base64-encode-string: Base 64. (line 24) * basic code (of input character): Keyboard Events. (line 12) * batch mode: Batch Mode. (line 6) * batch-byte-compile: Compilation Functions. (line 132) * baud, in serial connections: Serial Ports. (line 119) * baud-rate: Terminal Output. (line 11) * beep: Beeping. (line 18) * before point, insertion: Insertion. (line 6) * before-advice: Defining Advice. (line 25) * before-change-functions: Change Hooks. (line 17) * before-hack-local-variables-hook: File Local Variables. (line 72) * before-init-hook: Init File. (line 54) * before-init-time: Startup Summary. (line 15) * before-make-frame-hook: Creating Frames. (line 36) * before-revert-hook: Reverting. (line 80) * before-save-hook: Saving Buffers. (line 125) * before-string (overlay property): Overlay Properties. (line 175) * beginning of line: Text Lines. (line 54) * beginning of line in regexp: Regexp Special. (line 147) * beginning-of-buffer: Buffer End Motion. (line 19) * beginning-of-defun: List Motion. (line 56) * beginning-of-defun-function: List Motion. (line 81) * beginning-of-line: Text Lines. (line 15) * bell: Beeping. (line 6) * bell character: Basic Char Syntax. (line 27) * benchmark.el: Compilation Tips. (line 12) * benchmarking: Compilation Tips. (line 12) * big endian: Bindat Spec. (line 13) * binary coding system: Coding System Basics. (line 61) * binary files and text files: MS-DOS File Types. (line 6) * bindat-get-field: Bindat Functions. (line 20) * bindat-ip-to-string: Bindat Functions. (line 54) * bindat-length: Bindat Functions. (line 39) * bindat-pack: Bindat Functions. (line 43) * bindat-unpack: Bindat Functions. (line 11) * binding arguments: Argument List. (line 6) * binding local variables: Local Variables. (line 6) * binding of a key: Keymap Basics. (line 6) * bitmap-spec-p: Face Attributes. (line 196) * bitmaps, fringe: Fringe Bitmaps. (line 6) * bitwise arithmetic: Bitwise Operations. (line 6) * blink-cursor-alist: Cursor Parameters. (line 37) * blink-matching-delay: Blinking. (line 23) * blink-matching-open: Blinking. (line 29) * blink-matching-paren: Blinking. (line 16) * blink-matching-paren-distance: Blinking. (line 19) * blink-paren-function: Blinking. (line 10) * blinking parentheses: Blinking. (line 6) * bobp: Near Point. (line 62) * body of function: Lambda Components. (line 37) * bolp: Near Point. (line 73) * bool-vector-p: Bool-Vectors. (line 22) * Bool-vectors: Bool-Vectors. (line 6) * boolean: nil and t. (line 6) * booleanp: nil and t. (line 39) * boundp: Void Variables. (line 71) * box diagrams, for lists: Box Diagrams. (line 6) * break: Debugger. (line 6) * breakpoints (Edebug): Breakpoints. (line 6) * bucket (in obarray): Creating Symbols. (line 11) * buffer: Buffers. (line 6) * buffer contents: Text. (line 23) * buffer file name: Buffer File Name. (line 6) * buffer input stream: Input Streams. (line 12) * buffer internals: Buffer Internals. (line 6) * buffer list: The Buffer List. (line 6) * buffer modification: Buffer Modification. (line 6) * buffer names: Buffer Names. (line 6) * buffer output stream: Output Streams. (line 11) * buffer text notation: Buffer Text Notation. (line 6) * buffer, read-only: Read Only Buffers. (line 6) * buffer-access-fontified-property: Lazy Properties. (line 30) * buffer-access-fontify-functions: Lazy Properties. (line 15) * buffer-auto-save-file-format: Format Conversion Round-Trip. (line 149) * buffer-auto-save-file-name: Auto-Saving. (line 15) * buffer-backed-up: Making Backups. (line 20) * buffer-base-buffer: Indirect Buffers. (line 60) * buffer-chars-modified-tick: Buffer Modification. (line 58) * buffer-disable-undo: Maintaining Undo. (line 27) * buffer-display-count: Buffers and Windows. (line 41) * buffer-display-table: Active Display Table. (line 22) * buffer-display-time: Buffers and Windows. (line 90) * buffer-enable-undo: Maintaining Undo. (line 17) * buffer-end: Point. (line 51) * buffer-file-coding-system: Encoding and I/O. (line 21) * buffer-file-format: Format Conversion Round-Trip. (line 103) * buffer-file-name: Buffer File Name. (line 14) * buffer-file-number: Buffer File Name. (line 44) * buffer-file-truename: Buffer File Name. (line 38) * buffer-file-type: MS-DOS File Types. (line 17) * buffer-has-markers-at: Information from Markers. (line 32) * buffer-invisibility-spec: Invisible Text. (line 35) * buffer-list: The Buffer List. (line 29) * buffer-live-p: Killing Buffers. (line 98) * buffer-local variables: Buffer-Local Variables. (line 6) * buffer-local variables in modes: Major Mode Conventions. (line 145) * buffer-local variables, general-purpose: Standard Buffer-Local Variables. (line 6) * buffer-local-value: Creating Buffer-Local. (line 86) * buffer-local-variables: Creating Buffer-Local. (line 92) * Buffer-menu-mode-map: Standard Keymaps. (line 21) * buffer-modified-p: Buffer Modification. (line 23) * buffer-modified-tick: Buffer Modification. (line 52) * buffer-name: Buffer Names. (line 19) * buffer-name-history: Minibuffer History. (line 103) * buffer-offer-save: Killing Buffers. (line 83) * buffer-read-only: Read Only Buffers. (line 28) * buffer-save-without-query: Killing Buffers. (line 92) * buffer-saved-size: Auto-Saving. (line 166) * buffer-size: Point. (line 55) * buffer-string: Buffer Contents. (line 85) * buffer-substring: Buffer Contents. (line 10) * buffer-substring-filters: Buffer Contents. (line 71) * buffer-substring-no-properties: Buffer Contents. (line 44) * buffer-swap-text: Swapping Text. (line 27) * buffer-undo-list: Undo. (line 16) * bufferp: Buffer Basics. (line 41) * buffers without undo information: Buffer Names. (line 12) * buffers, controlled in windows: Buffers and Windows. (line 6) * buffers, creating: Creating Buffers. (line 6) * buffers, killing: Killing Buffers. (line 6) * bugs: Caveats. (line 27) * bugs in this manual: Caveats. (line 6) * building Emacs: Building Emacs. (line 6) * building lists: Building Lists. (line 6) * built-in function: What Is a Function. (line 22) * bury-buffer: The Buffer List. (line 102) * butlast: List Elements. (line 142) * button (button property): Button Properties. (line 51) * button buffer commands: Button Buffer Commands. (line 6) * button properties: Button Properties. (line 6) * button types: Button Types. (line 6) * button-activate: Manipulating Buttons. (line 29) * button-at: Manipulating Buttons. (line 45) * button-down event: Button-Down Events. (line 6) * button-end: Manipulating Buttons. (line 20) * button-face, customization keyword: Type Keywords. (line 64) * button-get: Manipulating Buttons. (line 23) * button-has-type-p: Manipulating Buttons. (line 41) * button-label: Manipulating Buttons. (line 35) * button-prefix, customization keyword: Type Keywords. (line 69) * button-put: Manipulating Buttons. (line 26) * button-start: Manipulating Buttons. (line 17) * button-suffix, customization keyword: Type Keywords. (line 69) * button-type: Manipulating Buttons. (line 38) * button-type-get: Manipulating Buttons. (line 51) * button-type-put: Manipulating Buttons. (line 48) * button-type-subtype-p: Manipulating Buttons. (line 54) * buttons in buffers: Buttons. (line 6) * byte compilation: Byte Compilation. (line 6) * byte compiler warnings, how to avoid: Warning Tips. (line 6) * byte packing and unpacking: Byte Packing. (line 6) * byte-boolean-vars <1>: Writing Emacs Primitives. (line 181) * byte-boolean-vars: Variables with Restricted Values. (line 23) * byte-code <1>: Compilation Functions. (line 145) * byte-code: Byte Compilation. (line 6) * byte-code function: Byte-Code Objects. (line 6) * byte-code interpreter: Compilation Functions. (line 145) * byte-code-function-p: What Is a Function. (line 97) * byte-compile: Compilation Functions. (line 34) * byte-compile-dynamic: Dynamic Loading. (line 46) * byte-compile-dynamic-docstrings: Docs and Compilation. (line 45) * byte-compile-file: Compilation Functions. (line 82) * byte-compiling macros: Compiling Macros. (line 6) * byte-compiling require: Named Features. (line 46) * byte-recompile-directory: Compilation Functions. (line 112) * byte-to-position: Text Representations. (line 72) * bytes: Strings and Characters. (line 6) * bytesize, in serial connections: Serial Ports. (line 119) * C-c: Prefix Keys. (line 21) * C-g: Quitting. (line 6) * C-h: Prefix Keys. (line 19) * C-M-x: Instrumenting. (line 10) * c-mode-map: Standard Keymaps. (line 24) * c-mode-syntax-table: Standard Syntax Tables. (line 17) * C-x: Prefix Keys. (line 27) * C-x 4: Prefix Keys. (line 34) * C-x 5: Prefix Keys. (line 36) * C-x 6: Prefix Keys. (line 38) * C-x : Prefix Keys. (line 31) * C-x v: Prefix Keys. (line 40) * C-x X =: Coverage Testing. (line 24) * caar: List Elements. (line 129) * cache-long-line-scans: Truncation. (line 74) * cadr: List Elements. (line 132) * call stack: Internals of Debugger. (line 21) * call-interactively: Interactive Call. (line 36) * call-process: Synchronous Processes. (line 31) * call-process-region: Synchronous Processes. (line 180) * call-process-shell-command: Synchronous Processes. (line 231) * called-interactively-p: Distinguish Interactive. (line 27) * calling a function: Calling Functions. (line 6) * cancel-change-group: Atomic Changes. (line 53) * cancel-debug-on-entry: Function Debugging. (line 63) * cancel-timer: Timers. (line 129) * capitalization: Case Conversion. (line 54) * capitalize: Case Conversion. (line 54) * capitalize-region: Case Changes. (line 13) * capitalize-word: Case Changes. (line 50) * car: List Elements. (line 7) * car-safe: List Elements. (line 35) * case conversion in buffers: Case Changes. (line 6) * case conversion in Lisp: Case Conversion. (line 6) * case in replacements: Replacing Match. (line 9) * case-fold-search: Searching and Case. (line 25) * case-replace: Searching and Case. (line 30) * case-table-p: Case Tables. (line 62) * catch: Catch and Throw. (line 61) * categories of characters: Categories. (line 6) * category (overlay property): Overlay Properties. (line 69) * category (text property): Special Properties. (line 15) * category table: Categories. (line 12) * category-docstring: Categories. (line 37) * category-set-mnemonics: Categories. (line 96) * category-table: Categories. (line 51) * category-table-p: Categories. (line 54) * cdar: List Elements. (line 135) * cddr: List Elements. (line 138) * cdr: List Elements. (line 21) * cdr-safe: List Elements. (line 48) * ceiling: Numeric Conversions. (line 53) * centering point: Textual Scrolling. (line 158) * change hooks: Change Hooks. (line 6) * change hooks for a character: Special Properties. (line 229) * change-major-mode-hook: Creating Buffer-Local. (line 163) * changing key bindings: Changing Key Bindings. (line 6) * changing to another buffer: Current Buffer. (line 6) * changing window size: Resizing Windows. (line 6) * char-after: Near Point. (line 14) * char-before: Near Point. (line 27) * char-category-set: Categories. (line 86) * char-charset: Character Sets. (line 39) * char-code-property-description: Character Properties. (line 123) * char-displayable-p: Fontsets. (line 125) * char-equal: Text Comparison. (line 7) * char-or-string-p: Predicates for Strings. (line 17) * char-property-alias-alist: Examining Properties. (line 51) * char-script-table: Character Properties. (line 138) * char-syntax: Syntax Table Functions. (line 71) * char-table length: Sequence Functions. (line 16) * char-table-extra-slot: Char-Tables. (line 74) * char-table-p: Char-Tables. (line 57) * char-table-parent: Char-Tables. (line 67) * char-table-range: Char-Tables. (line 85) * char-table-subtype: Char-Tables. (line 61) * char-tables: Char-Tables. (line 6) * char-to-string: String Conversion. (line 20) * char-width: Width. (line 11) * char-width-table: Character Properties. (line 146) * character quote: Syntax Class Table. (line 92) * character alternative (in regexp): Regexp Special. (line 72) * character arrays: Strings and Characters. (line 6) * character case: Case Conversion. (line 6) * character categories: Categories. (line 6) * character classes in regexp: Char Classes. (line 6) * character code conversion: Coding System Basics. (line 6) * character codepoint: Text Representations. (line 10) * character codes: Character Codes. (line 6) * character insertion: Commands for Insertion. (line 17) * character printing: Describing Characters. (line 29) * character properties: Character Properties. (line 6) * character sets: Character Sets. (line 6) * character to string: String Conversion. (line 20) * character translation tables: Translation of Characters. (line 6) * characterp: Character Codes. (line 22) * characters: Strings and Characters. (line 6) * characters for interactive codes: Interactive Codes. (line 6) * characters, multi-byte: Non-ASCII Characters. (line 6) * characters, representation in buffers and strings: Text Representations. (line 20) * charset: Character Sets. (line 6) * charset, coding systems to encode: Lisp and Coding Systems. (line 80) * charset, text property: Explicit Encoding. (line 106) * charset-after: Scanning Charsets. (line 13) * charset-list: Character Sets. (line 28) * charset-plist: Character Sets. (line 49) * charset-priority-list: Character Sets. (line 31) * charsetp: Character Sets. (line 24) * charsets supported by a coding system: Lisp and Coding Systems. (line 137) * check-coding-system: Lisp and Coding Systems. (line 19) * check-coding-systems-region: Lisp and Coding Systems. (line 85) * checkdoc-minor-mode: Documentation Tips. (line 6) * child process: Processes. (line 6) * circular list: Cons Cells. (line 33) * circular structure, read syntax: Circular Objects. (line 6) * cl: Lisp History. (line 28) * CL note--allocate more storage: Garbage Collection. (line 41) * CL note--case of letters: Symbol Type. (line 39) * CL note--default optional arg: Argument List. (line 46) * CL note--integers vrs eq: Comparison of Numbers. (line 40) * CL note--interning existing symbol: Creating Symbols. (line 111) * CL note--lack union, intersection: Sets And Lists. (line 14) * CL note--no continuable errors: Signaling Errors. (line 87) * CL note--only throw in Emacs: Catch and Throw. (line 55) * CL note--rplaca vs setcar: Modifying Lists. (line 10) * CL note--set local: Setting Variables. (line 81) * CL note--special forms compared: Special Forms. (line 96) * CL note--special variables: Variable Scoping. (line 24) * CL note--symbol in obarrays: Creating Symbols. (line 65) * class of advice: Defining Advice. (line 25) * cleanup forms: Cleanups. (line 13) * clear-abbrev-table: Abbrev Tables. (line 19) * clear-image-cache: Image Cache. (line 33) * clear-string: Modifying Strings. (line 27) * clear-this-command-keys: Command Loop Info. (line 95) * clear-visited-file-modtime: Modification Time. (line 35) * click event: Click Events. (line 6) * clickable buttons in buffers: Buttons. (line 6) * clickable text: Clickable Text. (line 6) * clipboard support (for MS-Windows): Window System Selections. (line 70) * clone-indirect-buffer: Indirect Buffers. (line 50) * close parenthesis character: Syntax Class Table. (line 45) * closures not available: Extent. (line 32) * clrhash: Hash Access. (line 29) * coded character set: Character Sets. (line 6) * codepoint, largest value: Character Codes. (line 32) * codes, interactive, description of: Interactive Codes. (line 6) * codespace: Text Representations. (line 10) * coding conventions in Emacs Lisp: Coding Conventions. (line 6) * coding standards: Tips. (line 6) * coding system: Coding Systems. (line 6) * coding system, automatically determined: Default Coding Systems. (line 6) * coding system, validity check: Lisp and Coding Systems. (line 18) * coding systems for encoding a string: Lisp and Coding Systems. (line 73) * coding systems for encoding region: Lisp and Coding Systems. (line 64) * coding systems, priority: Specifying Coding Systems. (line 50) * coding-system-aliases: Coding System Basics. (line 89) * coding-system-change-eol-conversion: Lisp and Coding Systems. (line 48) * coding-system-change-text-conversion: Lisp and Coding Systems. (line 59) * coding-system-charset-list: Lisp and Coding Systems. (line 138) * coding-system-eol-type: Lisp and Coding Systems. (line 26) * coding-system-for-read: Specifying Coding Systems. (line 10) * coding-system-for-write: Specifying Coding Systems. (line 36) * coding-system-get: Coding System Basics. (line 72) * coding-system-list: Lisp and Coding Systems. (line 9) * coding-system-p: Lisp and Coding Systems. (line 15) * coding-system-priority-list: Specifying Coding Systems. (line 57) * color names: Color Names. (line 6) * color-defined-p: Color Names. (line 26) * color-gray-p: Color Names. (line 62) * color-supported-p: Color Names. (line 50) * color-values: Color Names. (line 68) * colors on text-only terminals: Text Terminal Colors. (line 6) * columns: Columns. (line 6) * COM1: Serial Ports. (line 6) * combine-after-change-calls: Change Hooks. (line 40) * combine-and-quote-strings: Shell Arguments. (line 61) * command: What Is a Function. (line 54) * command descriptions: A Sample Function Description. (line 6) * command history: Command History. (line 6) * command in keymap: Key Lookup. (line 42) * command loop: Command Loop. (line 6) * command loop, recursive: Recursive Editing. (line 6) * command-debug-status: Internals of Debugger. (line 78) * command-error-function: Processing of Errors. (line 23) * command-execute: Interactive Call. (line 58) * command-history: Command History. (line 15) * command-history-map: Standard Keymaps. (line 27) * command-line: Command-Line Arguments. (line 20) * command-line arguments: Command-Line Arguments. (line 6) * command-line options: Command-Line Arguments. (line 33) * command-line-args: Command-Line Arguments. (line 62) * command-line-args-left: Command-Line Arguments. (line 66) * command-line-functions: Command-Line Arguments. (line 70) * command-line-processed: Command-Line Arguments. (line 25) * command-remapping: Remapping Commands. (line 40) * command-switch-alist: Command-Line Arguments. (line 33) * commandp: Interactive Call. (line 13) * commandp example: High-Level Completion. (line 90) * commands, defining: Defining Commands. (line 6) * comment ender: Syntax Class Table. (line 119) * comment starter: Syntax Class Table. (line 118) * comment syntax: Syntax Class Table. (line 119) * comments: Comments. (line 6) * comments, Lisp convention for: Comment Tips. (line 6) * Common Lisp: Lisp History. (line 11) * compare-buffer-substrings: Comparing Text. (line 11) * compare-strings: Text Comparison. (line 102) * compare-window-configurations: Window Configurations. (line 86) * comparing buffer text: Comparing Text. (line 6) * comparing file modification time: Modification Time. (line 6) * comparing numbers: Comparison of Numbers. (line 6) * compilation (Emacs Lisp): Byte Compilation. (line 6) * compilation functions: Compilation Functions. (line 6) * compile-defun: Compilation Functions. (line 72) * compile-time constant: Eval During Compile. (line 42) * compiled function: Byte-Code Objects. (line 6) * compiler errors: Compiler Errors. (line 6) * complete key: Keymap Basics. (line 6) * completing-read: Minibuffer Completion. (line 11) * completion: Completion. (line 6) * completion styles: Completion Styles. (line 6) * completion, file name: File Name Completion. (line 6) * completion-annotate-function: Programmed Completion. (line 64) * completion-auto-help: Completion Commands. (line 96) * completion-ignore-case: Basic Completion. (line 156) * completion-ignored-extensions: File Name Completion. (line 62) * completion-in-region: Basic Completion. (line 187) * completion-regexp-list: Basic Completion. (line 164) * completion-styles: Completion Styles. (line 11) * completion-styles-alist: Completion Styles. (line 16) * completion-table-dynamic: Programmed Completion. (line 56) * complex arguments: Minibuffers. (line 6) * complex command: Command History. (line 6) * Composite Types (customization): Composite Types. (line 6) * composition (text property): Special Properties. (line 299) * composition property, and point display: Adjusting Point. (line 6) * compute-motion: Screen Lines. (line 89) * concat: Creating Strings. (line 98) * concatenating lists: Rearrangement. (line 16) * concatenating strings: Creating Strings. (line 98) * cond: Conditionals. (line 52) * condition name: Error Symbols. (line 6) * condition-case: Handling Errors. (line 87) * conditional evaluation: Conditionals. (line 6) * conditional selection of windows: Selecting Windows. (line 95) * cons: Building Lists. (line 12) * cons cells: Building Lists. (line 6) * cons-cells-consed: Memory Usage. (line 14) * consing: Building Lists. (line 25) * consp: List-related Predicates. (line 12) * constant variables <1>: Defining Variables. (line 103) * constant variables: Constant Variables. (line 6) * constrain-to-field: Fields. (line 71) * continuation lines: Truncation. (line 6) * continue-process: Signals to Processes. (line 76) * control character key constants: Changing Key Bindings. (line 20) * control character printing: Describing Characters. (line 29) * control characters: Ctl-Char Syntax. (line 6) * control characters in display: Usual Display. (line 58) * control characters, reading: Quoted Character Input. (line 12) * control structures: Control Structures. (line 6) * Control-X-prefix: Prefix Keys. (line 27) * controller part, model/view/controller: Abstract Display Example. (line 61) * controlling terminal: Suspending Emacs. (line 13) * controlling-tty-p: Suspending Emacs. (line 112) * conventions for writing major modes: Major Mode Conventions. (line 6) * conventions for writing minor modes: Minor Mode Conventions. (line 6) * conversion of strings: String Conversion. (line 6) * convert-standard-filename: Standard File Names. (line 21) * converting numbers: Numeric Conversions. (line 6) * coordinates-in-window-p: Coordinates and Windows. (line 17) * copy-abbrev-table: Abbrev Tables. (line 23) * copy-alist: Association Lists. (line 174) * copy-category-table: Categories. (line 61) * copy-directory: Create/Delete Dirs. (line 20) * copy-face: Face Functions. (line 17) * copy-file: Changing Files. (line 82) * copy-hash-table: Other Hash. (line 12) * copy-keymap: Creating Keymaps. (line 40) * copy-marker: Creating Markers. (line 53) * copy-overlay: Managing Overlays. (line 80) * copy-region-as-kill: Kill Functions. (line 39) * copy-sequence: Sequence Functions. (line 62) * copy-syntax-table: Syntax Table Functions. (line 21) * copy-tree: Building Lists. (line 162) * copying alists: Association Lists. (line 174) * copying files: Changing Files. (line 6) * copying lists: Building Lists. (line 62) * copying sequences: Sequence Functions. (line 62) * copying strings: Creating Strings. (line 98) * copying vectors: Vector Functions. (line 33) * cos: Math Functions. (line 11) * count-lines: Text Lines. (line 72) * count-loop: A Sample Function Description. (line 67) * count-screen-lines: Screen Lines. (line 50) * counting columns: Columns. (line 6) * coverage testing: Test Coverage. (line 6) * coverage testing (Edebug): Coverage Testing. (line 6) * create-file-buffer: Subroutines of Visiting. (line 11) * create-fontset-from-fontset-spec: Fontsets. (line 15) * create-glyph: Glyphs. (line 57) * create-image: Defining Images. (line 11) * creating buffers: Creating Buffers. (line 6) * creating hash tables: Creating Hash. (line 6) * creating keymaps: Creating Keymaps. (line 6) * creating, copying and deleting directories: Create/Delete Dirs. (line 6) * ctl-arrow: Usual Display. (line 58) * ctl-x-4-map: Prefix Keys. (line 34) * ctl-x-5-map: Prefix Keys. (line 36) * ctl-x-map: Prefix Keys. (line 27) * current binding: Local Variables. (line 39) * current buffer: Current Buffer. (line 6) * current buffer mark: The Mark. (line 54) * current buffer point and mark (Edebug): Edebug Display Update. (line 22) * current buffer position: Point. (line 32) * current command: Command Loop Info. (line 34) * current stack frame: Using Debugger. (line 24) * current-active-maps: Active Keymaps. (line 72) * current-buffer: Current Buffer. (line 84) * current-case-table: Case Tables. (line 72) * current-column: Columns. (line 23) * current-fill-column: Margins. (line 51) * current-frame-configuration: Frame Configurations. (line 11) * current-global-map: Controlling Active Maps. (line 17) * current-idle-time: Idle Timers. (line 45) * current-indentation: Primitive Indent. (line 11) * current-input-method: Input Methods. (line 18) * current-input-mode: Input Modes. (line 35) * current-justification: Filling. (line 124) * current-kill: Low-Level Kill Ring. (line 12) * current-left-margin: Margins. (line 44) * current-local-map: Controlling Active Maps. (line 28) * current-message: Displaying Messages. (line 88) * current-minor-mode-maps: Controlling Active Maps. (line 48) * current-prefix-arg: Prefix Command Arguments. (line 87) * current-time: Time of Day. (line 30) * current-time-string: Time of Day. (line 10) * current-time-zone: Time of Day. (line 44) * current-window-configuration: Window Configurations. (line 21) * current-word: Buffer Contents. (line 99) * currying: Calling Functions. (line 78) * cursor: Window Point. (line 25) * cursor (text property): Special Properties. (line 173) * cursor, fringe: Fringe Cursors. (line 6) * cursor-in-echo-area: Echo Area Customization. (line 9) * cursor-in-non-selected-windows: Cursor Parameters. (line 50) * cursor-type: Cursor Parameters. (line 32) * cust-print: Printing in Edebug. (line 6) * custom-add-frequent-value: Variable Definitions. (line 177) * custom-reevaluate-setting: Variable Definitions. (line 192) * customization definitions: Customization. (line 6) * customization groups, defining: Group Definitions. (line 6) * customization keywords: Common Keywords. (line 6) * customization types: Customization Types. (line 6) * customization variables, how to define: Variable Definitions. (line 6) * customize-package-emacs-version-alist: Common Keywords. (line 125) * cut buffer: Window System Selections. (line 46) * cyclic ordering of windows: Cyclic Window Ordering. (line 6) * data type: Lisp Data Types. (line 6) * data-directory: Help Functions. (line 121) * datagrams: Datagrams. (line 6) * date-leap-year-p: Time Calculations. (line 31) * date-to-time: Time Parsing. (line 10) * deactivate-mark: The Mark. (line 152) * deactivate-mark-hook: The Mark. (line 180) * deactivating advice: Activation of Advice. (line 42) * debug: Invoking the Debugger. (line 10) * debug-ignored-errors: Error Debugging. (line 37) * debug-on-entry: Function Debugging. (line 14) * debug-on-error: Error Debugging. (line 19) * debug-on-error use: Processing of Errors. (line 31) * debug-on-next-call: Internals of Debugger. (line 62) * debug-on-quit: Infinite Loops. (line 22) * debug-on-signal: Error Debugging. (line 59) * debugger: Internals of Debugger. (line 10) * debugger command list: Debugger Commands. (line 6) * debugger for Emacs Lisp: Debugger. (line 6) * debugger-mode-map: Standard Keymaps. (line 42) * debugging byte compilation problems: Compilation Errors. (line 6) * debugging errors: Error Debugging. (line 6) * debugging invalid Lisp syntax: Syntax Errors. (line 6) * debugging specific functions: Function Debugging. (line 6) * declare: Defining Macros. (line 38) * declare-function: Declaring Functions. (line 6) * declaring functions: Declaring Functions. (line 6) * decode process output: Decoding Output. (line 6) * decode-char: Character Sets. (line 71) * decode-coding-inserted-region: Explicit Encoding. (line 115) * decode-coding-region: Explicit Encoding. (line 72) * decode-coding-string: Explicit Encoding. (line 93) * decode-time: Time Conversion. (line 24) * decoding file formats: Format Conversion. (line 6) * decoding in coding systems: Explicit Encoding. (line 6) * decrement field of register: Cons Cell Type. (line 6) * dedicated window: Dedicated Windows. (line 6) * deep binding: Impl of Scope. (line 6) * def-edebug-spec: Instrumenting Macro Calls. (line 38) * defadvice: Defining Advice. (line 10) * defalias: Defining Functions. (line 62) * default argument string: Interactive Codes. (line 20) * default coding system: Default Coding Systems. (line 6) * default coding system, functions to determine: Default Coding Systems. (line 97) * default init file: Init File. (line 24) * default key binding: Format of Keymaps. (line 34) * default value: Default Value. (line 6) * default value of char-table: Char-Tables. (line 35) * default-boundp: Default Value. (line 28) * default-directory: File Name Expansion. (line 69) * default-file-modes: Changing Files. (line 158) * default-frame-alist: Initial Parameters. (line 49) * default-input-method: Input Methods. (line 24) * default-justification: Filling. (line 118) * default-minibuffer-frame: Minibuffers and Frames. (line 24) * default-process-coding-system: Default Coding Systems. (line 89) * default-text-properties: Examining Properties. (line 64) * default-value: Default Value. (line 22) * default.el: Startup Summary. (line 51) * defconst: Defining Variables. (line 104) * defcustom: Variable Definitions. (line 9) * defface: Defining Faces. (line 17) * defgroup: Group Definitions. (line 23) * defimage: Defining Images. (line 30) * define customization group: Group Definitions. (line 6) * define customization options: Variable Definitions. (line 6) * define hash comparisons: Defining Hash. (line 6) * define-abbrev: Defining Abbrevs. (line 17) * define-abbrev-table: Abbrev Tables. (line 30) * define-button-type: Button Types. (line 12) * define-category: Categories. (line 33) * define-derived-mode: Derived Modes. (line 11) * define-fringe-bitmap: Customizing Bitmaps. (line 8) * define-generic-mode: Generic Modes. (line 14) * define-globalized-minor-mode: Defining Minor Modes. (line 132) * define-hash-table-test: Defining Hash. (line 22) * define-key: Changing Key Bindings. (line 46) * define-key-after: Modifying Menus. (line 12) * define-minor-mode: Defining Minor Modes. (line 11) * define-obsolete-face-alias: Face Functions. (line 56) * define-obsolete-function-alias: Obsolete Functions. (line 25) * define-obsolete-variable-alias: Variable Aliases. (line 51) * define-prefix-command: Prefix Keys. (line 88) * defined-colors: Color Names. (line 42) * defining a function: Defining Functions. (line 6) * defining advice: Defining Advice. (line 6) * defining commands: Defining Commands. (line 6) * defining Lisp variables in C: Writing Emacs Primitives. (line 181) * defining menus: Defining Menus. (line 6) * defining-kbd-macro: Keyboard Macros. (line 45) * definitions of symbols: Definitions. (line 6) * defmacro: Defining Macros. (line 18) * defsubr, Lisp symbol for a primitive: Writing Emacs Primitives. (line 163) * defsubst: Inline Functions. (line 6) * defun: Defining Functions. (line 11) * DEFUN, C macro to define Lisp primitives: Writing Emacs Primitives. (line 40) * defun-prompt-regexp: List Motion. (line 68) * defvar: Defining Variables. (line 26) * DEFVAR_INT, DEFVAR_LISP, DEFVAR_BOOL: Writing Emacs Primitives. (line 181) * defvaralias: Variable Aliases. (line 15) * delay-mode-hooks: Mode Hooks. (line 38) * delete: Sets And Lists. (line 123) * delete-and-extract-region: Deletion. (line 35) * delete-auto-save-file-if-necessary: Auto-Saving. (line 145) * delete-auto-save-files: Auto-Saving. (line 154) * delete-backward-char: Deletion. (line 57) * delete-blank-lines: User-Level Deletion. (line 103) * delete-char: Deletion. (line 44) * delete-directory: Create/Delete Dirs. (line 36) * delete-dups: Sets And Lists. (line 173) * delete-exited-processes: Deleting Processes. (line 22) * delete-field: Fields. (line 67) * delete-file: Changing Files. (line 110) * delete-frame: Deleting Frames. (line 11) * delete-frame event: Misc Events. (line 8) * delete-frame-functions: Deleting Frames. (line 11) * delete-horizontal-space: User-Level Deletion. (line 11) * delete-indentation: User-Level Deletion. (line 39) * delete-minibuffer-contents: Minibuffer Contents. (line 38) * delete-old-versions: Numbered Backups. (line 45) * delete-other-windows: Deleting Windows. (line 30) * delete-overlay: Managing Overlays. (line 44) * delete-process: Deleting Processes. (line 29) * delete-region: Deletion. (line 29) * delete-terminal: Multiple Terminals. (line 49) * delete-terminal-functions: Multiple Terminals. (line 64) * delete-to-left-margin: Margins. (line 66) * delete-window: Deleting Windows. (line 25) * delete-windows-on: Deleting Windows. (line 35) * deleting files: Changing Files. (line 6) * deleting frames: Deleting Frames. (line 6) * deleting list elements: Sets And Lists. (line 32) * deleting previous char: Deletion. (line 57) * deleting processes: Deleting Processes. (line 6) * deleting text vs killing: Deletion. (line 6) * deleting whitespace: User-Level Deletion. (line 11) * deleting windows: Deleting Windows. (line 6) * delq: Sets And Lists. (line 32) * derived mode: Derived Modes. (line 6) * describe characters and events: Describing Characters. (line 6) * describe-bindings: Scanning Keymaps. (line 120) * describe-buffer-case-table: Case Tables. (line 114) * describe-categories: Categories. (line 114) * describe-current-display-table: Display Table Format. (line 85) * describe-display-table: Display Table Format. (line 81) * describe-mode: Mode Help. (line 12) * describe-prefix-bindings: Help Functions. (line 97) * description for interactive codes: Interactive Codes. (line 6) * description format: Format of Descriptions. (line 6) * deserializing: Byte Packing. (line 12) * desktop save mode: Desktop Save Mode. (line 6) * desktop-buffer-mode-handlers: Desktop Save Mode. (line 33) * desktop-save-buffer: Desktop Save Mode. (line 17) * destroy-fringe-bitmap: Customizing Bitmaps. (line 33) * destructive list operations: Modifying Lists. (line 6) * detect-coding-region: Lisp and Coding Systems. (line 99) * detect-coding-string: Lisp and Coding Systems. (line 119) * diagrams, boxed, for lists: Box Diagrams. (line 6) * dialog boxes: Dialog Boxes. (line 6) * digit-argument: Prefix Command Arguments. (line 109) * ding: Beeping. (line 13) * dir-locals-class-alist: Directory Local Variables. (line 63) * dir-locals-directory-cache: Directory Local Variables. (line 67) * dir-locals-file: Directory Local Variables. (line 17) * dir-locals-set-class-variables: Directory Local Variables. (line 39) * dir-locals-set-directory-class: Directory Local Variables. (line 56) * directory local variables: Directory Local Variables. (line 6) * directory name: Directory Names. (line 6) * directory name abbreviation: Directory Names. (line 65) * directory part (of file name): File Name Components. (line 6) * directory-abbrev-alist: Directory Names. (line 73) * directory-file-name: Directory Names. (line 35) * directory-files: Contents of Directories. (line 16) * directory-files-and-attributes: Contents of Directories. (line 46) * directory-oriented functions: Contents of Directories. (line 6) * dired-kept-versions: Numbered Backups. (line 51) * dired-mode-map: Standard Keymaps. (line 45) * disable-command: Disabling Commands. (line 37) * disable-point-adjustment: Adjusting Point. (line 16) * disabled: Disabling Commands. (line 11) * disabled command: Disabling Commands. (line 6) * disabled-command-function: Disabling Commands. (line 42) * disabling advice: Enabling Advice. (line 6) * disabling undo: Maintaining Undo. (line 27) * disassemble: Disassembly. (line 21) * disassembled byte-code: Disassembly. (line 6) * discard-input: Event Input Misc. (line 98) * discarding input: Event Input Misc. (line 98) * display (overlay property): Overlay Properties. (line 102) * display (text property): Display Property. (line 6) * display feature testing: Display Feature Testing. (line 6) * display margins: Display Margins. (line 6) * display message in echo area: Displaying Messages. (line 6) * display property, and point display: Adjusting Point. (line 6) * display specification: Display Property. (line 6) * display table: Display Tables. (line 6) * display, abstract: Abstract Display. (line 6) * display, arbitrary objects: Abstract Display. (line 6) * display-backing-store: Display Feature Testing. (line 109) * display-buffer: Choosing Window. (line 14) * display-buffer-function: Choosing Window. (line 269) * display-buffer-reuse-frames: Choosing Window. (line 51) * display-color-cells: Display Feature Testing. (line 134) * display-color-p: Display Feature Testing. (line 35) * display-completion-list: Completion Commands. (line 69) * display-graphic-p: Display Feature Testing. (line 25) * display-grayscale-p: Display Feature Testing. (line 40) * display-images-p: Display Feature Testing. (line 70) * display-message-or-buffer: Displaying Messages. (line 69) * display-mm-dimensions-alist: Display Feature Testing. (line 104) * display-mm-height: Display Feature Testing. (line 96) * display-mm-width: Display Feature Testing. (line 100) * display-mouse-p: Display Feature Testing. (line 31) * display-pixel-height: Display Feature Testing. (line 80) * display-pixel-width: Display Feature Testing. (line 88) * display-planes: Display Feature Testing. (line 124) * display-popup-menus-p: Display Feature Testing. (line 20) * display-save-under: Display Feature Testing. (line 119) * display-screens: Display Feature Testing. (line 76) * display-selections-p: Display Feature Testing. (line 65) * display-supports-face-attributes-p: Display Feature Testing. (line 45) * display-table-slot: Display Table Format. (line 67) * display-visual-class: Display Feature Testing. (line 129) * display-warning: Warning Basics. (line 43) * displaying a buffer: Displaying Buffers. (line 6) * displays, multiple: Multiple Terminals. (line 6) * dnd-protocol-alist: Drag and Drop. (line 20) * do-auto-save: Auto-Saving. (line 132) * doc, customization keyword: Type Keywords. (line 86) * doc-directory: Accessing Documentation. (line 136) * DOC-VERSION (documentation) file: Documentation Basics. (line 46) * documentation: Accessing Documentation. (line 26) * documentation conventions: Documentation Basics. (line 6) * documentation for major mode: Mode Help. (line 6) * documentation notation: Evaluation Notation. (line 6) * documentation of function: Function Documentation. (line 6) * documentation strings: Documentation. (line 6) * documentation strings, conventions and tips: Documentation Tips. (line 6) * documentation, keys in: Keys in Documentation. (line 6) * documentation-property: Accessing Documentation. (line 7) * dolist: Iteration. (line 52) * DOS file types: MS-DOS File Types. (line 6) * dotimes: Iteration. (line 64) * dotimes-with-progress-reporter: Progress. (line 98) * dotted list: Cons Cells. (line 33) * dotted lists (Edebug): Specification List. (line 142) * dotted pair notation: Dotted Pair Notation. (line 6) * double-click events: Repeat Events. (line 6) * double-click-fuzz: Repeat Events. (line 73) * double-click-time: Repeat Events. (line 83) * double-quote in strings: Syntax for Strings. (line 6) * down-list: List Motion. (line 30) * downcase: Case Conversion. (line 20) * downcase-region: Case Changes. (line 36) * downcase-word: Case Changes. (line 64) * downcasing in lookup-key: Key Sequence Input. (line 73) * drag event: Drag Events. (line 6) * drag-n-drop event: Misc Events. (line 43) * dribble file: Recording Input. (line 20) * dump-emacs: Building Emacs. (line 96) * dumped Lisp files: Building Emacs. (line 29) * dumping Emacs: Building Emacs. (line 22) * dynamic loading of documentation: Docs and Compilation. (line 6) * dynamic loading of functions: Dynamic Loading. (line 6) * dynamic scoping: Variable Scoping. (line 11) * easy-mmode-define-minor-mode: Defining Minor Modes. (line 77) * echo area: The Echo Area. (line 6) * echo-area-clear-hook: Echo Area Customization. (line 18) * echo-keystrokes: Echo Area Customization. (line 22) * edebug: Source Breakpoints. (line 6) * Edebug debugging facility: Edebug. (line 6) * Edebug execution modes: Edebug Execution Modes. (line 6) * Edebug specification list: Specification List. (line 6) * edebug-all-defs: Edebug Options. (line 16) * edebug-all-forms: Edebug Options. (line 25) * edebug-continue-kbd-macro: Edebug Options. (line 79) * edebug-display-freq-count: Coverage Testing. (line 30) * edebug-eval-macro-args: Instrumenting Macro Calls. (line 70) * edebug-eval-top-level-form: Instrumenting. (line 26) * edebug-global-break-condition: Edebug Options. (line 96) * edebug-initial-mode: Edebug Options. (line 60) * edebug-on-error: Edebug Options. (line 84) * edebug-on-quit: Edebug Options. (line 88) * edebug-print-circle: Printing in Edebug. (line 38) * edebug-print-length: Printing in Edebug. (line 16) * edebug-print-level: Printing in Edebug. (line 20) * edebug-print-trace-after: Trace Buffer. (line 24) * edebug-print-trace-before: Trace Buffer. (line 24) * edebug-save-displayed-buffer-points: Edebug Options. (line 46) * edebug-save-windows: Edebug Options. (line 34) * edebug-set-global-break-condition: Global Break Condition. (line 13) * edebug-setup-hook: Edebug Options. (line 9) * edebug-sit-for-seconds: Edebug Execution Modes. (line 83) * edebug-temp-display-freq-count: Coverage Testing. (line 24) * edebug-test-coverage: Edebug Options. (line 75) * edebug-trace <1>: Edebug Options. (line 68) * edebug-trace: Trace Buffer. (line 36) * edebug-tracing: Trace Buffer. (line 29) * edit-abbrevs-map: Standard Keymaps. (line 48) * edit-and-eval-command: Object from Minibuffer. (line 50) * edit-tab-stops-map: Standard Keymaps. (line 51) * editing types: Editing Types. (line 6) * editor command loop: Command Loop. (line 6) * eight-bit, a charset: Character Sets. (line 16) * electric-buffer-menu-mode-map: Standard Keymaps. (line 54) * electric-future-map: A Sample Variable Description. (line 16) * electric-history-map: Standard Keymaps. (line 57) * element (of list): Lists. (line 6) * elements of sequences: Sequence Functions. (line 39) * elp.el: Compilation Tips. (line 9) * elt: Sequence Functions. (line 39) * Emacs event standard notation: Describing Characters. (line 14) * Emacs process run time: Processor Run Time. (line 6) * emacs, a charset: Character Sets. (line 16) * emacs-build-time: Version Info. (line 24) * emacs-init-time: Processor Run Time. (line 38) * emacs-internal coding system: Coding System Basics. (line 65) * emacs-lisp-docstring-fill-column: Documentation Basics. (line 29) * emacs-lisp-mode-map: Standard Keymaps. (line 60) * emacs-lisp-mode-syntax-table: Standard Syntax Tables. (line 20) * emacs-major-version: Version Info. (line 42) * emacs-minor-version: Version Info. (line 46) * emacs-pid: System Environment. (line 211) * emacs-save-session-functions: Session Management. (line 20) * emacs-session-restore: Session Management. (line 28) * emacs-startup-hook: Init File. (line 66) * emacs-uptime: Processor Run Time. (line 10) * emacs-version: Version Info. (line 10) * EMACSLOADPATH environment variable: Library Search. (line 10) * empty list: Box Diagrams. (line 41) * emulation-mode-map-alists: Controlling Active Maps. (line 139) * enable-command: Disabling Commands. (line 32) * enable-local-eval: File Local Variables. (line 132) * enable-local-variables: File Local Variables. (line 25) * enable-multibyte-characters: Text Representations. (line 54) * enable-recursive-minibuffers: Recursive Mini. (line 15) * enabling advice: Enabling Advice. (line 6) * encode-char: Character Sets. (line 80) * encode-coding-region: Explicit Encoding. (line 40) * encode-coding-string: Explicit Encoding. (line 64) * encode-time: Time Conversion. (line 69) * encoding file formats: Format Conversion. (line 6) * encoding in coding systems: Explicit Encoding. (line 6) * end of line in regexp: Regexp Special. (line 160) * end-of-buffer: Buffer End Motion. (line 33) * end-of-defun: List Motion. (line 62) * end-of-defun-function: List Motion. (line 89) * end-of-file: Input Functions. (line 13) * end-of-line: Text Lines. (line 36) * end-of-line conversion: Coding System Basics. (line 36) * endianness: Bindat Spec. (line 13) * enlarge-window: Resizing Windows. (line 12) * enlarge-window-horizontally: Resizing Windows. (line 44) * environment: Intro Eval. (line 40) * environment variable access: System Environment. (line 94) * environment variables, subprocesses: Subprocess Creation. (line 59) * eobp: Near Point. (line 68) * EOL conversion: Coding System Basics. (line 36) * eol conversion of coding system: Lisp and Coding Systems. (line 47) * eol type of coding system: Lisp and Coding Systems. (line 25) * eolp: Near Point. (line 78) * eq: Equality Predicates. (line 12) * eql: Comparison of Numbers. (line 51) * equal: Equality Predicates. (line 63) * equal-including-properties: Equality Predicates. (line 123) * equality: Equality Predicates. (line 6) * erase-buffer: Deletion. (line 15) * error: Signaling Errors. (line 27) * error cleanup: Cleanups. (line 13) * error debugging: Error Debugging. (line 6) * error description: Handling Errors. (line 121) * error display: The Echo Area. (line 6) * error handler: Handling Errors. (line 6) * error in debug: Invoking the Debugger. (line 62) * error message notation: Error Messages. (line 6) * error name: Error Symbols. (line 6) * error symbol: Error Symbols. (line 6) * error-conditions: Error Symbols. (line 6) * error-message-string: Handling Errors. (line 144) * errors: Errors. (line 6) * esc-map: Prefix Keys. (line 15) * ESC-prefix: Prefix Keys. (line 15) * escape (ASCII character): Basic Char Syntax. (line 27) * escape characters: Output Variables. (line 18) * escape characters in printing: Output Functions. (line 9) * escape sequence: Basic Char Syntax. (line 45) * escape-syntax character: Syntax Class Table. (line 82) * eval: Eval. (line 22) * eval, and debugging: Internals of Debugger. (line 62) * eval-after-load: Hooks for Loading. (line 18) * eval-and-compile: Eval During Compile. (line 10) * eval-at-startup: Building Emacs. (line 89) * eval-buffer: Eval. (line 70) * eval-buffer (Edebug): Instrumenting. (line 19) * eval-current-buffer: Eval. (line 83) * eval-current-buffer (Edebug): Instrumenting. (line 19) * eval-defun (Edebug): Instrumenting. (line 10) * eval-expression (Edebug): Instrumenting. (line 51) * eval-expression-debug-on-error: Error Debugging. (line 52) * eval-expression-print-length: Output Variables. (line 82) * eval-expression-print-level: Output Variables. (line 83) * eval-minibuffer: Object from Minibuffer. (line 38) * eval-region: Eval. (line 47) * eval-region (Edebug): Instrumenting. (line 19) * eval-when-compile: Eval During Compile. (line 36) * evaluated expression argument: Interactive Codes. (line 196) * evaluation: Evaluation. (line 6) * evaluation error: Local Variables. (line 104) * evaluation list group: Eval List. (line 47) * evaluation notation: Evaluation Notation. (line 6) * evaluation of buffer contents: Eval. (line 68) * evaluation of special forms: Special Forms. (line 6) * evaporate (overlay property): Overlay Properties. (line 193) * even-window-heights: Choosing Window. (line 140) * event printing: Describing Characters. (line 29) * event type: Classifying Events. (line 6) * event, reading only one: Reading One Event. (line 6) * event-basic-type: Classifying Events. (line 67) * event-click-count: Repeat Events. (line 66) * event-convert-list: Classifying Events. (line 93) * event-end: Accessing Mouse. (line 24) * event-modifiers: Classifying Events. (line 27) * event-start: Accessing Mouse. (line 17) * eventp: Input Events. (line 12) * events: Input Events. (line 6) * ewoc: Abstract Display. (line 6) * ewoc-buffer: Abstract Display Functions. (line 30) * ewoc-collect: Abstract Display Functions. (line 108) * ewoc-create: Abstract Display Functions. (line 11) * ewoc-data: Abstract Display Functions. (line 61) * ewoc-delete: Abstract Display Functions. (line 100) * ewoc-enter-after: Abstract Display Functions. (line 47) * ewoc-enter-before: Abstract Display Functions. (line 46) * ewoc-enter-first: Abstract Display Functions. (line 41) * ewoc-enter-last: Abstract Display Functions. (line 42) * ewoc-filter: Abstract Display Functions. (line 103) * ewoc-get-hf: Abstract Display Functions. (line 33) * ewoc-goto-next: Abstract Display Functions. (line 80) * ewoc-goto-node: Abstract Display Functions. (line 87) * ewoc-goto-prev: Abstract Display Functions. (line 79) * ewoc-invalidate: Abstract Display Functions. (line 96) * ewoc-locate: Abstract Display Functions. (line 67) * ewoc-location: Abstract Display Functions. (line 76) * ewoc-map: Abstract Display Functions. (line 114) * ewoc-next: Abstract Display Functions. (line 52) * ewoc-nth: Abstract Display Functions. (line 56) * ewoc-prev: Abstract Display Functions. (line 51) * ewoc-refresh: Abstract Display Functions. (line 90) * ewoc-set-data: Abstract Display Functions. (line 64) * ewoc-set-hf: Abstract Display Functions. (line 37) * examining the interactive form: Using Interactive. (line 131) * examining windows: Buffers and Windows. (line 6) * examples of using interactive: Interactive Examples. (line 6) * excursion: Excursions. (line 6) * exec-directory: Subprocess Creation. (line 64) * exec-path: Subprocess Creation. (line 70) * exec-suffixes: Subprocess Creation. (line 32) * executable-find: Locating Files. (line 50) * execute program: Subprocess Creation. (line 17) * execute with prefix argument: Interactive Call. (line 82) * execute-extended-command: Interactive Call. (line 77) * execute-kbd-macro: Keyboard Macros. (line 13) * executing-kbd-macro: Keyboard Macros. (line 38) * execution speed: Compilation Tips. (line 6) * exit: Recursive Editing. (line 32) * exit recursive editing: Recursive Editing. (line 32) * exit-minibuffer: Minibuffer Commands. (line 9) * exit-recursive-edit: Recursive Editing. (line 88) * exiting Emacs: Getting Out. (line 6) * exp: Math Functions. (line 32) * expand-abbrev: Abbrev Expansion. (line 27) * expand-file-name: File Name Expansion. (line 13) * expansion of file names: File Name Expansion. (line 6) * expansion of macros: Expansion. (line 6) * expression: Intro Eval. (line 12) * expression prefix: Syntax Class Table. (line 110) * expt: Math Functions. (line 47) * extended-command-history: Minibuffer History. (line 109) * extent: Variable Scoping. (line 11) * extra slots of char-table: Char-Tables. (line 6) * extra-keyboard-modifiers: Event Mod. (line 12) * face (button property): Button Properties. (line 23) * face (overlay property): Overlay Properties. (line 74) * face (text property): Special Properties. (line 22) * face alias: Face Functions. (line 47) * face attributes: Face Attributes. (line 6) * face codes of text: Special Properties. (line 22) * face id: Faces. (line 13) * face-all-attributes: Attribute Functions. (line 79) * face-attribute: Attribute Functions. (line 35) * face-attribute-relative-p: Attribute Functions. (line 64) * face-background: Attribute Functions. (line 135) * face-bold-p: Attribute Functions. (line 160) * face-differs-from-default-p: Face Functions. (line 44) * face-documentation <1>: Face Functions. (line 36) * face-documentation: Accessing Documentation. (line 48) * face-equal: Face Functions. (line 40) * face-font: Attribute Functions. (line 157) * face-font-family-alternatives: Font Selection. (line 17) * face-font-registry-alternatives: Font Selection. (line 55) * face-font-rescale-alist: Font Selection. (line 82) * face-font-selection-order: Font Selection. (line 28) * face-foreground: Attribute Functions. (line 134) * face-id: Face Functions. (line 31) * face-inverse-video-p: Attribute Functions. (line 172) * face-italic-p: Attribute Functions. (line 165) * face-list: Face Functions. (line 14) * face-remap-add-relative: Face Remapping. (line 76) * face-remap-remove-relative: Face Remapping. (line 91) * face-remap-reset-base: Face Remapping. (line 104) * face-remap-set-base: Face Remapping. (line 96) * face-remapping-alist: Face Remapping. (line 12) * face-stipple: Attribute Functions. (line 146) * face-underline-p: Attribute Functions. (line 169) * facemenu-background-menu: Standard Keymaps. (line 69) * facemenu-face-menu: Standard Keymaps. (line 73) * facemenu-foreground-menu: Standard Keymaps. (line 77) * facemenu-indentation-menu: Standard Keymaps. (line 81) * facemenu-justification-menu: Standard Keymaps. (line 85) * facemenu-keymap: Prefix Keys. (line 47) * facemenu-menu: Standard Keymaps. (line 66) * facemenu-special-menu: Standard Keymaps. (line 89) * facep: Faces. (line 18) * faces: Faces. (line 6) * faces for font lock: Faces for Font Lock. (line 6) * faces, automatic choice: Auto Faces. (line 6) * false: nil and t. (line 6) * fboundp: Function Cells. (line 46) * fceiling: Rounding Operations. (line 17) * FEATURE-unload-function: Unloading. (line 31) * featurep: Named Features. (line 124) * features: Named Features. (line 6) * fetch-bytecode: Dynamic Loading. (line 50) * ffloor: Rounding Operations. (line 13) * field (text property): Special Properties. (line 167) * field width: Formatting Strings. (line 124) * field-beginning: Fields. (line 37) * field-end: Fields. (line 48) * field-string: Fields. (line 59) * field-string-no-properties: Fields. (line 63) * fields: Fields. (line 6) * fifo data structure: Rings. (line 64) * file accessibility: Testing Accessibility. (line 6) * file age: Testing Accessibility. (line 96) * file attributes: File Attributes. (line 13) * file contents, and default coding system: Default Coding Systems. (line 17) * file format conversion: Format Conversion. (line 6) * file hard link: Changing Files. (line 28) * file local variables: File Local Variables. (line 6) * file locks: File Locks. (line 6) * file mode specification error: Auto Major Mode. (line 45) * file modes and MS-DOS: File Attributes. (line 184) * file modification time: Testing Accessibility. (line 96) * file name completion subroutines: File Name Completion. (line 6) * file name of buffer: Buffer File Name. (line 6) * file name of directory: Directory Names. (line 6) * file name, and default coding system: Default Coding Systems. (line 27) * file names: File Names. (line 6) * file names in directory: Contents of Directories. (line 6) * file open error: Subroutines of Visiting. (line 37) * file symbolic links: Kinds of Files. (line 10) * file types on MS-DOS and Windows: MS-DOS File Types. (line 6) * file with multiple names: Changing Files. (line 28) * file, information about: Information about Files. (line 6) * file-accessible-directory-p: Testing Accessibility. (line 65) * file-already-exists: Changing Files. (line 103) * file-attributes: File Attributes. (line 64) * file-chase-links: Truenames. (line 33) * file-coding-system-alist: Default Coding Systems. (line 28) * file-directory-p: Kinds of Files. (line 33) * file-error: How Programs Do Loading. (line 76) * file-executable-p: Testing Accessibility. (line 40) * file-exists-p: Testing Accessibility. (line 12) * file-expand-wildcards: Contents of Directories. (line 56) * file-local-copy: Magic File Names. (line 157) * file-local-variables-alist: File Local Variables. (line 64) * file-locked: File Locks. (line 62) * file-locked-p: File Locks. (line 24) * file-modes: File Attributes. (line 13) * file-modes-symbolic-to-number: Changing Files. (line 182) * file-name-absolute-p: Relative File Names. (line 17) * file-name-all-completions: File Name Completion. (line 10) * file-name-as-directory: Directory Names. (line 26) * file-name-buffer-file-type-alist: MS-DOS File Types. (line 36) * file-name-coding-system: Encoding and I/O. (line 61) * file-name-completion: File Name Completion. (line 34) * file-name-directory: File Name Components. (line 22) * file-name-extension: File Name Components. (line 61) * file-name-handler-alist: Magic File Names. (line 16) * file-name-history: Minibuffer History. (line 100) * file-name-nondirectory: File Name Components. (line 35) * file-name-sans-extension: File Name Components. (line 78) * file-name-sans-versions: File Name Components. (line 46) * file-newer-than-file-p: Testing Accessibility. (line 96) * file-newest-backup: Backup Names. (line 85) * file-nlinks: File Attributes. (line 48) * file-ownership-preserved-p: Testing Accessibility. (line 86) * file-precious-flag: Saving Buffers. (line 137) * file-readable-p: Testing Accessibility. (line 29) * file-regular-p: Kinds of Files. (line 49) * file-relative-name: Relative File Names. (line 32) * file-remote-p: Magic File Names. (line 169) * file-supersession: Modification Time. (line 84) * file-symlink-p: Kinds of Files. (line 10) * file-truename: Truenames. (line 15) * file-writable-p: Testing Accessibility. (line 47) * fill-column: Margins. (line 20) * fill-context-prefix: Adaptive Fill. (line 17) * fill-forward-paragraph-function: Filling. (line 161) * fill-individual-paragraphs: Filling. (line 59) * fill-individual-varying-indent: Filling. (line 81) * fill-nobreak-predicate: Margins. (line 85) * fill-paragraph: Filling. (line 34) * fill-paragraph-function: Filling. (line 147) * fill-prefix: Margins. (line 7) * fill-region: Filling. (line 46) * fill-region-as-paragraph: Filling. (line 86) * fillarray: Array Functions. (line 56) * filling text: Filling. (line 6) * filling, automatic: Auto Filling. (line 6) * filter function: Filter Functions. (line 6) * filter multibyte flag, of process: Decoding Output. (line 30) * filter-buffer-substring: Buffer Contents. (line 49) * find file in path: Locating Files. (line 6) * find library: Library Search. (line 6) * find-auto-coding: Default Coding Systems. (line 113) * find-backup-file-name: Backup Names. (line 65) * find-buffer-visiting: Buffer File Name. (line 74) * find-charset-region: Scanning Charsets. (line 19) * find-charset-string: Scanning Charsets. (line 30) * find-coding-systems-for-charsets: Lisp and Coding Systems. (line 81) * find-coding-systems-region: Lisp and Coding Systems. (line 65) * find-coding-systems-string: Lisp and Coding Systems. (line 74) * find-file: Visiting Functions. (line 18) * find-file-hook: Visiting Functions. (line 116) * find-file-name-handler: Magic File Names. (line 149) * find-file-noselect: Visiting Functions. (line 38) * find-file-not-found-functions: Visiting Functions. (line 125) * find-file-other-window: Visiting Functions. (line 85) * find-file-read-only: Visiting Functions. (line 92) * find-file-wildcards: Visiting Functions. (line 108) * find-font: Low-Level Font. (line 97) * find-image: Defining Images. (line 54) * find-operation-coding-system: Default Coding Systems. (line 142) * finding files: Visiting Files. (line 6) * finding windows: Selecting Windows. (line 54) * first-change-hook: Change Hooks. (line 62) * fit-window-to-buffer: Resizing Windows. (line 76) * fixed-size window: Resizing Windows. (line 105) * fixup-whitespace: User-Level Deletion. (line 69) * flags in format specifications: Formatting Strings. (line 149) * float: Numeric Conversions. (line 9) * float-output-format: Output Variables. (line 116) * float-time: Time of Day. (line 72) * floating-point functions: Math Functions. (line 6) * floatp: Predicates on Numbers. (line 14) * floats-consed: Memory Usage. (line 18) * floor: Numeric Conversions. (line 35) * flowcontrol, in serial connections: Serial Ports. (line 119) * flushing input: Event Input Misc. (line 98) * fmakunbound: Function Cells. (line 51) * fn in function's documentation string: Autoload. (line 137) * focus event: Focus Events. (line 6) * focus-follows-mouse: Input Focus. (line 116) * follow links: Clickable Text. (line 6) * follow-link (button property): Button Properties. (line 47) * following-char: Near Point. (line 34) * font lock faces: Faces for Font Lock. (line 6) * Font Lock mode: Font Lock Mode. (line 6) * font-at: Low-Level Font. (line 25) * font-face-attributes: Low-Level Font. (line 133) * font-family-list: Face Attributes. (line 183) * font-get: Low-Level Font. (line 124) * font-list-limit: Font Lookup. (line 55) * font-lock-add-keywords: Customizing Keywords. (line 11) * font-lock-beginning-of-syntax-function: Syntactic Font Lock. (line 27) * font-lock-builtin-face: Faces for Font Lock. (line 31) * font-lock-comment-delimiter-face: Faces for Font Lock. (line 18) * font-lock-comment-face: Faces for Font Lock. (line 15) * font-lock-constant-face: Faces for Font Lock. (line 46) * font-lock-defaults: Font Lock Basics. (line 13) * font-lock-doc-face: Faces for Font Lock. (line 21) * font-lock-extend-after-change-region-function: Region to Fontify. (line 16) * font-lock-extra-managed-props: Other Font Lock Variables. (line 23) * font-lock-face (text property): Special Properties. (line 51) * font-lock-fontify-buffer-function: Other Font Lock Variables. (line 32) * font-lock-fontify-region-function: Other Font Lock Variables. (line 41) * font-lock-function-name-face: Faces for Font Lock. (line 34) * font-lock-keyword-face: Faces for Font Lock. (line 27) * font-lock-keywords: Search-based Fontification. (line 12) * font-lock-keywords-case-fold-search: Search-based Fontification. (line 203) * font-lock-keywords-only: Syntactic Font Lock. (line 15) * font-lock-mark-block-function: Other Font Lock Variables. (line 11) * font-lock-multiline: Font Lock Multiline. (line 23) * font-lock-negation-char-face: Faces for Font Lock. (line 52) * font-lock-preprocessor-face: Faces for Font Lock. (line 49) * font-lock-remove-keywords: Customizing Keywords. (line 43) * font-lock-string-face: Faces for Font Lock. (line 24) * font-lock-syntactic-face-function: Syntactic Font Lock. (line 46) * font-lock-syntactic-keywords: Setting Syntax Properties. (line 11) * font-lock-syntax-table: Syntactic Font Lock. (line 21) * font-lock-type-face: Faces for Font Lock. (line 42) * font-lock-unfontify-buffer-function: Other Font Lock Variables. (line 36) * font-lock-unfontify-region-function: Other Font Lock Variables. (line 48) * font-lock-variable-name-face: Faces for Font Lock. (line 38) * font-lock-warning-face: Faces for Font Lock. (line 55) * font-put: Low-Level Font. (line 88) * font-spec: Low-Level Font. (line 37) * font-xlfd-name: Low-Level Font. (line 146) * fontification-functions: Auto Faces. (line 11) * fontified (text property): Special Properties. (line 66) * fontp: Low-Level Font. (line 13) * foo: A Sample Function Description. (line 25) * for: Argument Evaluation. (line 12) * force-mode-line-update: Mode Line Basics. (line 24) * force-window-update: Forcing Redisplay. (line 30) * forcing redisplay: Forcing Redisplay. (line 6) * form: Intro Eval. (line 12) * format: Formatting Strings. (line 17) * format definition: Format Conversion Round-Trip. (line 19) * format of keymaps: Format of Keymaps. (line 6) * format specification: Formatting Strings. (line 26) * format, customization keyword: Type Keywords. (line 23) * format-alist: Format Conversion Round-Trip. (line 14) * format-find-file: Format Conversion Round-Trip. (line 126) * format-insert-file: Format Conversion Round-Trip. (line 135) * format-mode-line: Emulating Mode Line. (line 11) * format-network-address: Misc Network. (line 37) * format-seconds: Time Parsing. (line 165) * format-time-string: Time Parsing. (line 14) * format-write-file: Format Conversion Round-Trip. (line 113) * formatting strings: Formatting Strings. (line 6) * formfeed: Basic Char Syntax. (line 27) * forward advice: Defining Advice. (line 80) * forward-button: Button Buffer Commands. (line 34) * forward-char: Character Motion. (line 27) * forward-comment: Motion via Parsing. (line 42) * forward-line: Text Lines. (line 54) * forward-list: List Motion. (line 15) * forward-sexp: List Motion. (line 35) * forward-to-indentation: Motion by Indent. (line 20) * forward-word: Word Motion. (line 10) * frame: Frames. (line 6) * frame configuration: Frame Configurations. (line 6) * frame parameters: Frame Parameters. (line 6) * frame size: Size and Position. (line 6) * frame title: Frame Titles. (line 6) * frame visibility: Visibility of Frames. (line 6) * frame-alpha-lower-limit: Font and Color Parameters. (line 53) * frame-background-mode: Defining Faces. (line 128) * frame-char-height: Size and Position. (line 52) * frame-char-width: Size and Position. (line 53) * frame-current-scroll-bars: Scroll Bars. (line 13) * frame-first-window: Frames and Windows. (line 20) * frame-height: Size and Position. (line 29) * frame-inherited-parameters: Creating Frames. (line 44) * frame-list: Finding All Frames. (line 7) * frame-live-p: Deleting Frames. (line 22) * frame-local variables: Frame-Local Variables. (line 6) * frame-parameter: Parameter Access. (line 9) * frame-parameters: Parameter Access. (line 15) * frame-pixel-height: Size and Position. (line 35) * frame-pixel-width: Size and Position. (line 36) * frame-selected-window: Frames and Windows. (line 30) * frame-terminal: Frames. (line 61) * frame-title-format: Frame Titles. (line 17) * frame-visible-p: Visibility of Frames. (line 35) * frame-width: Size and Position. (line 30) * framep: Frames. (line 40) * frames, scanning all: Finding All Frames. (line 6) * free list: Garbage Collection. (line 35) * frequency counts: Coverage Testing. (line 6) * fringe bitmaps: Fringe Bitmaps. (line 6) * fringe cursors: Fringe Cursors. (line 6) * fringe indicators: Fringe Indicators. (line 6) * fringe-bitmaps-at-pos: Fringe Bitmaps. (line 24) * fringe-cursor-alist: Fringe Cursors. (line 24) * fringe-indicator-alist: Fringe Indicators. (line 55) * fringes: Fringes. (line 6) * fringes, and empty line indication: Fringe Indicators. (line 11) * fringes-outside-margins: Fringe Size/Pos. (line 10) * fround: Rounding Operations. (line 25) * fset: Function Cells. (line 66) * ftp-login: Cleanups. (line 57) * ftruncate: Rounding Operations. (line 21) * full keymap: Format of Keymaps. (line 6) * funcall: Calling Functions. (line 23) * funcall, and debugging: Internals of Debugger. (line 62) * function <1>: Anonymous Functions. (line 71) * function: What Is a Function. (line 16) * function aliases: Defining Functions. (line 61) * function call: Function Forms. (line 6) * function call debugging: Function Debugging. (line 6) * function cell: Symbol Components. (line 21) * function cell in autoload: Autoload. (line 62) * function declaration: Declaring Functions. (line 6) * function definition: Function Names. (line 6) * function descriptions: A Sample Function Description. (line 6) * function form evaluation: Function Forms. (line 6) * function input stream: Input Streams. (line 27) * function invocation: Calling Functions. (line 6) * function keys: Function Keys. (line 6) * function name: Function Names. (line 6) * function output stream: Output Streams. (line 24) * function quoting: Anonymous Functions. (line 75) * function safety: Function Safety. (line 6) * function-documentation: Documentation Basics. (line 35) * functionals: Calling Functions. (line 103) * functionp: What Is a Function. (line 80) * functions in modes: Major Mode Conventions. (line 49) * functions, making them interactive: Defining Commands. (line 6) * Fundamental mode: Major Mode Basics. (line 6) * fundamental-mode: Auto Major Mode. (line 11) * fundamental-mode-abbrev-table: Standard Abbrev Tables. (line 28) * fundamental-mode-map: Standard Keymaps. (line 98) * gamma correction: Font and Color Parameters. (line 35) * gap-position: Buffer Gap. (line 20) * gap-size: Buffer Gap. (line 24) * garbage collection: Garbage Collection. (line 6) * garbage collection protection: Writing Emacs Primitives. (line 15) * garbage-collect: Garbage Collection. (line 54) * garbage-collection-messages: Garbage Collection. (line 143) * gc-cons-percentage: Garbage Collection. (line 174) * gc-cons-threshold: Garbage Collection. (line 153) * gc-elapsed: Garbage Collection. (line 211) * GCPRO and UNGCPRO: Writing Emacs Primitives. (line 116) * gcs-done: Garbage Collection. (line 207) * generate-autoload-cookie: Autoload. (line 161) * generate-new-buffer: Creating Buffers. (line 37) * generate-new-buffer-name: Buffer Names. (line 67) * generated-autoload-file: Autoload. (line 167) * generic comment delimiter: Syntax Class Table. (line 132) * generic string delimiter: Syntax Class Table. (line 145) * generic mode: Generic Modes. (line 6) * geometry specification: Geometry. (line 10) * get: Symbol Plists. (line 25) * get, defcustom keyword: Variable Definitions. (line 77) * get-buffer: Buffer Names. (line 50) * get-buffer-create: Creating Buffers. (line 17) * get-buffer-process: Process Buffers. (line 59) * get-buffer-window: Buffers and Windows. (line 53) * get-buffer-window-list: Buffers and Windows. (line 81) * get-byte: Character Codes. (line 42) * get-char-code-property: Character Properties. (line 109) * get-char-property: Examining Properties. (line 26) * get-char-property-and-overlay: Examining Properties. (line 39) * get-charset-property: Character Sets. (line 60) * get-device-terminal: Multiple Terminals. (line 39) * get-file-buffer: Buffer File Name. (line 58) * get-file-char: Input Streams. (line 139) * get-internal-run-time: Processor Run Time. (line 20) * get-largest-window: Selecting Windows. (line 81) * get-load-suffixes: Load Suffixes. (line 33) * get-lru-window: Selecting Windows. (line 58) * get-process: Process Information. (line 25) * get-register: Registers. (line 58) * get-text-property: Examining Properties. (line 17) * get-unused-category: Categories. (line 46) * get-window-with-predicate: Selecting Windows. (line 97) * getenv: System Environment. (line 94) * gethash: Hash Access. (line 12) * GIF: GIF Images. (line 6) * global binding: Local Variables. (line 6) * global break condition: Global Break Condition. (line 6) * global keymap: Active Keymaps. (line 6) * global variable: Global Variables. (line 6) * global-abbrev-table: Standard Abbrev Tables. (line 10) * global-disable-point-adjustment: Adjusting Point. (line 25) * global-key-binding: Functions for Key Lookup. (line 61) * global-map: Controlling Active Maps. (line 7) * global-mode-string: Mode Line Variables. (line 96) * global-set-key: Key Binding Commands. (line 52) * global-unset-key: Key Binding Commands. (line 60) * glyph: Glyphs. (line 6) * glyph-char: Glyphs. (line 22) * glyph-face: Glyphs. (line 25) * glyph-table: Glyphs. (line 32) * goto-char: Character Motion. (line 10) * goto-map: Prefix Keys. (line 43) * grep-mode-map: Standard Keymaps. (line 106) * group, customization keyword: Common Keywords. (line 21) * hack-dir-local-variables: Directory Local Variables. (line 29) * hack-local-variables: File Local Variables. (line 45) * hack-local-variables-hook: File Local Variables. (line 76) * handle-shift-selection: The Mark. (line 186) * handle-switch-frame: Input Focus. (line 79) * handling errors: Handling Errors. (line 6) * hash code: Defining Hash. (line 6) * hash notation: Printed Representation. (line 13) * hash tables: Hash Tables. (line 6) * hash-table-count: Other Hash. (line 16) * hash-table-p: Other Hash. (line 9) * hash-table-rehash-size: Other Hash. (line 28) * hash-table-rehash-threshold: Other Hash. (line 31) * hash-table-size: Other Hash. (line 34) * hash-table-test: Other Hash. (line 19) * hash-table-weakness: Other Hash. (line 24) * hashing: Creating Symbols. (line 11) * header comments: Library Headers. (line 6) * header line (of a window): Header Lines. (line 6) * header-line prefix key: Key Sequence Input. (line 92) * header-line-format: Header Lines. (line 11) * help for major mode: Mode Help. (line 6) * help-buffer: Help Functions. (line 125) * help-char: Help Functions. (line 52) * help-command: Help Functions. (line 44) * help-echo (overlay property): Overlay Properties. (line 108) * help-echo (text property): Special Properties. (line 79) * help-echo event: Misc Events. (line 56) * help-echo, customization keyword: Type Keywords. (line 96) * help-event-list: Help Functions. (line 70) * help-form: Help Functions. (line 75) * help-index (button property): Button Properties. (line 43) * help-map: Help Functions. (line 40) * help-mode-map: Standard Keymaps. (line 113) * help-setup-xref: Help Functions. (line 139) * Helper-describe-bindings: Help Functions. (line 108) * Helper-help: Help Functions. (line 113) * Helper-help-map: Standard Keymaps. (line 116) * hex numbers: Integer Basics. (line 22) * hidden buffers: Buffer Names. (line 12) * history list: Minibuffer History. (line 6) * history of commands: Command History. (line 6) * history-add-new-input: Minibuffer History. (line 72) * history-delete-duplicates: Minibuffer History. (line 87) * history-length: Minibuffer History. (line 79) * HOME environment variable: Subprocess Creation. (line 17) * hook variables, list of: Standard Hooks. (line 6) * hooks: Hooks. (line 6) * hooks for changing a character: Special Properties. (line 229) * hooks for loading: Hooks for Loading. (line 6) * hooks for motion of point: Special Properties. (line 259) * hooks for text changes: Change Hooks. (line 6) * hooks for window operations: Window Hooks. (line 6) * horizontal position: Columns. (line 6) * horizontal scrolling: Horizontal Scrolling. (line 6) * horizontal-scroll-bar prefix key: Key Sequence Input. (line 92) * hyper characters: Other Char Bits. (line 16) * hyperlinks in documentation strings: Documentation Tips. (line 103) * icon-title-format: Frame Titles. (line 24) * iconified frame: Visibility of Frames. (line 6) * iconify-frame: Visibility of Frames. (line 31) * iconify-frame event: Misc Events. (line 16) * identity: Calling Functions. (line 113) * idleness: Idle Timers. (line 24) * IEEE floating point: Float Basics. (line 18) * if: Conditionals. (line 12) * ignore: Calling Functions. (line 116) * ignore-errors: Handling Errors. (line 193) * ignored-local-variables: File Local Variables. (line 124) * image cache: Image Cache. (line 6) * image descriptor: Image Descriptors. (line 6) * image formats: Image Formats. (line 6) * image types: Image Formats. (line 6) * image-cache-eviction-delay: Image Cache. (line 45) * image-library-alist: Image Formats. (line 34) * image-load-path: Defining Images. (line 70) * image-load-path-for-library: Defining Images. (line 90) * image-mask-p: Image Descriptors. (line 160) * image-refresh: Image Cache. (line 27) * image-size: Showing Images. (line 68) * image-type-available-p: Image Formats. (line 51) * image-types: Image Formats. (line 24) * images in buffers: Images. (line 6) * Imenu: Imenu. (line 6) * imenu-add-to-menubar: Imenu. (line 15) * imenu-case-fold-search: Imenu. (line 70) * imenu-create-index-function: Imenu. (line 130) * imenu-extract-index-name-function: Imenu. (line 119) * imenu-generic-expression: Imenu. (line 27) * imenu-prev-index-position-function: Imenu. (line 109) * imenu-syntax-alist: Imenu. (line 78) * implicit progn: Sequencing. (line 21) * inc: Simple Macro. (line 11) * indent-according-to-mode: Mode-Specific Indent. (line 21) * indent-code-rigidly: Region Indent. (line 61) * indent-for-tab-command: Mode-Specific Indent. (line 26) * indent-line-function: Mode-Specific Indent. (line 12) * indent-region: Region Indent. (line 10) * indent-region-function: Region Indent. (line 24) * indent-relative: Relative Indent. (line 10) * indent-relative-maybe: Relative Indent. (line 51) * indent-rigidly: Region Indent. (line 45) * indent-tabs-mode: Primitive Indent. (line 29) * indent-to: Primitive Indent. (line 17) * indent-to-left-margin: Margins. (line 73) * indentation: Indentation. (line 6) * indicate-buffer-boundaries: Fringe Indicators. (line 17) * indicate-empty-lines: Fringe Indicators. (line 11) * indicators, fringe: Fringe Indicators. (line 6) * indirect buffers: Indirect Buffers. (line 6) * indirect specifications: Specification List. (line 109) * indirect-function: Function Indirection. (line 61) * indirect-variable: Variable Aliases. (line 59) * indirection for functions: Function Indirection. (line 6) * infinite loops: Infinite Loops. (line 6) * infinite recursion: Local Variables. (line 104) * infinity: Float Basics. (line 18) * Info-edit-map: Standard Keymaps. (line 120) * Info-mode-map: Standard Keymaps. (line 123) * inherit standard syntax: Syntax Class Table. (line 127) * inheritance of text properties: Sticky Properties. (line 6) * inheriting a keymap's bindings: Inheritance and Keymaps. (line 6) * inhibit-default-init: Init File. (line 48) * inhibit-eol-conversion: Specifying Coding Systems. (line 45) * inhibit-field-text-motion: Word Motion. (line 43) * inhibit-file-name-handlers: Magic File Names. (line 142) * inhibit-file-name-operation: Magic File Names. (line 146) * inhibit-iso-escape-detection: Lisp and Coding Systems. (line 129) * inhibit-modification-hooks: Change Hooks. (line 66) * inhibit-null-byte-detection: Lisp and Coding Systems. (line 123) * inhibit-point-motion-hooks: Special Properties. (line 284) * inhibit-quit: Quitting. (line 80) * inhibit-read-only: Read Only Buffers. (line 32) * inhibit-splash-screen: Startup Summary. (line 118) * inhibit-startup-echo-area-message: Startup Summary. (line 129) * inhibit-startup-message: Startup Summary. (line 118) * inhibit-startup-screen: Startup Summary. (line 109) * inhibit-x-resources: Resources. (line 52) * init file: Init File. (line 6) * init-file-user: User Identification. (line 7) * initial-buffer-choice: Startup Summary. (line 122) * initial-environment: System Environment. (line 145) * initial-frame-alist: Initial Parameters. (line 10) * initial-major-mode: Auto Major Mode. (line 92) * initial-scratch-message: Startup Summary. (line 145) * initial-window-system: Window Systems. (line 33) * initial-window-system, and startup: Startup Summary. (line 20) * initialization of Emacs: Startup Summary. (line 6) * initialize, defcustom keyword: Variable Definitions. (line 90) * inline functions: Inline Functions. (line 6) * innermost containing parentheses: Parser State. (line 17) * input events: Input Events. (line 6) * input focus: Input Focus. (line 6) * input methods: Input Methods. (line 6) * input modes: Input Modes. (line 6) * input stream: Input Streams. (line 6) * input-decode-map: Translation Keymaps. (line 13) * input-method-alist: Input Methods. (line 44) * input-method-function: Invoking the Input Method. (line 13) * input-pending-p: Event Input Misc. (line 53) * insert: Insertion. (line 37) * insert-abbrev-table-description: Abbrev Tables. (line 52) * insert-and-inherit: Sticky Properties. (line 72) * insert-before-markers: Insertion. (line 43) * insert-before-markers-and-inherit: Sticky Properties. (line 76) * insert-behind-hooks (overlay property): Overlay Properties. (line 149) * insert-behind-hooks (text property): Special Properties. (line 247) * insert-buffer: Commands for Insertion. (line 11) * insert-buffer-substring: Insertion. (line 70) * insert-buffer-substring-as-yank: Yanking. (line 19) * insert-buffer-substring-no-properties: Insertion. (line 92) * insert-button: Making Buttons. (line 36) * insert-char: Insertion. (line 56) * insert-default-directory: Reading File Names. (line 130) * insert-directory: Contents of Directories. (line 69) * insert-directory-program: Contents of Directories. (line 100) * insert-file-contents: Reading from Files. (line 12) * insert-file-contents-literally: Reading from Files. (line 56) * insert-for-yank: Yanking. (line 12) * insert-image: Showing Images. (line 10) * insert-in-front-hooks (overlay property): Overlay Properties. (line 143) * insert-in-front-hooks (text property): Special Properties. (line 247) * insert-register: Registers. (line 70) * insert-sliced-image: Showing Images. (line 35) * insert-text-button: Making Buttons. (line 51) * inserting killed text: Yank Commands. (line 12) * insertion before point: Insertion. (line 6) * insertion of text: Insertion. (line 6) * insertion type of a marker: Marker Insertion Types. (line 6) * inside comment: Parser State. (line 27) * inside string: Parser State. (line 23) * installation-directory: System Environment. (line 177) * int-to-string: String Conversion. (line 55) * intangible (overlay property): Overlay Properties. (line 160) * intangible (text property): Special Properties. (line 153) * integer to decimal: String Conversion. (line 43) * integer to hexadecimal: Formatting Strings. (line 83) * integer to octal: Formatting Strings. (line 74) * integer to string: String Conversion. (line 43) * integer-or-marker-p: Predicates on Markers. (line 16) * integerp: Predicates on Numbers. (line 20) * integers: Numbers. (line 6) * integers in specific radix: Integer Basics. (line 22) * interactive: Using Interactive. (line 11) * interactive call: Interactive Call. (line 6) * interactive code description: Interactive Codes. (line 6) * interactive completion: Interactive Codes. (line 10) * interactive function: Defining Commands. (line 6) * interactive, examples of using: Interactive Examples. (line 6) * interactive-form: Using Interactive. (line 132) * interactive-form, function property: Using Interactive. (line 21) * intern: Creating Symbols. (line 96) * intern-soft: Creating Symbols. (line 116) * internal representation of characters: Text Representations. (line 20) * internals, of buffer: Buffer Internals. (line 6) * internals, of process: Process Internals. (line 6) * internals, of window: Window Internals. (line 6) * interning: Creating Symbols. (line 23) * interpreter: Evaluation. (line 6) * interpreter-mode-alist: Auto Major Mode. (line 97) * interprogram-cut-function: Low-Level Kill Ring. (line 87) * interprogram-paste-function: Low-Level Kill Ring. (line 62) * interrupt Lisp functions: Quitting. (line 6) * interrupt-process: Signals to Processes. (line 49) * intervals: Not Intervals. (line 6) * intervals-consed: Memory Usage. (line 39) * invalid prefix key error: Changing Key Bindings. (line 57) * invalid-function: Function Indirection. (line 20) * invalid-read-syntax: Printed Representation. (line 25) * invalid-regexp: Regexp Backslash. (line 200) * invert-face: Attribute Functions. (line 125) * invisible (overlay property): Overlay Properties. (line 155) * invisible (text property): Special Properties. (line 149) * invisible frame: Visibility of Frames. (line 6) * invisible text: Invisible Text. (line 6) * invisible-p: Invisible Text. (line 92) * invisible/intangible text, and point: Adjusting Point. (line 6) * invocation-directory: System Environment. (line 172) * invocation-name: System Environment. (line 167) * isearch-mode-map: Standard Keymaps. (line 131) * iteration: Iteration. (line 6) * jit-lock-register: Other Font Lock Variables. (line 53) * jit-lock-unregister: Other Font Lock Variables. (line 65) * joining lists: Rearrangement. (line 16) * just-one-space: User-Level Deletion. (line 99) * justify-current-line: Filling. (line 100) * kbd: Key Sequences. (line 35) * kbd-macro-termination-hook: Keyboard Macros. (line 63) * kept-new-versions: Numbered Backups. (line 29) * kept-old-versions: Numbered Backups. (line 34) * key: Key Sequences. (line 6) * key binding: Keymap Basics. (line 6) * key binding, conventions for: Key Binding Conventions. (line 6) * key lookup: Key Lookup. (line 6) * key sequence: Key Sequences. (line 6) * key sequence error: Changing Key Bindings. (line 57) * key sequence input: Key Sequence Input. (line 6) * key translation function: Translation Keymaps. (line 75) * key-binding: Active Keymaps. (line 82) * key-description: Describing Characters. (line 14) * key-translation-map: Translation Keymaps. (line 56) * keyboard events: Keyboard Events. (line 6) * keyboard events in strings: Strings of Events. (line 6) * keyboard input: Reading Input. (line 6) * keyboard input decoding on X: Locales. (line 11) * keyboard macro execution: Interactive Call. (line 58) * keyboard macro termination: Beeping. (line 13) * keyboard macro, terminating: Event Input Misc. (line 98) * keyboard macros: Keyboard Macros. (line 6) * keyboard macros (Edebug): Edebug Execution Modes. (line 69) * keyboard-coding-system: Terminal I/O Encoding. (line 12) * keyboard-quit: Quitting. (line 106) * keyboard-translate: Event Mod. (line 55) * keyboard-translate-table: Event Mod. (line 33) * keymap: Keymaps. (line 6) * keymap (button property): Button Properties. (line 32) * keymap (overlay property): Overlay Properties. (line 205) * keymap (text property): Special Properties. (line 109) * keymap entry: Key Lookup. (line 6) * keymap format: Format of Keymaps. (line 6) * keymap in keymap: Key Lookup. (line 52) * keymap inheritance: Inheritance and Keymaps. (line 6) * keymap of character: Special Properties. (line 109) * keymap of character (and overlays): Overlay Properties. (line 199) * keymap prompt string: Format of Keymaps. (line 50) * keymap-parent: Inheritance and Keymaps. (line 28) * keymap-prompt: Defining Menus. (line 21) * keymapp: Format of Keymaps. (line 98) * keymaps for translating events: Translation Keymaps. (line 6) * keymaps in modes: Major Mode Conventions. (line 61) * keys in documentation strings: Keys in Documentation. (line 6) * keys, reserved: Key Binding Conventions. (line 14) * keystroke: Key Sequences. (line 6) * keystroke command: What Is a Function. (line 69) * keyword symbol: Constant Variables. (line 6) * keywordp: Constant Variables. (line 20) * kill command repetition: Command Loop Info. (line 43) * kill ring: The Kill Ring. (line 6) * kill-all-local-variables: Creating Buffer-Local. (line 139) * kill-append: Low-Level Kill Ring. (line 50) * kill-buffer: Killing Buffers. (line 33) * kill-buffer-hook: Killing Buffers. (line 76) * kill-buffer-query-functions: Killing Buffers. (line 68) * kill-emacs: Killing Emacs. (line 11) * kill-emacs-hook: Killing Emacs. (line 39) * kill-emacs-query-functions: Killing Emacs. (line 30) * kill-local-variable: Creating Buffer-Local. (line 119) * kill-new: Low-Level Kill Ring. (line 34) * kill-process: Signals to Processes. (line 57) * kill-read-only-ok: Kill Functions. (line 34) * kill-region: Kill Functions. (line 15) * kill-ring: Internals of Kill Ring. (line 52) * kill-ring-max: Internals of Kill Ring. (line 62) * kill-ring-yank-pointer: Internals of Kill Ring. (line 56) * killing buffers: Killing Buffers. (line 6) * killing Emacs: Killing Emacs. (line 6) * kmacro-map: Standard Keymaps. (line 140) * lambda expression: Lambda Expressions. (line 6) * lambda in debug: Invoking the Debugger. (line 33) * lambda in keymap: Key Lookup. (line 61) * lambda list: Lambda Components. (line 14) * lambda-list (Edebug): Specification List. (line 177) * last: List Elements. (line 111) * last-abbrev: Abbrev Expansion. (line 76) * last-abbrev-location: Abbrev Expansion. (line 82) * last-abbrev-text: Abbrev Expansion. (line 87) * last-buffer: The Buffer List. (line 93) * last-coding-system-used: Encoding and I/O. (line 48) * last-command: Command Loop Info. (line 12) * last-command-char: Command Loop Info. (line 112) * last-command-event: Command Loop Info. (line 111) * last-event-frame: Command Loop Info. (line 126) * last-input-char: Event Input Misc. (line 60) * last-input-event: Event Input Misc. (line 59) * last-kbd-macro: Keyboard Macros. (line 56) * last-nonmenu-event: Command Loop Info. (line 103) * last-prefix-arg: Prefix Command Arguments. (line 98) * last-repeatable-command: Command Loop Info. (line 29) * lax-plist-get: Other Plists. (line 44) * lax-plist-put: Other Plists. (line 48) * lazy loading: Dynamic Loading. (line 6) * lazy-completion-table: Basic Completion. (line 170) * left-fringe-width: Fringe Size/Pos. (line 15) * left-margin: Margins. (line 80) * left-margin-width: Display Margins. (line 32) * length: Sequence Functions. (line 16) * let: Local Variables. (line 52) * let*: Local Variables. (line 74) * lexical binding (Edebug): Edebug Eval. (line 26) * lexical comparison: Text Comparison. (line 52) * lexical scoping: Variable Scoping. (line 11) * library: Loading. (line 6) * library compilation: Compilation Functions. (line 112) * library header comments: Library Headers. (line 6) * library search: Library Search. (line 6) * line end conversion: Coding System Basics. (line 36) * line height: Line Height. (line 6) * line number: Text Lines. (line 87) * line truncation: Truncation. (line 6) * line wrapping: Truncation. (line 6) * line-beginning-position: Text Lines. (line 33) * line-end-position: Text Lines. (line 51) * line-height (text property) <1>: Line Height. (line 22) * line-height (text property): Special Properties. (line 200) * line-move-ignore-invisible: Invisible Text. (line 101) * line-number-at-pos: Text Lines. (line 87) * line-prefix: Truncation. (line 57) * line-spacing: Line Height. (line 77) * line-spacing (text property) <1>: Line Height. (line 83) * line-spacing (text property): Special Properties. (line 194) * lines: Text Lines. (line 6) * lines in region: Text Lines. (line 72) * link, customization keyword: Common Keywords. (line 31) * linking files: Changing Files. (line 6) * Lisp debugger: Debugger. (line 6) * Lisp expression motion: List Motion. (line 6) * Lisp history: Lisp History. (line 6) * Lisp library: Loading. (line 6) * Lisp nesting error: Eval. (line 93) * Lisp object: Lisp Data Types. (line 6) * Lisp printer: Output Functions. (line 40) * Lisp reader: Streams Intro. (line 6) * lisp-interaction-mode-map: Standard Keymaps. (line 143) * lisp-mode-abbrev-table: Standard Abbrev Tables. (line 36) * lisp-mode-map: Standard Keymaps. (line 146) * lisp-mode.el: Example Major Modes. (line 82) * list: Building Lists. (line 36) * list all coding systems: Lisp and Coding Systems. (line 8) * list elements: List Elements. (line 6) * list form evaluation: Classifying Lists. (line 6) * list in keymap: Key Lookup. (line 56) * list length: Sequence Functions. (line 16) * list motion: List Motion. (line 6) * list structure: Cons Cells. (line 46) * list-buffers-directory: Buffer File Name. (line 122) * list-charset-chars: Character Sets. (line 63) * list-fonts: Low-Level Font. (line 102) * list-processes: Process Information. (line 10) * list-system-processes: System Processes. (line 16) * listify-key-sequence: Event Input Misc. (line 41) * listp: List-related Predicates. (line 23) * lists: Lists. (line 6) * lists and cons cells: Cons Cells. (line 6) * lists as sets: Sets And Lists. (line 6) * literal evaluation: Self-Evaluating Forms. (line 6) * little endian: Bindat Spec. (line 13) * ln: Changing Files. (line 103) * load: How Programs Do Loading. (line 15) * load error with require: Named Features. (line 17) * load errors: How Programs Do Loading. (line 72) * load, customization keyword: Common Keywords. (line 89) * load-average: System Environment. (line 184) * load-file: How Programs Do Loading. (line 87) * load-file-rep-suffixes: Load Suffixes. (line 17) * load-history: Where Defined. (line 21) * load-in-progress: How Programs Do Loading. (line 100) * load-library: How Programs Do Loading. (line 95) * load-path: Library Search. (line 10) * load-read-function: How Programs Do Loading. (line 104) * load-suffixes: Load Suffixes. (line 10) * loading: Loading. (line 6) * loading hooks: Hooks for Loading. (line 6) * loadup.el: Building Emacs. (line 16) * local binding: Local Variables. (line 6) * local keymap: Active Keymaps. (line 6) * local variables: Local Variables. (line 6) * local-abbrev-table: Standard Abbrev Tables. (line 16) * local-function-key-map: Translation Keymaps. (line 42) * local-key-binding: Functions for Key Lookup. (line 54) * local-map (overlay property): Overlay Properties. (line 199) * local-map (text property): Special Properties. (line 122) * local-set-key: Key Binding Commands. (line 79) * local-unset-key: Key Binding Commands. (line 87) * local-variable-if-set-p: Creating Buffer-Local. (line 82) * local-variable-p: Creating Buffer-Local. (line 78) * locale: Locales. (line 6) * locale-coding-system: Locales. (line 11) * locale-info: Locales. (line 31) * locate file in path: Locating Files. (line 6) * locate-file: Locating Files. (line 16) * locate-library: Library Search. (line 99) * lock file: File Locks. (line 6) * lock-buffer: File Locks. (line 33) * log: Math Functions. (line 37) * log10: Math Functions. (line 42) * logand: Bitwise Operations. (line 131) * logb: Float Basics. (line 51) * logging echo-area messages: Logging Messages. (line 6) * logical arithmetic: Bitwise Operations. (line 6) * logical shift: Bitwise Operations. (line 15) * logior: Bitwise Operations. (line 169) * lognot: Bitwise Operations. (line 205) * logxor: Bitwise Operations. (line 187) * looking-at: Regexp Search. (line 114) * looking-at-p: Regexp Search. (line 164) * looking-back: Regexp Search. (line 138) * lookup tables: Hash Tables. (line 6) * lookup-key: Functions for Key Lookup. (line 9) * loops, infinite: Infinite Loops. (line 6) * lower case: Case Conversion. (line 6) * lower-frame: Raising and Lowering. (line 28) * lowering a frame: Raising and Lowering. (line 13) * lsh: Bitwise Operations. (line 15) * lwarn: Warning Basics. (line 51) * M-g: Prefix Keys. (line 43) * M-o: Prefix Keys. (line 47) * M-s: Prefix Keys. (line 45) * M-x: Interactive Call. (line 87) * Maclisp: Lisp History. (line 11) * macro: What Is a Function. (line 46) * macro argument evaluation: Argument Evaluation. (line 57) * macro call: Expansion. (line 6) * macro call evaluation: Macro Forms. (line 6) * macro compilation: Compilation Functions. (line 15) * macro descriptions: A Sample Function Description. (line 6) * macro expansion: Expansion. (line 37) * macroexpand: Expansion. (line 37) * macroexpand-all: Expansion. (line 71) * macros: Macros. (line 6) * macros, at compile time: Eval During Compile. (line 48) * magic autoload comment: Autoload. (line 93) * magic file names: Magic File Names. (line 6) * magic-fallback-mode-alist: Auto Major Mode. (line 113) * magic-mode-alist: Auto Major Mode. (line 105) * mail-host-address: System Environment. (line 86) * major mode: Major Modes. (line 6) * major mode conventions: Major Mode Conventions. (line 6) * major mode hook: Major Mode Conventions. (line 158) * major mode keymap: Active Keymaps. (line 52) * major mode, automatic selection: Auto Major Mode. (line 6) * major-mode <1>: Mode Help. (line 20) * major-mode: Auto Major Mode. (line 68) * make-abbrev-table: Abbrev Tables. (line 9) * make-auto-save-file-name: Auto-Saving. (line 55) * make-backup-file-name: Backup Names. (line 36) * make-backup-file-name-function: Making Backups. (line 91) * make-backup-files: Making Backups. (line 27) * make-bool-vector: Bool-Vectors. (line 18) * make-button: Making Buttons. (line 32) * make-byte-code: Byte-Code Objects. (line 56) * make-category-set: Categories. (line 76) * make-category-table: Categories. (line 71) * make-char-table: Char-Tables. (line 40) * make-directory: Create/Delete Dirs. (line 12) * make-display-table: Display Table Format. (line 10) * make-face: Face Functions. (line 9) * make-frame: Creating Frames. (line 9) * make-frame-invisible: Visibility of Frames. (line 24) * make-frame-on-display: Multiple Terminals. (line 100) * make-frame-visible: Visibility of Frames. (line 18) * make-frame-visible event: Misc Events. (line 23) * make-glyph-code: Glyphs. (line 18) * make-hash-table: Creating Hash. (line 9) * make-help-screen: Help Functions. (line 154) * make-indirect-buffer: Indirect Buffers. (line 32) * make-keymap: Creating Keymaps. (line 26) * make-list: Building Lists. (line 48) * make-local-variable: Creating Buffer-Local. (line 7) * make-marker: Creating Markers. (line 15) * make-network-process: Network Processes. (line 11) * make-obsolete: Obsolete Functions. (line 10) * make-obsolete-variable: Variable Aliases. (line 37) * make-overlay: Managing Overlays. (line 16) * make-progress-reporter: Progress. (line 24) * make-ring: Rings. (line 11) * make-serial-process: Serial Ports. (line 42) * make-sparse-keymap: Creating Keymaps. (line 9) * make-string: Creating Strings. (line 10) * make-symbol: Creating Symbols. (line 84) * make-symbolic-link: Changing Files. (line 103) * make-syntax-table: Syntax Table Functions. (line 10) * make-temp-file: Unique File Names. (line 15) * make-temp-name: Unique File Names. (line 59) * make-text-button: Making Buttons. (line 47) * make-translation-table: Translation of Characters. (line 19) * make-translation-table-from-alist: Translation of Characters. (line 79) * make-translation-table-from-vector: Translation of Characters. (line 65) * make-variable-buffer-local: Creating Buffer-Local. (line 47) * make-vector: Vector Functions. (line 26) * makehash: Creating Hash. (line 104) * making buttons: Making Buttons. (line 6) * makunbound: Void Variables. (line 21) * manipulating buttons: Manipulating Buttons. (line 6) * map-char-table: Char-Tables. (line 118) * map-charset-chars: Character Sets. (line 91) * map-keymap: Scanning Keymaps. (line 65) * map-y-or-n-p: Multiple Queries. (line 14) * mapatoms: Creating Symbols. (line 144) * mapc: Mapping Functions. (line 53) * mapcar: Mapping Functions. (line 20) * mapconcat: Mapping Functions. (line 58) * maphash: Hash Access. (line 37) * mapping functions: Mapping Functions. (line 6) * margins, display: Display Margins. (line 6) * mark: The Mark. (line 54) * mark excursion: Excursions. (line 20) * mark ring: The Mark. (line 6) * mark, the: The Mark. (line 6) * mark-active: The Mark. (line 172) * mark-even-if-inactive: The Mark. (line 145) * mark-marker: The Mark. (line 63) * mark-ring: The Mark. (line 202) * mark-ring-max: The Mark. (line 211) * marker argument: Interactive Codes. (line 135) * marker garbage collection: Overview of Markers. (line 31) * marker input stream: Input Streams. (line 17) * marker output stream: Output Streams. (line 15) * marker relocation: Overview of Markers. (line 24) * marker-buffer: Information from Markers. (line 14) * marker-insertion-type: Marker Insertion Types. (line 20) * marker-position: Information from Markers. (line 10) * markerp: Predicates on Markers. (line 11) * markers: Markers. (line 6) * markers as numbers: Overview of Markers. (line 38) * match data: Match Data. (line 6) * match, customization keyword: Type Keywords. (line 104) * match-alternatives, customization keyword: Composite Types. (line 203) * match-beginning: Simple Match Data. (line 56) * match-data: Entire Match Data. (line 10) * match-end: Simple Match Data. (line 68) * match-string: Simple Match Data. (line 35) * match-string-no-properties: Simple Match Data. (line 52) * match-substitute-replacement: Replacing Match. (line 65) * mathematical functions: Math Functions. (line 6) * max: Comparison of Numbers. (line 79) * max-char: Character Codes. (line 33) * max-image-size: Showing Images. (line 77) * max-lisp-eval-depth: Eval. (line 86) * max-mini-window-height: Minibuffer Misc. (line 33) * max-specpdl-size: Local Variables. (line 104) * maximum value of character codepoint: Character Codes. (line 32) * md5: MD5 Checksum. (line 14) * MD5 checksum: MD5 Checksum. (line 6) * member: Sets And Lists. (line 107) * member-ignore-case: Sets And Lists. (line 166) * membership in a list: Sets And Lists. (line 20) * memory allocation: Garbage Collection. (line 6) * memory usage: Memory Usage. (line 6) * memory-full: Garbage Collection. (line 197) * memory-limit: Garbage Collection. (line 189) * memory-use-counts: Garbage Collection. (line 201) * memq: Sets And Lists. (line 20) * memql: Sets And Lists. (line 89) * menu bar: Menu Bar. (line 6) * menu definition example: Menu Example. (line 6) * menu keymaps: Menu Keymaps. (line 6) * menu prompt string: Defining Menus. (line 6) * menu separators: Menu Separators. (line 6) * menu-bar prefix key: Key Sequence Input. (line 92) * menu-bar-edit-menu: Standard Keymaps. (line 149) * menu-bar-files-menu: Standard Keymaps. (line 152) * menu-bar-final-items: Menu Bar. (line 61) * menu-bar-help-menu: Standard Keymaps. (line 155) * menu-bar-mule-menu: Standard Keymaps. (line 158) * menu-bar-search-menu: Standard Keymaps. (line 161) * menu-bar-tools-menu: Standard Keymaps. (line 164) * menu-bar-update-hook: Menu Bar. (line 71) * menu-item: Extended Menu Items. (line 6) * menu-prompt-more-char: Keyboard Menus. (line 27) * merge-face-attribute: Attribute Functions. (line 87) * message: Displaying Messages. (line 10) * message digest computation: MD5 Checksum. (line 6) * message-box: Displaying Messages. (line 61) * message-log-max: Logging Messages. (line 11) * message-or-box: Displaying Messages. (line 48) * message-truncate-lines: Echo Area Customization. (line 34) * meta character key constants: Changing Key Bindings. (line 20) * meta character printing: Describing Characters. (line 29) * meta characters: Meta-Char Syntax. (line 6) * meta characters lookup: Format of Keymaps. (line 61) * meta-prefix-char: Functions for Key Lookup. (line 84) * min: Comparison of Numbers. (line 91) * minibuffer: Minibuffers. (line 6) * minibuffer completion: Minibuffer Completion. (line 6) * minibuffer history: Minibuffer History. (line 6) * minibuffer input: Recursive Editing. (line 25) * minibuffer window, and next-window: Cyclic Window Ordering. (line 24) * minibuffer windows: Minibuffer Windows. (line 6) * minibuffer-allow-text-properties: Text from Minibuffer. (line 132) * minibuffer-auto-raise: Raising and Lowering. (line 31) * minibuffer-complete: Completion Commands. (line 48) * minibuffer-complete-and-exit: Completion Commands. (line 51) * minibuffer-complete-word: Completion Commands. (line 41) * minibuffer-completion-confirm: Completion Commands. (line 21) * minibuffer-completion-contents: Minibuffer Contents. (line 33) * minibuffer-completion-help: Completion Commands. (line 59) * minibuffer-completion-predicate: Completion Commands. (line 16) * minibuffer-completion-table: Completion Commands. (line 10) * minibuffer-confirm-exit-commands: Completion Commands. (line 34) * minibuffer-contents: Minibuffer Contents. (line 22) * minibuffer-contents-no-properties: Minibuffer Contents. (line 28) * minibuffer-depth: Recursive Mini. (line 10) * minibuffer-exit-hook: Minibuffer Misc. (line 15) * minibuffer-frame-alist: Initial Parameters. (line 43) * minibuffer-help-form: Minibuffer Misc. (line 19) * minibuffer-history: Minibuffer History. (line 93) * minibuffer-local-completion-map: Completion Commands. (line 102) * minibuffer-local-filename-completion-map: Completion Commands. (line 143) * minibuffer-local-filename-must-match-map: Completion Commands. (line 148) * minibuffer-local-map: Text from Minibuffer. (line 142) * minibuffer-local-must-match-map: Completion Commands. (line 119) * minibuffer-local-ns-map: Text from Minibuffer. (line 190) * minibuffer-local-shell-command-map: Reading File Names. (line 186) * minibuffer-message: Minibuffer Misc. (line 38) * minibuffer-prompt: Minibuffer Contents. (line 9) * minibuffer-prompt-end: Minibuffer Contents. (line 13) * minibuffer-prompt-width: Minibuffer Contents. (line 18) * minibuffer-scroll-window: Minibuffer Misc. (line 23) * minibuffer-selected-window: Minibuffer Misc. (line 28) * minibuffer-setup-hook: Minibuffer Misc. (line 11) * minibuffer-window: Minibuffer Windows. (line 14) * minibuffer-window-active-p: Minibuffer Windows. (line 38) * minibufferp: Minibuffer Misc. (line 7) * minimum window size: Resizing Windows. (line 127) * minor mode: Minor Modes. (line 6) * minor mode conventions: Minor Mode Conventions. (line 6) * minor-mode-alist: Mode Line Variables. (line 78) * minor-mode-key-binding: Functions for Key Lookup. (line 68) * minor-mode-list: Minor Modes. (line 29) * minor-mode-map-alist: Controlling Active Maps. (line 64) * minor-mode-overriding-map-alist: Controlling Active Maps. (line 90) * misc-objects-consed: Memory Usage. (line 34) * mkdir: Create/Delete Dirs. (line 11) * mod: Arithmetic Operations. (line 140) * mode: Modes. (line 6) * mode help: Mode Help. (line 6) * mode hook: Major Mode Conventions. (line 158) * mode line: Mode Line Format. (line 6) * mode loading: Major Mode Conventions. (line 209) * mode variable: Minor Mode Conventions. (line 16) * mode-class (property): Major Mode Conventions. (line 182) * mode-line construct: Mode Line Data. (line 6) * mode-line prefix key: Key Sequence Input. (line 92) * mode-line-buffer-identification: Mode Line Variables. (line 36) * mode-line-format: Mode Line Top. (line 9) * mode-line-frame-identification: Mode Line Variables. (line 30) * mode-line-modes: Mode Line Variables. (line 52) * mode-line-modified: Mode Line Variables. (line 21) * mode-line-mule-info: Mode Line Variables. (line 16) * mode-line-position: Mode Line Variables. (line 41) * mode-line-process: Mode Line Variables. (line 69) * mode-name: Mode Line Variables. (line 60) * mode-specific-map: Prefix Keys. (line 21) * model/view/controller: Abstract Display. (line 6) * modification flag (of buffer): Buffer Modification. (line 6) * modification of lists: Rearrangement. (line 6) * modification time of buffer: Modification Time. (line 6) * modification time of file: File Attributes. (line 95) * modification-hooks (overlay property): Overlay Properties. (line 114) * modification-hooks (text property): Special Properties. (line 229) * modifier bits (of input character): Keyboard Events. (line 12) * modify-all-frames-parameters: Parameter Access. (line 34) * modify-category-entry: Categories. (line 104) * modify-frame-parameters: Parameter Access. (line 20) * modify-syntax-entry: Syntax Table Functions. (line 27) * modulus: Arithmetic Operations. (line 140) * momentary-string-display: Temporary Displays. (line 81) * most-negative-fixnum: Integer Basics. (line 81) * most-positive-fixnum: Integer Basics. (line 77) * motion by chars, words, lines, lists: Motion. (line 6) * motion event: Motion Events. (line 6) * mouse click event: Click Events. (line 6) * mouse drag event: Drag Events. (line 6) * mouse events, data in: Accessing Mouse. (line 6) * mouse events, in special parts of frame: Key Sequence Input. (line 92) * mouse events, repeated: Repeat Events. (line 6) * mouse motion events: Motion Events. (line 6) * mouse pointer shape: Pointer Shape. (line 6) * mouse position: Mouse Position. (line 6) * mouse position list, accessing: Accessing Mouse. (line 31) * mouse tracking: Mouse Tracking. (line 6) * mouse, availability: Display Feature Testing. (line 31) * mouse-1: Clickable Text. (line 6) * mouse-1-click-follows-link: Clickable Text. (line 78) * mouse-2: Key Binding Conventions. (line 6) * mouse-action (button property): Button Properties. (line 17) * mouse-face (button property): Button Properties. (line 27) * mouse-face (overlay property): Overlay Properties. (line 98) * mouse-face (text property): Special Properties. (line 60) * mouse-movement-p: Classifying Events. (line 89) * mouse-on-link-p: Clickable Text. (line 163) * mouse-pixel-position: Mouse Position. (line 32) * mouse-position: Mouse Position. (line 10) * mouse-position-function: Mouse Position. (line 16) * mouse-wheel-down-event: Misc Events. (line 37) * mouse-wheel-up-event: Misc Events. (line 37) * move to beginning or end of buffer: Buffer End Motion. (line 6) * move-marker: Moving Markers. (line 34) * move-overlay: Managing Overlays. (line 53) * move-to-column: Columns. (line 32) * move-to-left-margin: Margins. (line 57) * move-to-window-line: Screen Lines. (line 69) * movemail: Subprocess Creation. (line 64) * MS-DOS and file modes: File Attributes. (line 184) * MS-DOS file types: MS-DOS File Types. (line 6) * mule-keymap: Prefix Keys. (line 31) * multi-query-replace-map: Search and Replace. (line 146) * multi-tty: Multiple Terminals. (line 6) * multibyte characters: Non-ASCII Characters. (line 6) * multibyte text: Text Representations. (line 20) * multibyte-char-to-unibyte: Converting Representations. (line 59) * multibyte-string-p: Text Representations. (line 83) * multibyte-syntax-as-symbol: Control Parsing. (line 7) * multiline font lock: Multiline Font Lock. (line 6) * multiple terminals: Multiple Terminals. (line 6) * multiple windows: Basic Windows. (line 32) * multiple X displays: Multiple Terminals. (line 6) * multiple-frames: Frame Titles. (line 29) * named function: Function Names. (line 6) * NaN: Float Basics. (line 18) * narrow-to-page: Narrowing. (line 37) * narrow-to-region: Narrowing. (line 29) * narrowing: Narrowing. (line 6) * natnump: Predicates on Numbers. (line 33) * natural numbers: Predicates on Numbers. (line 28) * nbutlast: List Elements. (line 149) * nconc: Rearrangement. (line 16) * negative infinity: Float Basics. (line 18) * negative-argument: Prefix Command Arguments. (line 116) * network byte ordering: Bindat Spec. (line 13) * network connection: Network. (line 6) * network servers: Network Servers. (line 6) * network service name, and default coding system: Default Coding Systems. (line 80) * network-coding-system-alist: Default Coding Systems. (line 81) * network-interface-info: Misc Network. (line 17) * network-interface-list: Misc Network. (line 10) * new file message: Subroutines of Visiting. (line 37) * newline <1>: Commands for Insertion. (line 43) * newline: Basic Char Syntax. (line 27) * newline and Auto Fill mode: Commands for Insertion. (line 47) * newline in print: Output Functions. (line 84) * newline in strings: Syntax for Strings. (line 13) * newline-and-indent: Mode-Specific Indent. (line 35) * next input: Event Input Misc. (line 11) * next-button: Button Buffer Commands. (line 52) * next-char-property-change: Property Search. (line 84) * next-frame: Finding All Frames. (line 20) * next-history-element: Minibuffer Commands. (line 22) * next-matching-history-element: Minibuffer Commands. (line 31) * next-overlay-change: Finding Overlays. (line 36) * next-property-change: Property Search. (line 26) * next-screen-context-lines: Textual Scrolling. (line 151) * next-single-char-property-change: Property Search. (line 100) * next-single-property-change: Property Search. (line 60) * next-window: Cyclic Window Ordering. (line 24) * nil: nil and t. (line 6) * nil as a list: Box Diagrams. (line 41) * nil in keymap: Key Lookup. (line 36) * nil input stream: Input Streams. (line 51) * nil output stream: Output Streams. (line 34) * nlistp: List-related Predicates. (line 32) * no-byte-compile: Byte Compilation. (line 27) * no-catch: Catch and Throw. (line 86) * no-conversion coding system: Coding System Basics. (line 61) * no-redraw-on-reenter: Refresh Screen. (line 30) * no-self-insert property: Defining Abbrevs. (line 34) * non-ASCII characters: Non-ASCII Characters. (line 6) * non-ASCII text in keybindings: Key Binding Commands. (line 29) * non-capturing group: Regexp Backslash. (line 67) * non-greedy repetition characters in regexp: Regexp Special. (line 59) * nondirectory part (of file name): File Name Components. (line 6) * noninteractive: Batch Mode. (line 25) * nonlocal exits: Nonlocal Exits. (line 6) * nonprinting characters, reading: Quoted Character Input. (line 12) * noreturn: Test Coverage. (line 30) * normal hook: Hooks. (line 12) * normal-auto-fill-function: Auto Filling. (line 30) * normal-backup-enable-predicate: Making Backups. (line 51) * normal-mode: Auto Major Mode. (line 20) * not: Combining Conditions. (line 12) * not-modified: Buffer Modification. (line 43) * notation: Evaluation Notation. (line 6) * nreverse: Rearrangement. (line 64) * nth: List Elements. (line 77) * nthcdr: List Elements. (line 97) * null: List-related Predicates. (line 38) * null bytes, and decoding text: Lisp and Coding Systems. (line 122) * num-input-keys: Key Sequence Input. (line 113) * num-nonmacro-input-events: Reading One Event. (line 92) * number comparison: Comparison of Numbers. (line 6) * number conversions: Numeric Conversions. (line 6) * number-or-marker-p: Predicates on Markers. (line 20) * number-sequence: Building Lists. (line 171) * number-to-string: String Conversion. (line 43) * numberp: Predicates on Numbers. (line 24) * numbers: Numbers. (line 6) * numeric prefix argument: Prefix Command Arguments. (line 6) * numeric prefix argument usage: Interactive Codes. (line 153) * numerical RGB color specification: Color Names. (line 6) * obarray: Creating Symbols. (line 11) * obarray in completion: Basic Completion. (line 32) * object: Lisp Data Types. (line 6) * object internals: Object Internals. (line 6) * object to string: Output Functions. (line 91) * occur-mode-map: Standard Keymaps. (line 178) * octal character code: General Escape Syntax. (line 23) * octal character input: Quoted Character Input. (line 12) * octal numbers: Integer Basics. (line 22) * one-window-p: Splitting Windows. (line 136) * only-global-abbrevs: Defining Abbrevs. (line 48) * opacity, frame: Font and Color Parameters. (line 53) * open parenthesis character: Syntax Class Table. (line 44) * open-dribble-file: Recording Input. (line 20) * open-network-stream: Network. (line 55) * open-paren-in-column-0-is-defun-start: List Motion. (line 75) * open-termscript: Terminal Output. (line 48) * operating system environment: System Environment. (line 6) * operations (property): Magic File Names. (line 127) * option descriptions: A Sample Variable Description. (line 6) * optional arguments: Argument List. (line 18) * options on command line: Command-Line Arguments. (line 33) * options, defcustom keyword: Variable Definitions. (line 60) * or: Combining Conditions. (line 60) * ordering of windows, cyclic: Cyclic Window Ordering. (line 6) * other-buffer: The Buffer List. (line 68) * other-window: Cyclic Window Ordering. (line 83) * other-window-scroll-buffer: Textual Scrolling. (line 93) * output from processes: Output from Processes. (line 6) * output stream: Output Streams. (line 6) * output-controlling variables: Output Variables. (line 6) * overall prompt string: Format of Keymaps. (line 50) * overflow: Integer Basics. (line 9) * overflow-newline-into-fringe: Fringe Cursors. (line 18) * overlay-arrow-position: Overlay Arrow. (line 20) * overlay-arrow-string: Overlay Arrow. (line 13) * overlay-arrow-variable-list: Overlay Arrow. (line 41) * overlay-buffer: Managing Overlays. (line 40) * overlay-end: Managing Overlays. (line 36) * overlay-get: Overlay Properties. (line 28) * overlay-properties: Overlay Properties. (line 39) * overlay-put: Overlay Properties. (line 35) * overlay-recenter: Managing Overlays. (line 144) * overlay-start: Managing Overlays. (line 32) * overlayp: Managing Overlays. (line 12) * overlays: Overlays. (line 6) * overlays-at: Finding Overlays. (line 7) * overlays-in: Finding Overlays. (line 27) * overriding-local-map: Controlling Active Maps. (line 103) * overriding-local-map-menu-flag: Controlling Active Maps. (line 119) * overriding-terminal-local-map: Controlling Active Maps. (line 110) * overwrite-mode: Commands for Insertion. (line 62) * package-version, customization keyword: Common Keywords. (line 108) * packing: Byte Packing. (line 12) * padding: Formatting Strings. (line 124) * page-delimiter: Standard Regexps. (line 10) * paired delimiter: Syntax Class Table. (line 103) * paragraph-separate: Standard Regexps. (line 25) * paragraph-start: Standard Regexps. (line 32) * parent of char-table: Char-Tables. (line 29) * parent process: Processes. (line 6) * parenthesis: Cons Cell Type. (line 25) * parenthesis depth: Low-Level Parsing. (line 18) * parenthesis matching: Blinking. (line 6) * parenthesis mismatch, debugging: Syntax Errors. (line 20) * parenthesis syntax: Syntax Class Table. (line 45) * parity, in serial connections: Serial Ports. (line 119) * parse-colon-path: System Environment. (line 156) * parse-partial-sexp: Low-Level Parsing. (line 12) * parse-sexp-ignore-comments: Control Parsing. (line 13) * parse-sexp-lookup-properties <1>: Control Parsing. (line 17) * parse-sexp-lookup-properties: Syntax Properties. (line 28) * parser state: Parser State. (line 6) * parsing buffer text: Syntax Tables. (line 6) * partial application of functions: Calling Functions. (line 78) * passwords, reading: Reading a Password. (line 6) * PATH environment variable: Subprocess Creation. (line 17) * path-separator: System Environment. (line 150) * PBM: Other Image Types. (line 6) * peculiar error: Error Symbols. (line 29) * peeking at input: Event Input Misc. (line 11) * percent symbol in mode line: Mode Line Data. (line 20) * perform-replace: Search and Replace. (line 44) * performance analysis: Coverage Testing. (line 6) * permanent local variable: Creating Buffer-Local. (line 173) * permission: File Attributes. (line 13) * piece of advice: Advising Functions. (line 11) * pipes: Asynchronous Processes. (line 98) * play-sound: Sound Output. (line 15) * play-sound-file: Sound Output. (line 48) * play-sound-functions: Sound Output. (line 52) * plist: Property Lists. (line 6) * plist vs. alist: Plists and Alists. (line 6) * plist-get: Other Plists. (line 10) * plist-member: Other Plists. (line 52) * plist-put: Other Plists. (line 24) * point: Point. (line 6) * point excursion: Excursions. (line 20) * point in window: Window Point. (line 6) * point with narrowing: Point. (line 17) * point-entered (text property): Special Properties. (line 259) * point-left (text property): Special Properties. (line 259) * point-marker: Creating Markers. (line 22) * point-max: Point. (line 45) * point-max-marker: Creating Markers. (line 32) * point-min: Point. (line 39) * point-min-marker: Creating Markers. (line 27) * pointer (text property): Special Properties. (line 189) * pointer shape: Pointer Shape. (line 6) * pointers: Cons Cell Type. (line 6) * pop: List Elements. (line 61) * pop-mark: The Mark. (line 115) * pop-to-buffer: Displaying Buffers. (line 70) * pop-up-frame-alist: Choosing Window. (line 173) * pop-up-frame-function: Choosing Window. (line 163) * pop-up-frames: Choosing Window. (line 149) * pop-up-windows: Choosing Window. (line 60) * port number, and default coding system: Default Coding Systems. (line 80) * pos-visible-in-window-p: Window Start and End. (line 122) * position (in buffer): Positions. (line 6) * position argument: Interactive Codes. (line 79) * position in window: Window Point. (line 6) * position of mouse: Mouse Position. (line 6) * position-bytes: Text Representations. (line 65) * positive infinity: Float Basics. (line 18) * posix-looking-at: POSIX Regexps. (line 34) * posix-search-backward: POSIX Regexps. (line 29) * posix-search-forward: POSIX Regexps. (line 24) * posix-string-match: POSIX Regexps. (line 39) * posn-actual-col-row: Accessing Mouse. (line 71) * posn-area: Accessing Mouse. (line 38) * posn-at-point: Accessing Mouse. (line 109) * posn-at-x-y: Accessing Mouse. (line 116) * posn-col-row: Accessing Mouse. (line 65) * posn-image: Accessing Mouse. (line 82) * posn-object: Accessing Mouse. (line 86) * posn-object-width-height: Accessing Mouse. (line 96) * posn-object-x-y: Accessing Mouse. (line 90) * posn-point: Accessing Mouse. (line 43) * posn-string: Accessing Mouse. (line 78) * posn-timestamp: Accessing Mouse. (line 101) * posn-window: Accessing Mouse. (line 35) * posn-x-y: Accessing Mouse. (line 49) * post-command-hook: Command Overview. (line 45) * post-gc-hook: Garbage Collection. (line 148) * postscript images: PostScript Images. (line 6) * pre-command-hook: Command Overview. (line 39) * preactivating advice: Preactivation. (line 6) * preceding-char: Near Point. (line 56) * precision in format specifications: Formatting Strings. (line 184) * predicates for numbers: Predicates on Numbers. (line 6) * prefix argument: Prefix Command Arguments. (line 6) * prefix argument unreading: Event Input Misc. (line 20) * prefix command: Prefix Keys. (line 88) * prefix key: Prefix Keys. (line 6) * prefix, defgroup keyword: Group Definitions. (line 46) * prefix-arg: Prefix Command Arguments. (line 92) * prefix-help-command: Help Functions. (line 90) * prefix-numeric-value: Prefix Command Arguments. (line 79) * preloaded-file-list: Building Emacs. (line 29) * preloading additional functions and variables: Building Emacs. (line 58) * prepare-change-group: Atomic Changes. (line 31) * preventing backtracking: Specification List. (line 102) * preventing prefix key: Key Lookup. (line 102) * preventing quitting: Quitting. (line 45) * previous complete subexpression: Parser State. (line 20) * previous-button: Button Buffer Commands. (line 53) * previous-char-property-change: Property Search. (line 94) * previous-frame: Finding All Frames. (line 45) * previous-history-element: Minibuffer Commands. (line 18) * previous-matching-history-element: Minibuffer Commands. (line 26) * previous-overlay-change: Finding Overlays. (line 41) * previous-property-change: Property Search. (line 54) * previous-single-char-property-change: Property Search. (line 110) * previous-single-property-change: Property Search. (line 78) * previous-window: Cyclic Window Ordering. (line 78) * primitive: What Is a Function. (line 22) * primitive function: Primitive Function Type. (line 6) * primitive function internals: Writing Emacs Primitives. (line 6) * primitive type: Lisp Data Types. (line 16) * primitive-undo: Undo. (line 108) * prin1: Output Functions. (line 57) * prin1-to-string: Output Functions. (line 91) * princ: Output Functions. (line 69) * print: Output Functions. (line 40) * print example: Output Streams. (line 50) * print name cell: Symbol Components. (line 10) * print-circle: Output Variables. (line 92) * print-continuous-numbering: Output Variables. (line 102) * print-escape-multibyte: Output Variables. (line 52) * print-escape-newlines: Output Variables. (line 18) * print-escape-nonascii: Output Variables. (line 43) * print-gensym: Output Variables. (line 96) * print-length: Output Variables. (line 62) * print-level: Output Variables. (line 76) * print-number-table: Output Variables. (line 111) * print-quoted: Output Variables. (line 12) * printable-chars: Character Properties. (line 151) * printed representation: Printed Representation. (line 6) * printed representation for characters: Basic Char Syntax. (line 6) * printing: Streams Intro. (line 6) * printing (Edebug): Printing in Edebug. (line 6) * printing circular structures: Printing in Edebug. (line 6) * printing limits: Output Variables. (line 62) * printing notation: Printing Notation. (line 6) * priority (overlay property): Overlay Properties. (line 49) * priority order of coding systems: Specifying Coding Systems. (line 50) * process: Processes. (line 6) * process filter: Filter Functions. (line 6) * process filter multibyte flag: Decoding Output. (line 30) * process input: Input to Processes. (line 6) * process internals: Process Internals. (line 6) * process output: Output from Processes. (line 6) * process sentinel: Sentinels. (line 6) * process signals: Signals to Processes. (line 6) * process-adaptive-read-buffering: Output from Processes. (line 28) * process-attributes: System Processes. (line 23) * process-buffer: Process Buffers. (line 28) * process-coding-system: Process Information. (line 163) * process-coding-system-alist: Default Coding Systems. (line 58) * process-command: Process Information. (line 32) * process-connection-type: Asynchronous Processes. (line 98) * process-contact: Process Information. (line 41) * process-datagram-address: Datagrams. (line 21) * process-environment: System Environment. (line 128) * process-exit-status: Process Information. (line 151) * process-file: Synchronous Processes. (line 127) * process-file-shell-command: Synchronous Processes. (line 238) * process-file-side-effects: Synchronous Processes. (line 167) * process-filter: Filter Functions. (line 90) * process-get: Process Information. (line 180) * process-id: Process Information. (line 86) * process-kill-buffer-query-function: Process Buffers. (line 20) * process-kill-without-query: Query Before Exit. (line 25) * process-lines: Synchronous Processes. (line 247) * process-list: Process Information. (line 18) * process-mark: Process Buffers. (line 34) * process-name: Process Information. (line 93) * process-plist: Process Information. (line 188) * process-put: Process Information. (line 184) * process-query-on-exit-flag: Query Before Exit. (line 14) * process-running-child-p: Input to Processes. (line 71) * process-send-eof: Input to Processes. (line 62) * process-send-region: Input to Processes. (line 54) * process-send-string: Input to Processes. (line 36) * process-sentinel: Sentinels. (line 93) * process-status: Process Information. (line 96) * process-tty-name: Process Information. (line 157) * process-type: Process Information. (line 146) * processor run time: Processor Run Time. (line 6) * processp: Processes. (line 24) * profiling: Compilation Tips. (line 9) * prog1: Sequencing. (line 48) * prog2: Sequencing. (line 65) * progn: Sequencing. (line 33) * program arguments: Subprocess Creation. (line 50) * program directories: Subprocess Creation. (line 73) * program name, and default coding system: Default Coding Systems. (line 57) * programmed completion: Programmed Completion. (line 6) * programming conventions: Programming Tips. (line 6) * programming types: Programming Types. (line 6) * progress reporting: Progress. (line 6) * progress-reporter-done: Progress. (line 87) * progress-reporter-force-update: Progress. (line 77) * progress-reporter-update: Progress. (line 57) * prompt for file name: Reading File Names. (line 6) * prompt string (of menu): Defining Menus. (line 6) * prompt string of keymap: Format of Keymaps. (line 50) * properties of text: Text Properties. (line 6) * propertize: Changing Properties. (line 94) * property category of text character: Special Properties. (line 15) * property list: Property Lists. (line 6) * property list cell: Symbol Components. (line 30) * property lists vs association lists: Plists and Alists. (line 6) * protect C variables from garbage collection: Writing Emacs Primitives. (line 116) * protected forms: Cleanups. (line 13) * provide: Named Features. (line 69) * providing features: Named Features. (line 6) * PTYs: Asynchronous Processes. (line 98) * punctuation character: Syntax Class Table. (line 34) * pure storage: Pure Storage. (line 6) * pure-bytes-used: Pure Storage. (line 42) * purecopy: Pure Storage. (line 29) * purify-flag: Pure Storage. (line 48) * push: List Variables. (line 10) * push-button: Button Buffer Commands. (line 22) * push-mark: The Mark. (line 104) * put: Symbol Plists. (line 36) * put-char-code-property: Character Properties. (line 134) * put-charset-property: Character Sets. (line 56) * put-image: Showing Images. (line 40) * put-text-property: Changing Properties. (line 20) * puthash: Hash Access. (line 16) * query-replace-history: Minibuffer History. (line 96) * query-replace-map: Search and Replace. (line 86) * querying the user: Yes-or-No Queries. (line 6) * question mark in character constant: Basic Char Syntax. (line 6) * quietly-read-abbrev-file: Abbrev Files. (line 19) * quit-flag: Quitting. (line 75) * quit-process: Signals to Processes. (line 62) * quitting: Quitting. (line 6) * quitting from infinite loop: Infinite Loops. (line 6) * quote: Quoting. (line 13) * quote character: Parser State. (line 30) * quoted character input: Quoted Character Input. (line 6) * quoted-insert suppression: Changing Key Bindings. (line 159) * quoting and unquoting shell command line: Shell Arguments. (line 40) * quoting characters in printing: Output Functions. (line 9) * quoting using apostrophe: Quoting. (line 15) * radix for reading an integer: Integer Basics. (line 22) * raise-frame: Raising and Lowering. (line 24) * random: Random Numbers. (line 27) * random numbers: Random Numbers. (line 6) * rassoc: Association Lists. (line 91) * rassq: Association Lists. (line 125) * rassq-delete-all: Association Lists. (line 228) * raw prefix argument: Prefix Command Arguments. (line 6) * raw prefix argument usage: Interactive Codes. (line 157) * raw-text coding system: Coding System Basics. (line 51) * re-builder: Regular Expressions. (line 11) * re-search-backward: Regexp Search. (line 62) * re-search-forward: Regexp Search. (line 17) * reactivating advice: Activation of Advice. (line 72) * read: Input Functions. (line 17) * read command name: Interactive Call. (line 77) * read file names: Reading File Names. (line 6) * read input: Reading Input. (line 6) * read syntax: Printed Representation. (line 6) * read syntax for characters: Basic Char Syntax. (line 6) * read-buffer: High-Level Completion. (line 15) * read-buffer-completion-ignore-case: High-Level Completion. (line 55) * read-buffer-function: High-Level Completion. (line 49) * read-char: Reading One Event. (line 60) * read-char-exclusive: Reading One Event. (line 84) * read-circle: Input Functions. (line 57) * read-coding-system: User-Chosen Coding Systems. (line 71) * read-color: High-Level Completion. (line 130) * read-command: High-Level Completion. (line 59) * read-directory-name: Reading File Names. (line 119) * read-event: Reading One Event. (line 10) * read-expression-history: Minibuffer History. (line 115) * read-file-modes: Changing Files. (line 161) * read-file-name: Reading File Names. (line 14) * read-file-name-completion-ignore-case: Reading File Names. (line 114) * read-file-name-function: Reading File Names. (line 108) * read-from-minibuffer: Text from Minibuffer. (line 20) * read-from-string: Input Functions. (line 22) * read-input-method-name: Input Methods. (line 36) * read-kbd-macro: Describing Characters. (line 76) * read-key: Reading One Event. (line 103) * read-key-sequence: Key Sequence Input. (line 12) * read-key-sequence-vector: Key Sequence Input. (line 69) * read-minibuffer: Object from Minibuffer. (line 10) * read-no-blanks-input: Text from Minibuffer. (line 170) * read-non-nil-coding-system: User-Chosen Coding Systems. (line 77) * read-only (text property): Special Properties. (line 132) * read-only buffer: Read Only Buffers. (line 6) * read-only buffers in interactive: Using Interactive. (line 67) * read-only character: Special Properties. (line 132) * read-passwd: Reading a Password. (line 10) * read-quoted-char: Quoted Character Input. (line 12) * read-quoted-char quitting: Quitting. (line 55) * read-regexp: Text from Minibuffer. (line 104) * read-shell-command: Reading File Names. (line 170) * read-string: Text from Minibuffer. (line 77) * read-variable: High-Level Completion. (line 96) * reading: Streams Intro. (line 6) * reading a single event: Reading One Event. (line 6) * reading from files: Reading from Files. (line 6) * reading from minibuffer with completion: Minibuffer Completion. (line 6) * reading interactive arguments: Interactive Codes. (line 41) * reading numbers in hex, octal, and binary: Integer Basics. (line 22) * reading symbols: Creating Symbols. (line 6) * real-last-command: Command Loop Info. (line 25) * rearrangement of lists: Rearrangement. (line 6) * rebinding: Changing Key Bindings. (line 6) * recent-auto-save-p: Auto-Saving. (line 97) * recent-keys: Recording Input. (line 7) * recenter: Textual Scrolling. (line 158) * record command history: Interactive Call. (line 46) * recording input: Recording Input. (line 6) * recursion: Iteration. (line 6) * recursion-depth: Recursive Editing. (line 104) * recursive command loop: Recursive Editing. (line 6) * recursive editing level: Recursive Editing. (line 6) * recursive evaluation: Intro Eval. (line 30) * recursive minibuffers: Recursive Mini. (line 6) * recursive-edit: Recursive Editing. (line 62) * redirect-frame-focus: Input Focus. (line 85) * redisplay: Forcing Redisplay. (line 12) * redisplay-dont-pause: Forcing Redisplay. (line 48) * redisplay-preemption-period: Forcing Redisplay. (line 53) * redo: Undo. (line 6) * redraw-display: Refresh Screen. (line 16) * redraw-frame: Refresh Screen. (line 11) * references, following: Key Binding Conventions. (line 6) * regexp: Regular Expressions. (line 6) * regexp alternative: Regexp Backslash. (line 13) * regexp grouping: Regexp Backslash. (line 45) * regexp searching: Regexp Search. (line 6) * regexp-history: Minibuffer History. (line 106) * regexp-opt: Regexp Functions. (line 30) * regexp-opt-depth: Regexp Functions. (line 52) * regexp-quote: Regexp Functions. (line 9) * regexps used standardly in editing: Standard Regexps. (line 6) * region (between point and mark): The Region. (line 6) * region argument: Interactive Codes. (line 161) * region-beginning: The Region. (line 17) * region-end: The Region. (line 22) * register-alist: Registers. (line 14) * registers: Registers. (line 6) * regular expression: Regular Expressions. (line 6) * regular expression searching: Regexp Search. (line 6) * regular expressions, developing: Regular Expressions. (line 11) * reindent-then-newline-and-indent: Mode-Specific Indent. (line 45) * relative file name: Relative File Names. (line 6) * remainder: Arithmetic Operations. (line 114) * remapping commands: Remapping Commands. (line 6) * remhash: Hash Access. (line 21) * remove: Sets And Lists. (line 152) * remove-from-invisibility-spec: Invisible Text. (line 69) * remove-hook: Setting Hooks. (line 47) * remove-images: Showing Images. (line 59) * remove-list-of-text-properties: Changing Properties. (line 67) * remove-overlays: Managing Overlays. (line 69) * remove-text-properties: Changing Properties. (line 45) * remq: Sets And Lists. (line 77) * rename-auto-save-file: Auto-Saving. (line 160) * rename-buffer: Buffer Names. (line 38) * rename-file: Changing Files. (line 73) * repeat events: Repeat Events. (line 6) * repeated loading: Repeated Loading. (line 6) * replace bindings: Changing Key Bindings. (line 112) * replace characters: Substitution. (line 11) * replace matched text: Replacing Match. (line 6) * replace-buffer-in-windows: Displaying Buffers. (line 112) * replace-match: Replacing Match. (line 11) * replace-re-search-function: Search and Replace. (line 158) * replace-regexp-in-string: Search and Replace. (line 22) * replace-search-function: Search and Replace. (line 151) * replacement after search: Search and Replace. (line 6) * require: Named Features. (line 103) * require, customization keyword: Common Keywords. (line 94) * require-final-newline: Saving Buffers. (line 153) * requiring features: Named Features. (line 6) * reserved keys: Key Binding Conventions. (line 14) * resize frame: Size and Position. (line 6) * resize window: Resizing Windows. (line 6) * rest arguments: Argument List. (line 18) * restore-buffer-modified-p: Buffer Modification. (line 39) * restriction (in a buffer): Narrowing. (line 6) * resume (cf. no-redraw-on-reenter): Refresh Screen. (line 30) * resume-tty: Suspending Emacs. (line 98) * resume-tty-functions: Suspending Emacs. (line 103) * rethrow a signal: Handling Errors. (line 133) * return (ASCII character): Basic Char Syntax. (line 27) * reverse: Building Lists. (line 150) * reversing a list: Rearrangement. (line 64) * revert-buffer: Reverting. (line 13) * revert-buffer-function: Reverting. (line 56) * revert-buffer-insert-file-contents-function: Reverting. (line 68) * revert-without-query: Reverting. (line 45) * rgb value: Color Names. (line 68) * right-fringe-width: Fringe Size/Pos. (line 20) * right-margin-width: Display Margins. (line 36) * ring data structure: Rings. (line 6) * ring-bell-function: Beeping. (line 28) * ring-copy: Rings. (line 28) * ring-elements: Rings. (line 25) * ring-empty-p: Rings. (line 32) * ring-insert: Rings. (line 45) * ring-insert-at-beginning: Rings. (line 58) * ring-length: Rings. (line 21) * ring-p: Rings. (line 15) * ring-ref: Rings. (line 40) * ring-remove: Rings. (line 52) * ring-size: Rings. (line 18) * risky, defcustom keyword: Variable Definitions. (line 138) * risky-local-variable-p: File Local Variables. (line 114) * rm: Changing Files. (line 110) * round: Numeric Conversions. (line 66) * rounding in conversions: Numeric Conversions. (line 6) * rounding without conversion: Rounding Operations. (line 6) * rplaca: Modifying Lists. (line 10) * rplacd: Modifying Lists. (line 10) * run time stack: Internals of Debugger. (line 21) * run-at-time: Timers. (line 44) * run-hook-with-args: Running Hooks. (line 24) * run-hook-with-args-until-failure: Running Hooks. (line 29) * run-hook-with-args-until-success: Running Hooks. (line 36) * run-hooks: Running Hooks. (line 10) * run-mode-hooks: Mode Hooks. (line 28) * run-with-idle-timer: Idle Timers. (line 11) * safe local variable: File Local Variables. (line 79) * safe, defcustom keyword: Variable Definitions. (line 142) * safe-length: List Elements. (line 117) * safe-local-eval-forms: File Local Variables. (line 139) * safe-local-variable-p: File Local Variables. (line 101) * safe-local-variable-values: File Local Variables. (line 90) * safe-magic (property): Magic File Names. (line 119) * safely encode a string: Lisp and Coding Systems. (line 73) * safely encode characters in a charset: Lisp and Coding Systems. (line 80) * safely encode region: Lisp and Coding Systems. (line 64) * safety of functions: Function Safety. (line 6) * same-window-buffer-names: Choosing Window. (line 253) * same-window-p: Choosing Window. (line 265) * same-window-regexps: Choosing Window. (line 259) * save-abbrevs: Abbrev Files. (line 27) * save-buffer: Saving Buffers. (line 13) * save-buffer-coding-system: Encoding and I/O. (line 35) * save-current-buffer: Current Buffer. (line 99) * save-excursion: Excursions. (line 20) * save-match-data: Saving Match Data. (line 21) * save-restriction: Narrowing. (line 55) * save-selected-window: Selecting Windows. (line 30) * save-some-buffers: Saving Buffers. (line 35) * save-window-excursion: Window Configurations. (line 53) * saving buffers: Saving Buffers. (line 6) * saving text properties: Format Conversion. (line 6) * saving window information: Window Configurations. (line 6) * scalability of overlays: Overlays. (line 12) * scalable-fonts-allowed: Font Selection. (line 69) * scan-lists: Motion via Parsing. (line 10) * scan-sexps: Motion via Parsing. (line 29) * scope: Variable Scoping. (line 11) * screen layout: Frame Configuration Type. (line 6) * screen of terminal: Basic Windows. (line 45) * screen size: Size and Position. (line 6) * scroll bar events, data in: Accessing Scroll. (line 6) * scroll bars: Scroll Bars. (line 6) * scroll-bar-event-ratio: Accessing Scroll. (line 9) * scroll-bar-mode: Scroll Bars. (line 65) * scroll-bar-scale: Accessing Scroll. (line 15) * scroll-bar-width: Scroll Bars. (line 80) * scroll-conservatively: Textual Scrolling. (line 105) * scroll-down: Textual Scrolling. (line 56) * scroll-down-aggressively: Textual Scrolling. (line 118) * scroll-left: Horizontal Scrolling. (line 48) * scroll-margin: Textual Scrolling. (line 97) * scroll-other-window: Textual Scrolling. (line 67) * scroll-preserve-screen-position: Textual Scrolling. (line 142) * scroll-right: Horizontal Scrolling. (line 67) * scroll-step: Textual Scrolling. (line 136) * scroll-up: Textual Scrolling. (line 45) * scroll-up-aggressively: Textual Scrolling. (line 131) * scrolling textually: Textual Scrolling. (line 6) * search-backward: String Search. (line 62) * search-failed: String Search. (line 41) * search-forward: String Search. (line 16) * search-map: Prefix Keys. (line 45) * search-spaces-regexp: Regexp Search. (line 168) * searching: Searching and Matching. (line 6) * searching active keymaps for keys: Searching Keymaps. (line 6) * searching and case: Searching and Case. (line 6) * searching and replacing: Search and Replace. (line 6) * searching for regexp: Regexp Search. (line 6) * seconds-to-time: Time Parsing. (line 160) * select safe coding system: User-Chosen Coding Systems. (line 6) * select-frame: Input Focus. (line 50) * select-frame-set-input-focus: Input Focus. (line 43) * select-safe-coding-system: User-Chosen Coding Systems. (line 8) * select-safe-coding-system-accept-default-p: User-Chosen Coding Systems. (line 50) * select-window: Selecting Windows. (line 14) * selected window: Basic Windows. (line 6) * selected-frame: Input Focus. (line 21) * selected-window: Selecting Windows. (line 10) * selecting a buffer: Current Buffer. (line 6) * selecting a window: Selecting Windows. (line 6) * selection (for window systems): Window System Selections. (line 6) * selection-coding-system: Window System Selections. (line 65) * selective-display: Selective Display. (line 40) * selective-display-ellipses: Selective Display. (line 86) * self-evaluating form: Self-Evaluating Forms. (line 6) * self-insert-and-exit: Minibuffer Commands. (line 13) * self-insert-command: Commands for Insertion. (line 17) * self-insert-command override: Changing Key Bindings. (line 149) * self-insert-command, minor modes: Keymaps and Minor Modes. (line 11) * self-insertion: Commands for Insertion. (line 17) * send-string-to-terminal: Terminal Output. (line 31) * sending signals: Signals to Processes. (line 6) * sentence-end: Standard Regexps. (line 38) * sentence-end-double-space: Filling. (line 133) * sentence-end-without-period: Filling. (line 138) * sentence-end-without-space: Filling. (line 143) * sentinel (of process): Sentinels. (line 6) * sequence: Sequences Arrays Vectors. (line 6) * sequence length: Sequence Functions. (line 16) * sequencep: Sequence Functions. (line 12) * serial connections: Serial Ports. (line 6) * serial-process-configure: Serial Ports. (line 119) * serial-term: Serial Ports. (line 31) * serializing: Byte Packing. (line 12) * session manager: Session Management. (line 6) * set: Setting Variables. (line 42) * set, defcustom keyword: Variable Definitions. (line 69) * set-advertised-calling-convention: Obsolete Functions. (line 36) * set-after, defcustom keyword: Variable Definitions. (line 146) * set-auto-coding: Default Coding Systems. (line 136) * set-auto-mode: Auto Major Mode. (line 50) * set-buffer: Current Buffer. (line 90) * set-buffer-auto-saved: Auto-Saving. (line 101) * set-buffer-major-mode: Auto Major Mode. (line 82) * set-buffer-modified-p: Buffer Modification. (line 29) * set-buffer-multibyte: Selecting a Representation. (line 10) * set-case-syntax: Case Tables. (line 111) * set-case-syntax-delims: Case Tables. (line 107) * set-case-syntax-pair: Case Tables. (line 103) * set-case-table: Case Tables. (line 75) * set-category-table: Categories. (line 67) * set-char-table-extra-slot: Char-Tables. (line 79) * set-char-table-parent: Char-Tables. (line 71) * set-char-table-range: Char-Tables. (line 100) * set-charset-priority: Character Sets. (line 36) * set-coding-system-priority: Specifying Coding Systems. (line 62) * set-default: Default Value. (line 77) * set-default-file-modes: Changing Files. (line 139) * set-display-table-slot: Display Table Format. (line 74) * set-face-attribute: Attribute Functions. (line 10) * set-face-background: Attribute Functions. (line 99) * set-face-bold-p: Attribute Functions. (line 109) * set-face-font: Attribute Functions. (line 106) * set-face-foreground: Attribute Functions. (line 98) * set-face-inverse-video-p: Attribute Functions. (line 121) * set-face-italic-p: Attribute Functions. (line 113) * set-face-stipple: Attribute Functions. (line 103) * set-face-underline-p: Attribute Functions. (line 117) * set-file-modes: Changing Files. (line 125) * set-file-times: Changing Files. (line 190) * set-fontset-font: Fontsets. (line 85) * set-frame-configuration: Frame Configurations. (line 15) * set-frame-height: Size and Position. (line 67) * set-frame-parameter: Parameter Access. (line 30) * set-frame-position: Size and Position. (line 16) * set-frame-selected-window: Frames and Windows. (line 34) * set-frame-size: Size and Position. (line 59) * set-frame-width: Size and Position. (line 81) * set-fringe-bitmap-face: Customizing Bitmaps. (line 39) * set-input-method: Input Methods. (line 29) * set-input-mode: Input Modes. (line 7) * set-keyboard-coding-system: Terminal I/O Encoding. (line 18) * set-keymap-parent: Inheritance and Keymaps. (line 32) * set-left-margin: Margins. (line 34) * set-mark: The Mark. (line 82) * set-marker: Moving Markers. (line 13) * set-marker-insertion-type: Marker Insertion Types. (line 14) * set-match-data: Entire Match Data. (line 50) * set-minibuffer-window: Minibuffer Windows. (line 21) * set-mouse-pixel-position: Mouse Position. (line 36) * set-mouse-position: Mouse Position. (line 25) * set-network-process-option: Network Options. (line 68) * set-process-buffer: Process Buffers. (line 55) * set-process-coding-system: Process Information. (line 171) * set-process-datagram-address: Datagrams. (line 25) * set-process-filter: Filter Functions. (line 86) * set-process-plist: Process Information. (line 191) * set-process-query-on-exit-flag: Query Before Exit. (line 17) * set-process-sentinel: Sentinels. (line 73) * set-register: Registers. (line 62) * set-right-margin: Margins. (line 39) * set-screen-height: Size and Position. (line 84) * set-screen-width: Size and Position. (line 84) * set-standard-case-table: Case Tables. (line 65) * set-syntax-table: Syntax Table Functions. (line 98) * set-terminal-coding-system: Terminal I/O Encoding. (line 32) * set-terminal-parameter: Terminal Parameters. (line 25) * set-text-properties: Changing Properties. (line 72) * set-time-zone-rule: Time of Day. (line 66) * set-visited-file-modtime: Modification Time. (line 63) * set-visited-file-name: Buffer File Name. (line 86) * set-window-buffer: Buffers and Windows. (line 15) * set-window-configuration: Window Configurations. (line 25) * set-window-dedicated-p: Dedicated Windows. (line 42) * set-window-display-table: Active Display Table. (line 18) * set-window-fringes: Fringe Size/Pos. (line 31) * set-window-hscroll: Horizontal Scrolling. (line 89) * set-window-margins: Display Margins. (line 47) * set-window-parameter: Window Parameters. (line 21) * set-window-point: Window Point. (line 42) * set-window-scroll-bars: Scroll Bars. (line 31) * set-window-start: Window Start and End. (line 68) * set-window-vscroll: Vertical Scrolling. (line 35) * setcar: Setcar. (line 10) * setcdr: Setcdr. (line 9) * setenv: System Environment. (line 111) * setplist: Symbol Plists. (line 10) * setq: Setting Variables. (line 11) * setq-default: Default Value. (line 36) * sets: Sets And Lists. (line 6) * setting modes of files: Changing Files. (line 6) * setting-constant: Constant Variables. (line 6) * severity level: Warning Basics. (line 6) * sexp motion: List Motion. (line 6) * shadowing of variables: Local Variables. (line 17) * shallow binding: Impl of Scope. (line 26) * shared structure, read syntax: Circular Objects. (line 6) * shell command arguments: Shell Arguments. (line 6) * shell-command-history: Minibuffer History. (line 112) * shell-command-to-string: Synchronous Processes. (line 243) * shell-quote-argument: Shell Arguments. (line 14) * shift-selection, and interactive spec: Using Interactive. (line 75) * shift-translation: Key Sequence Input. (line 73) * show-help-function: Special Properties. (line 290) * shrink-window: Resizing Windows. (line 52) * shrink-window-horizontally: Resizing Windows. (line 61) * shrink-window-if-larger-than-buffer: Resizing Windows. (line 91) * shy groups: Regexp Backslash. (line 67) * side effect: Intro Eval. (line 49) * signal: Signaling Errors. (line 49) * signal-process: Signals to Processes. (line 81) * signaling errors: Signaling Errors. (line 6) * signals: Signals to Processes. (line 6) * sigusr1 event: Misc Events. (line 67) * sigusr2 event: Misc Events. (line 67) * sin: Math Functions. (line 10) * single-key-description: Describing Characters. (line 29) * sit-for: Waiting. (line 13) * site-init.el: Building Emacs. (line 58) * site-load.el: Building Emacs. (line 43) * site-run-file: Init File. (line 39) * site-start.el: Startup Summary. (line 42) * size of frame: Size and Position. (line 6) * size of window: Size of Window. (line 6) * skip-chars-backward: Skipping Characters. (line 53) * skip-chars-forward: Skipping Characters. (line 15) * skip-syntax-backward: Motion and Syntax. (line 23) * skip-syntax-forward: Motion and Syntax. (line 10) * skipping characters: Skipping Characters. (line 6) * skipping comments: Control Parsing. (line 13) * sleep-for: Waiting. (line 42) * small-temporary-file-directory: Unique File Names. (line 86) * Snarf-documentation: Accessing Documentation. (line 124) * sort: Rearrangement. (line 99) * sort-columns: Sorting. (line 211) * sort-fields: Sorting. (line 189) * sort-fold-case: Sorting. (line 108) * sort-lines: Sorting. (line 174) * sort-numeric-base: Sorting. (line 207) * sort-numeric-fields: Sorting. (line 196) * sort-pages: Sorting. (line 184) * sort-paragraphs: Sorting. (line 179) * sort-regexp-fields: Sorting. (line 113) * sort-subr: Sorting. (line 13) * sorting lists: Rearrangement. (line 99) * sorting text: Sorting. (line 6) * sound: Sound Output. (line 6) * source breakpoints: Source Breakpoints. (line 6) * space (ASCII character): Basic Char Syntax. (line 27) * spaces, pixel specification: Pixel Specification. (line 6) * spaces, specified height or width: Specified Space. (line 6) * sparse keymap: Format of Keymaps. (line 6) * special: Major Mode Conventions. (line 182) * special events: Special Events. (line 6) * special form descriptions: A Sample Function Description. (line 6) * special forms: Special Forms. (line 6) * special forms for control structures: Control Structures. (line 6) * special-display-buffer-names: Choosing Window. (line 179) * special-display-frame-alist: Choosing Window. (line 249) * special-display-function: Choosing Window. (line 225) * special-display-p: Choosing Window. (line 219) * special-display-popup-frame: Choosing Window. (line 231) * special-display-regexps: Choosing Window. (line 208) * special-event-map: Controlling Active Maps. (line 133) * specify color: Color Names. (line 6) * speedups: Compilation Tips. (line 6) * splicing (with backquote): Backquote. (line 39) * split-height-threshold: Choosing Window. (line 105) * split-string: Creating Strings. (line 128) * split-string-and-unquote: Shell Arguments. (line 45) * split-string-default-separators: Creating Strings. (line 201) * split-width-threshold: Choosing Window. (line 126) * split-window: Splitting Windows. (line 12) * split-window-horizontally: Splitting Windows. (line 119) * split-window-keep-point: Splitting Windows. (line 107) * split-window-preferred-function: Choosing Window. (line 70) * split-window-sensibly: Choosing Window. (line 100) * split-window-vertically: Splitting Windows. (line 94) * splitting windows: Splitting Windows. (line 6) * sqrt: Math Functions. (line 52) * stable sort: Rearrangement. (line 99) * standard buffer-local variables: Standard Buffer-Local Variables. (line 6) * standard colors for character terminals: Font and Color Parameters. (line 21) * standard errors: Standard Errors. (line 6) * standard hooks: Standard Hooks. (line 6) * standard keymaps: Standard Keymaps. (line 6) * standard regexps used in editing: Standard Regexps. (line 6) * standard-case-table: Case Tables. (line 69) * standard-category-table: Categories. (line 58) * standard-display-table: Active Display Table. (line 28) * standard-input: Input Functions. (line 52) * standard-output: Output Variables. (line 7) * standard-syntax-table: Standard Syntax Tables. (line 10) * standard-translation-table-for-decode: Translation of Characters. (line 47) * standard-translation-table-for-encode: Translation of Characters. (line 52) * standards of coding style: Tips. (line 6) * start-file-process: Asynchronous Processes. (line 55) * start-file-process-shell-command: Asynchronous Processes. (line 93) * start-process: Asynchronous Processes. (line 18) * start-process-shell-command: Asynchronous Processes. (line 78) * startup of Emacs: Startup Summary. (line 6) * startup.el: Startup Summary. (line 6) * staticpro, protection from GC: Writing Emacs Primitives. (line 190) * sticky text properties: Sticky Properties. (line 6) * stop points: Using Edebug. (line 36) * stop-process: Signals to Processes. (line 67) * stopbits, in serial connections: Serial Ports. (line 119) * stopping an infinite loop: Infinite Loops. (line 6) * stopping on events: Global Break Condition. (line 6) * store-match-data: Entire Match Data. (line 62) * store-substring: Modifying Strings. (line 15) * stream (for printing): Output Streams. (line 6) * stream (for reading): Input Streams. (line 6) * string: Creating Strings. (line 23) * string quote: Syntax Class Table. (line 61) * string equality: Text Comparison. (line 6) * string in keymap: Key Lookup. (line 46) * string input stream: Input Streams. (line 23) * string length: Sequence Functions. (line 16) * string search: String Search. (line 6) * string to character: String Conversion. (line 25) * string to number: String Conversion. (line 60) * string to object: Input Functions. (line 22) * string, number of bytes: Text Representations. (line 86) * string, writing a doc string: Documentation Basics. (line 6) * string-as-multibyte: Selecting a Representation. (line 43) * string-as-unibyte: Selecting a Representation. (line 34) * string-bytes: Text Representations. (line 86) * string-chars-consed: Memory Usage. (line 30) * string-equal: Text Comparison. (line 50) * string-lessp: Text Comparison. (line 98) * string-match: Regexp Search. (line 81) * string-match-p: Regexp Search. (line 110) * string-or-null-p: Predicates for Strings. (line 13) * string-to-char: String Conversion. (line 25) * string-to-int: String Conversion. (line 89) * string-to-multibyte: Converting Representations. (line 43) * string-to-number: String Conversion. (line 60) * string-to-syntax: Syntax Table Internals. (line 41) * string-to-unibyte: Converting Representations. (line 52) * string-width: Width. (line 15) * string<: Text Comparison. (line 53) * string=: Text Comparison. (line 18) * stringp: Predicates for Strings. (line 10) * strings: Strings and Characters. (line 6) * strings with keyboard events: Strings of Events. (line 6) * strings, formatting them: Formatting Strings. (line 6) * strings-consed: Memory Usage. (line 43) * subprocess: Processes. (line 6) * subr: What Is a Function. (line 22) * subr-arity: What Is a Function. (line 104) * subrp: What Is a Function. (line 88) * subst-char-in-region: Substitution. (line 11) * substitute-command-keys: Keys in Documentation. (line 36) * substitute-in-file-name: File Name Expansion. (line 83) * substitute-key-definition: Changing Key Bindings. (line 112) * substituting keys in documentation: Keys in Documentation. (line 6) * substring: Creating Strings. (line 29) * substring-no-properties: Creating Strings. (line 92) * subtype of char-table: Char-Tables. (line 14) * suggestions: Caveats. (line 27) * super characters: Other Char Bits. (line 16) * suppress-keymap: Changing Key Bindings. (line 149) * suspend (cf. no-redraw-on-reenter): Refresh Screen. (line 30) * suspend evaluation: Recursive Editing. (line 62) * suspend-emacs: Suspending Emacs. (line 23) * suspend-frame: Suspending Emacs. (line 118) * suspend-hook: Suspending Emacs. (line 78) * suspend-resume-hook: Suspending Emacs. (line 81) * suspend-tty: Suspending Emacs. (line 85) * suspend-tty-functions: Suspending Emacs. (line 94) * suspending Emacs: Suspending Emacs. (line 6) * swap text between buffers: Swapping Text. (line 6) * switch-to-buffer: Displaying Buffers. (line 23) * switch-to-buffer-other-window: Displaying Buffers. (line 56) * switches on command line: Command-Line Arguments. (line 33) * switching to a buffer: Displaying Buffers. (line 6) * sxhash: Defining Hash. (line 42) * symbol: Symbols. (line 6) * symbol constituent: Syntax Class Table. (line 24) * symbol components: Symbol Components. (line 6) * symbol equality: Creating Symbols. (line 39) * symbol evaluation: Symbol Forms. (line 6) * symbol function indirection: Function Indirection. (line 6) * symbol in keymap: Key Lookup. (line 82) * symbol name hashing: Creating Symbols. (line 11) * symbol that evaluates to itself: Constant Variables. (line 6) * symbol with constant value: Constant Variables. (line 6) * symbol-file: Where Defined. (line 7) * symbol-function: Function Cells. (line 14) * symbol-name: Creating Symbols. (line 73) * symbol-plist: Symbol Plists. (line 7) * symbol-value: Accessing Variables. (line 13) * symbolp: Symbols. (line 17) * symbols-consed: Memory Usage. (line 26) * synchronous subprocess: Synchronous Processes. (line 6) * syntactic font lock: Syntactic Font Lock. (line 6) * syntax class: Syntax Descriptors. (line 6) * syntax descriptor: Syntax Descriptors. (line 23) * syntax error (Edebug): Backtracking. (line 6) * syntax flags: Syntax Flags. (line 6) * syntax for characters: Basic Char Syntax. (line 6) * syntax table: Syntax Tables. (line 6) * syntax table example: Example Major Modes. (line 87) * syntax table internals: Syntax Table Internals. (line 6) * syntax tables in modes: Major Mode Conventions. (line 110) * syntax-after: Syntax Table Internals. (line 45) * syntax-begin-function: Position Parse. (line 36) * syntax-class: Syntax Table Internals. (line 52) * syntax-ppss: Position Parse. (line 11) * syntax-ppss-flush-cache: Position Parse. (line 27) * syntax-ppss-toplevel-pos: Parser State. (line 57) * syntax-table: Syntax Table Functions. (line 102) * syntax-table (text property): Syntax Properties. (line 6) * syntax-table-p: Syntax Basics. (line 42) * system abbrev: Abbrevs. (line 25) * system processes: System Processes. (line 6) * system type and name: System Environment. (line 15) * system-configuration: System Environment. (line 11) * system-key-alist: X11 Keysyms. (line 10) * system-messages-locale: Locales. (line 17) * system-name: System Environment. (line 75) * system-time-locale: Locales. (line 24) * system-type: System Environment. (line 16) * t: nil and t. (line 26) * t input stream: Input Streams. (line 41) * t output stream: Output Streams. (line 31) * tab (ASCII character): Basic Char Syntax. (line 27) * tab deletion: Deletion. (line 70) * tab-stop-list: Indent Tabs. (line 24) * tab-to-tab-stop: Indent Tabs. (line 17) * tab-width: Usual Display. (line 64) * tabs stops for indentation: Indent Tabs. (line 6) * tag on run time stack: Catch and Throw. (line 61) * tag, customization keyword: Common Keywords. (line 16) * tan: Math Functions. (line 12) * TCP: Network. (line 6) * temacs: Building Emacs. (line 6) * TEMP environment variable: Unique File Names. (line 68) * temp-buffer-setup-hook: Temporary Displays. (line 68) * temp-buffer-show-function: Temporary Displays. (line 58) * temp-buffer-show-hook: Temporary Displays. (line 74) * temporary-file-directory: Unique File Names. (line 68) * TERM environment variable: Terminal-Specific. (line 46) * term-file-prefix: Terminal-Specific. (line 46) * term-setup-hook: Terminal-Specific. (line 60) * Termcap: Terminal-Specific. (line 15) * terminal: Frames. (line 17) * terminal frame: Frames. (line 21) * terminal input: Terminal Input. (line 6) * terminal input modes: Input Modes. (line 6) * terminal output: Terminal Output. (line 6) * terminal parameters: Terminal Parameters. (line 6) * terminal screen: Basic Windows. (line 45) * terminal type: Terminal Type. (line 6) * terminal-coding-system: Terminal I/O Encoding. (line 26) * terminal-list: Multiple Terminals. (line 35) * terminal-live-p: Frames. (line 65) * terminal-local variables: Multiple Terminals. (line 69) * terminal-name: Multiple Terminals. (line 29) * terminal-parameter: Terminal Parameters. (line 20) * terminal-parameters: Terminal Parameters. (line 16) * terminal-specific initialization: Terminal-Specific. (line 6) * termscript file: Terminal Output. (line 48) * terpri: Output Functions. (line 84) * test-completion: Basic Completion. (line 132) * testcover-mark-all: Test Coverage. (line 6) * testcover-next-mark: Test Coverage. (line 6) * testcover-start: Test Coverage. (line 6) * testing types: Type Predicates. (line 21) * text: Text. (line 6) * text conversion of coding system: Lisp and Coding Systems. (line 57) * text deletion: Deletion. (line 6) * text files and binary files: MS-DOS File Types. (line 6) * text insertion: Insertion. (line 6) * text near point: Near Point. (line 6) * text parsing: Syntax Tables. (line 6) * text properties: Text Properties. (line 6) * text properties in files: Format Conversion. (line 6) * text properties in the mode line: Properties in Mode. (line 6) * text properties, read syntax: Text Props and Strings. (line 6) * text representation: Text Representations. (line 6) * text-char-description: Describing Characters. (line 55) * text-mode-abbrev-table: Standard Abbrev Tables. (line 33) * text-mode-map: Standard Keymaps. (line 191) * text-mode-syntax-table: Standard Syntax Tables. (line 14) * text-properties-at: Examining Properties. (line 59) * text-property-any: Property Search. (line 115) * text-property-default-nonsticky: Sticky Properties. (line 54) * text-property-not-all: Property Search. (line 126) * textual order: Control Structures. (line 12) * textual scrolling: Textual Scrolling. (line 6) * thing-at-point: Buffer Contents. (line 112) * this-command: Command Loop Info. (line 34) * this-command-keys: Command Loop Info. (line 74) * this-command-keys-shift-translated: Key Sequence Input. (line 78) * this-command-keys-vector: Command Loop Info. (line 90) * this-original-command: Command Loop Info. (line 67) * three-step-help: Help Functions. (line 177) * throw: Catch and Throw. (line 77) * throw example: Recursive Editing. (line 32) * TIFF: TIFF Images. (line 6) * tiled windows: Basic Windows. (line 45) * time-add: Time Calculations. (line 17) * time-less-p: Time Calculations. (line 10) * time-subtract: Time Calculations. (line 13) * time-to-day-in-year: Time Calculations. (line 28) * time-to-days: Time Calculations. (line 24) * timer: Timers. (line 6) * timer-max-repeats: Timers. (line 101) * timestamp of a mouse event: Accessing Mouse. (line 100) * timing programs: Compilation Tips. (line 9) * tips for writing Lisp: Tips. (line 6) * TMP environment variable: Unique File Names. (line 68) * TMPDIR environment variable: Unique File Names. (line 68) * toggle-read-only: Read Only Buffers. (line 46) * tool bar: Tool Bar. (line 6) * tool-bar-add-item: Tool Bar. (line 95) * tool-bar-add-item-from-menu: Tool Bar. (line 116) * tool-bar-border: Tool Bar. (line 161) * tool-bar-button-margin: Tool Bar. (line 152) * tool-bar-button-relief: Tool Bar. (line 157) * tool-bar-local-item-from-menu: Tool Bar. (line 130) * tool-bar-map: Tool Bar. (line 80) * tooltip: Special Properties. (line 79) * top-level: Recursive Editing. (line 99) * top-level form: Loading. (line 15) * tq-close: Transaction Queues. (line 40) * tq-create: Transaction Queues. (line 12) * tq-enqueue: Transaction Queues. (line 20) * trace buffer: Trace Buffer. (line 6) * track-mouse: Mouse Tracking. (line 19) * transaction queue: Transaction Queues. (line 6) * transcendental functions: Math Functions. (line 6) * transient-mark-mode: The Mark. (line 123) * translate-region: Substitution. (line 34) * translation tables: Translation of Characters. (line 6) * translation-table-for-input: Translation of Characters. (line 57) * transparency, frame: Font and Color Parameters. (line 53) * transpose-regions: Transposition. (line 10) * triple-click events: Repeat Events. (line 6) * true: nil and t. (line 26) * true list: Cons Cells. (line 25) * truename (of file): Truenames. (line 6) * truncate: Numeric Conversions. (line 22) * truncate-lines: Truncation. (line 22) * truncate-partial-width-windows: Truncation. (line 30) * truncate-string-to-width: Width. (line 20) * truth value: nil and t. (line 6) * try-completion: Basic Completion. (line 11) * tty-color-alist: Text Terminal Colors. (line 41) * tty-color-approximate: Text Terminal Colors. (line 51) * tty-color-clear: Text Terminal Colors. (line 37) * tty-color-define: Text Terminal Colors. (line 27) * tty-color-translate: Text Terminal Colors. (line 57) * tty-erase-char: System Environment. (line 215) * two's complement: Integer Basics. (line 49) * type: Lisp Data Types. (line 6) * type (button property): Button Properties. (line 38) * type checking: Type Predicates. (line 6) * type checking internals: Object Internals. (line 20) * type predicates: Type Predicates. (line 21) * type, defcustom keyword: Customization Types. (line 11) * type-of: Type Predicates. (line 182) * typographic conventions: Some Terms. (line 14) * UDP: Network. (line 6) * umask: Changing Files. (line 139) * unbalanced parentheses: Syntax Errors. (line 20) * unbinding keys: Key Binding Commands. (line 60) * unbury-buffer: The Buffer List. (line 127) * undecided coding-system, when encoding: Explicit Encoding. (line 56) * undefined: Functions for Key Lookup. (line 50) * undefined in keymap: Key Lookup. (line 96) * undefined key: Keymap Basics. (line 6) * underline-minimum-offset: Face Attributes. (line 188) * undo avoidance: Substitution. (line 15) * undo-ask-before-discard: Maintaining Undo. (line 62) * undo-boundary: Undo. (line 79) * undo-in-progress: Undo. (line 103) * undo-limit: Maintaining Undo. (line 45) * undo-outer-limit: Maintaining Undo. (line 57) * undo-strong-limit: Maintaining Undo. (line 50) * unexec: Building Emacs. (line 96) * unhandled-file-name-directory: Magic File Names. (line 198) * unibyte text: Text Representations. (line 40) * unibyte-char-to-multibyte: Converting Representations. (line 64) * unibyte-string: Text Representations. (line 90) * Unicode: Text Representations. (line 10) * unicode character escape: General Escape Syntax. (line 10) * unicode, a charset: Character Sets. (line 16) * unintern: Creating Symbols. (line 163) * uninterned symbol: Creating Symbols. (line 39) * universal-argument: Prefix Command Arguments. (line 104) * unless: Conditionals. (line 42) * unload-feature: Unloading. (line 11) * unload-feature-special-hooks: Unloading. (line 50) * unloading packages: Unloading. (line 6) * unloading packages, preparing for: Coding Conventions. (line 97) * unlock-buffer: File Locks. (line 40) * unnumbered group: Regexp Backslash. (line 67) * unpacking: Byte Packing. (line 12) * unread-command-char: Event Input Misc. (line 45) * unread-command-events: Event Input Misc. (line 11) * unsafep: Function Safety. (line 14) * unwind-protect: Cleanups. (line 13) * unwinding: Cleanups. (line 13) * up-list: List Motion. (line 25) * upcase: Case Conversion. (line 37) * upcase-initials: Case Conversion. (line 78) * upcase-region: Case Changes. (line 43) * upcase-word: Case Changes. (line 73) * update-directory-autoloads: Autoload. (line 93) * update-file-autoloads: Autoload. (line 93) * upper case: Case Conversion. (line 6) * upper case key sequence: Key Sequence Input. (line 73) * use-global-map: Controlling Active Maps. (line 52) * use-hard-newlines: Filling. (line 170) * use-local-map: Controlling Active Maps. (line 58) * use-region-p: The Region. (line 33) * user identification: User Identification. (line 6) * user option: Defining Variables. (line 129) * user signals: Misc Events. (line 67) * user-defined error: Error Symbols. (line 6) * user-emacs-directory: Init File. (line 75) * user-full-name: User Identification. (line 46) * user-init-file: Init File. (line 70) * user-login-name: User Identification. (line 27) * user-mail-address: User Identification. (line 20) * user-real-login-name: User Identification. (line 41) * user-real-uid: User Identification. (line 68) * user-uid: User Identification. (line 75) * user-variable-p: Defining Variables. (line 129) * user-variable-p example: High-Level Completion. (line 123) * utf-8-emacs coding system: Coding System Basics. (line 65) * validity of coding system: Lisp and Coding Systems. (line 18) * value cell: Symbol Components. (line 15) * value of expression: Evaluation. (line 6) * values: Eval. (line 110) * variable: Variables. (line 6) * variable aliases: Variable Aliases. (line 6) * variable definition: Defining Variables. (line 6) * variable descriptions: A Sample Variable Description. (line 6) * variable limit error: Local Variables. (line 104) * variable with constant value: Constant Variables. (line 6) * variable, buffer-local: Buffer-Local Variables. (line 6) * variable-documentation: Documentation Basics. (line 42) * variable-interactive: Defining Variables. (line 142) * variable-width spaces: Specified Space. (line 6) * variant coding system: Coding System Basics. (line 44) * vc-mode: Mode Line Variables. (line 46) * vc-prefix-map: Prefix Keys. (line 40) * vconcat: Vector Functions. (line 33) * vector: Vector Functions. (line 17) * vector (type): Vectors. (line 6) * vector evaluation: Self-Evaluating Forms. (line 6) * vector length: Sequence Functions. (line 16) * vector-cells-consed: Memory Usage. (line 22) * vectorp: Vector Functions. (line 9) * verify-visited-file-modtime: Modification Time. (line 15) * version number (in file name): File Name Components. (line 6) * version, customization keyword: Common Keywords. (line 103) * version-control: Numbered Backups. (line 11) * vertical fractional scrolling: Vertical Scrolling. (line 6) * vertical scroll position: Vertical Scrolling. (line 6) * vertical tab: Basic Char Syntax. (line 27) * vertical-line prefix key: Key Sequence Input. (line 92) * vertical-motion: Screen Lines. (line 31) * vertical-scroll-bar: Scroll Bars. (line 20) * vertical-scroll-bar prefix key: Key Sequence Input. (line 92) * view part, model/view/controller: Abstract Display. (line 6) * view-file: Visiting Functions. (line 99) * view-mode-map: Standard Keymaps. (line 197) * view-register: Registers. (line 67) * virtual buffers: Swapping Text. (line 6) * visible frame: Visibility of Frames. (line 6) * visible-bell: Beeping. (line 21) * visible-frame-list: Finding All Frames. (line 14) * visited file: Buffer File Name. (line 6) * visited file mode: Auto Major Mode. (line 50) * visited-file-modtime: Modification Time. (line 45) * visiting files: Visiting Files. (line 6) * void function: Function Indirection. (line 6) * void function cell: Function Cells. (line 30) * void variable: Void Variables. (line 6) * void-function: Function Cells. (line 14) * void-text-area-pointer: Pointer Shape. (line 19) * void-variable: Void Variables. (line 6) * waiting: Waiting. (line 6) * waiting for command key input: Event Input Misc. (line 53) * waiting-for-user-input-p: Sentinels. (line 97) * walk-windows: Cyclic Window Ordering. (line 97) * warn: Warning Basics. (line 56) * warning type: Warning Basics. (line 36) * warning-fill-prefix: Warning Variables. (line 62) * warning-levels: Warning Variables. (line 10) * warning-minimum-level: Warning Options. (line 10) * warning-minimum-log-level: Warning Options. (line 15) * warning-prefix-function: Warning Variables. (line 26) * warning-series: Warning Variables. (line 42) * warning-suppress-log-types: Warning Options. (line 26) * warning-suppress-types: Warning Options. (line 20) * warning-type-format: Warning Variables. (line 66) * warnings: Warnings. (line 6) * wheel-down event: Misc Events. (line 28) * wheel-up event: Misc Events. (line 28) * when: Conditionals. (line 32) * where-is-internal: Scanning Keymaps. (line 77) * while: Iteration. (line 12) * while-no-input: Event Input Misc. (line 78) * whitespace: Basic Char Syntax. (line 27) * whitespace character: Syntax Class Table. (line 10) * wholenump: Predicates on Numbers. (line 28) * widen: Narrowing. (line 48) * widening: Narrowing. (line 48) * window: Basic Windows. (line 6) * window (overlay property): Overlay Properties. (line 65) * window configuration (Edebug): Edebug Display Update. (line 25) * window configurations: Window Configurations. (line 6) * window end position: Window Start and End. (line 43) * window excursions: Excursions. (line 35) * window frame: Frames. (line 21) * window header line: Header Lines. (line 6) * window internals: Window Internals. (line 6) * window layout in a frame: Window Configuration Type. (line 6) * window layout, all frames: Frame Configuration Type. (line 6) * window manager, and frame parameters: Management Parameters. (line 6) * window ordering, cyclic: Cyclic Window Ordering. (line 6) * window parameters: Window Parameters. (line 6) * window point: Window Point. (line 6) * window point internals: Window Internals. (line 59) * window position: Window Point. (line 6) * window resizing: Resizing Windows. (line 6) * window size: Size of Window. (line 6) * window size, changing: Resizing Windows. (line 6) * window splitting: Splitting Windows. (line 6) * window start position: Window Start and End. (line 6) * window that satisfies a predicate: Selecting Windows. (line 95) * window top line: Window Start and End. (line 22) * window tree: Window Tree. (line 6) * window-at: Coordinates and Windows. (line 9) * window-body-height: Size of Window. (line 32) * window-buffer: Buffers and Windows. (line 46) * window-configuration-change-hook: Window Hooks. (line 53) * window-configuration-frame: Window Configurations. (line 96) * window-configuration-p: Window Configurations. (line 83) * window-current-scroll-bars: Scroll Bars. (line 72) * window-dedicated-p: Dedicated Windows. (line 35) * window-display-table: Active Display Table. (line 13) * window-edges: Size of Window. (line 60) * window-end: Window Start and End. (line 44) * window-frame: Frames and Windows. (line 10) * window-fringes: Fringe Size/Pos. (line 41) * window-full-height-p: Size of Window. (line 36) * window-full-width-p: Size of Window. (line 55) * window-height: Size of Window. (line 15) * window-hscroll: Horizontal Scrolling. (line 73) * window-inside-edges: Size of Window. (line 78) * window-inside-pixel-edges: Size of Window. (line 131) * window-line-height: Window Start and End. (line 155) * window-list: Cyclic Window Ordering. (line 105) * window-live-p: Deleting Windows. (line 18) * window-margins: Display Margins. (line 52) * window-min-height: Resizing Windows. (line 131) * window-min-width: Resizing Windows. (line 140) * window-minibuffer-p: Minibuffer Windows. (line 29) * window-parameter: Window Parameters. (line 10) * window-parameters: Window Parameters. (line 15) * window-pixel-edges: Size of Window. (line 126) * window-point: Window Point. (line 30) * window-point-insertion-type: Window Point. (line 49) * window-scroll-bars: Scroll Bars. (line 46) * window-scroll-functions: Window Hooks. (line 14) * window-setup-hook: Window Systems. (line 46) * window-size-change-functions: Window Hooks. (line 31) * window-size-fixed: Resizing Windows. (line 106) * window-start: Window Start and End. (line 22) * window-system: Window Systems. (line 12) * window-system-initialization-alist: Startup Summary. (line 20) * window-tree: Window Tree. (line 10) * window-vscroll: Vertical Scrolling. (line 26) * window-width: Size of Window. (line 40) * windowp: Basic Windows. (line 53) * Windows file types: MS-DOS File Types. (line 6) * windows, controlling precisely: Buffers and Windows. (line 6) * with-case-table: Case Tables. (line 78) * with-coding-priority: Specifying Coding Systems. (line 67) * with-current-buffer: Current Buffer. (line 111) * with-help-window: Help Functions. (line 130) * with-local-quit: Quitting. (line 85) * with-no-warnings: Compiler Errors. (line 44) * with-output-to-string: Output Functions. (line 112) * with-output-to-temp-buffer: Temporary Displays. (line 11) * with-selected-window: Selecting Windows. (line 48) * with-syntax-table: Syntax Table Functions. (line 106) * with-temp-buffer: Current Buffer. (line 121) * with-temp-file: Writing to Files. (line 84) * with-temp-message: Displaying Messages. (line 42) * with-timeout: Timers. (line 106) * word constituent: Syntax Class Table. (line 18) * word-search-backward: String Search. (line 115) * word-search-backward-lax: String Search. (line 122) * word-search-forward: String Search. (line 67) * word-search-forward-lax: String Search. (line 109) * words-include-escapes: Word Motion. (line 37) * wrap-prefix: Truncation. (line 45) * write-abbrev-file: Abbrev Files. (line 38) * write-char: Output Functions. (line 88) * write-contents-functions: Saving Buffers. (line 112) * write-file: Saving Buffers. (line 56) * write-file-functions: Saving Buffers. (line 76) * write-region: Writing to Files. (line 26) * write-region-annotate-functions: Format Conversion Piecemeal. (line 49) * write-region-post-annotation-function: Format Conversion Piecemeal. (line 63) * writing a documentation string: Documentation Basics. (line 6) * writing Emacs primitives: Writing Emacs Primitives. (line 6) * writing to files: Writing to Files. (line 6) * wrong-number-of-arguments: Argument List. (line 6) * wrong-type-argument: Type Predicates. (line 6) * X Window System: Window Systems. (line 16) * x-alt-keysym: X11 Keysyms. (line 30) * x-bitmap-file-path: Face Attributes. (line 192) * x-close-connection: Multiple Terminals. (line 136) * x-color-defined-p: Color Names. (line 38) * x-color-values: Color Names. (line 94) * x-defined-colors: Color Names. (line 46) * x-display-color-p: Display Feature Testing. (line 35) * x-display-list: Multiple Terminals. (line 111) * x-dnd-known-types: Drag and Drop. (line 6) * x-dnd-test-function: Drag and Drop. (line 6) * x-dnd-types-alist: Drag and Drop. (line 15) * x-family-fonts: Font Lookup. (line 31) * x-get-cut-buffer: Window System Selections. (line 52) * x-get-resource: Resources. (line 13) * x-get-selection: Window System Selections. (line 33) * x-hyper-keysym: X11 Keysyms. (line 32) * x-list-fonts: Font Lookup. (line 8) * x-meta-keysym: X11 Keysyms. (line 31) * x-open-connection: Multiple Terminals. (line 117) * x-parse-geometry: Geometry. (line 10) * x-pointer-shape: Pointer Shape. (line 28) * x-popup-dialog: Dialog Boxes. (line 16) * x-popup-menu: Pop-Up Menus. (line 10) * x-resource-class: Resources. (line 27) * x-resource-name: Resources. (line 33) * x-select-enable-clipboard: Window System Selections. (line 77) * x-sensitive-text-pointer-shape: Pointer Shape. (line 32) * x-server-vendor: Display Feature Testing. (line 148) * x-server-version: Display Feature Testing. (line 141) * x-set-cut-buffer: Window System Selections. (line 56) * x-set-selection: Window System Selections. (line 13) * x-super-keysym: X11 Keysyms. (line 33) * X11 keysyms: X11 Keysyms. (line 6) * XBM: XBM Images. (line 6) * XPM: XPM Images. (line 6) * y-or-n-p: Yes-or-No Queries. (line 24) * y-or-n-p-with-timeout: Yes-or-No Queries. (line 78) * yank: Yank Commands. (line 12) * yank suppression: Changing Key Bindings. (line 159) * yank-pop: Yank Commands. (line 35) * yank-undo-function: Yank Commands. (line 58) * yes-or-no questions: Yes-or-No Queries. (line 6) * yes-or-no-p: Yes-or-No Queries. (line 84) * zerop: Predicates on Numbers. (line 36) * | in regexp: Regexp Backslash. (line 13)