Freeware (IRIX)  »  Info Pages
find in page

elisp : Coding Conventions

table of contents

  Introduction
  Coding Conventions
  Lisp Data Types
  Numbers
  Strings and Characters
  Lists
  Sequences Arrays Vectors
  Hash Tables
  Symbols
  Evaluation
  Control Structures
  Variables
  Functions
  Macros
  Customization
  Loading
  Byte Compilation
  Advising Functions
  Debugging
  Read and Print
  Minibuffers
  Command Loop
  Keymaps
  Modes
  Documentation
  Files
  Backups and Auto-Saving
  Buffers
  Windows
  Frames
  Positions
  Markers
  Text
  Non-ASCII Characters
  Searching and Matching
  Syntax Tables
  Abbrevs
  Processes
  Display
  Calendar
  System Interface
  Antinews
  GNU Free Documentation License
  GPL
  Tips
  GNU Emacs Internals
  Standard Errors
  Standard Buffer-Local Variables
  Standard Keymaps
  Standard Hooks
  Index
  New Symbols
  Caveats
  Lisp History
  Conventions
  Acknowledgements
  Some Terms
  nil and t
  Evaluation Notation
  Printing Notation
  Error Messages
  Buffer Text Notation
  Format of Descriptions
  Coding Conventions
  Compilation Tips
  Documentation Tips
  Comment Tips
  Library Headers
  A Sample Function Description
  A Sample Variable Description
  Printed Representation
  Comments
  Programming Types
  Editing Types
  Type Predicates
  Equality Predicates
  Integer Type
  Floating Point Type
  Character Type
  Sequence Type
  Cons Cell Type
  Array Type
  String Type
  Vector Type
  Symbol Type
  Function Type
  Macro Type
  Primitive Function Type
  Byte-Code Type
  Autoload Type
  Dotted Pair Notation
  Association List Type
  Buffer Type
  Window Type
  Window Configuration Type
  Marker Type
  Process Type
  Stream Type
  Keymap Type
  Overlay Type
  Integer Basics
  Float Basics
  Predicates on Numbers
  Comparison of Numbers
  Arithmetic Operations
  Bitwise Operations
  Numeric Conversions
  Math Functions
  Random Numbers
  String Basics
  Predicates for Strings
  Creating Strings
  Text Comparison
  String Conversion
  Formatting Strings
  Case Conversion
  Cons Cells
  Lists as Boxes
  List-related Predicates
  List Elements
  Building Lists
  Modifying Lists
  Sets And Lists
  Association Lists
  Setcar
  Setcdr
  Rearrangement
  Sequence Functions
  Arrays
  Array Functions
  Vectors
  Symbol Components
  Definitions
  Creating Symbols
  Property Lists
  Intro Eval
  Eval
  Forms
  Quoting
  Self-Evaluating Forms
  Symbol Forms
  Classifying Lists
  Function Forms
  Macro Forms
  Special Forms
  Autoloading
  Sequencing
  Conditionals
  Combining Conditions
  Iteration
  Nonlocal Exits
  Catch and Throw
  Examples of Catch
  Errors
  Cleanups
  Signaling Errors
  Processing of Errors
  Handling Errors
  Error Symbols
  Global Variables
  Constant Variables
  Local Variables
  Void Variables
  Defining Variables
  Accessing Variables
  Setting Variables
  Variable Scoping
  Buffer-Local Variables
  Scope
  Extent
  Impl of Scope
  Using Scoping
  Intro to Buffer-Local
  Creating Buffer-Local
  Default Value
  What Is a Function
  Lambda Expressions
  Function Names
  Defining Functions
  Calling Functions
  Mapping Functions
  Anonymous Functions
  Function Cells
  Related Topics
  Lambda Components
  Simple Lambda
  Argument List
  Function Documentation
  Simple Macro
  Expansion
  Compiling Macros
  Defining Macros
  Backquote
  Problems with Macros
  How Programs Do Loading
  Autoload
  Named Features
  Repeated Loading
  Compilation Functions
  Disassembly
  Simple Advice
  Defining Advice
  Computed Advice
  Activation of Advice
  Enabling Advice
  Preactivation
  Argument Access in Advice
  Subr Arguments
  Combined Definition
  Debugger
  Syntax Errors
  Compilation Errors
  Edebug
  Error Debugging
  Function Debugging
  Explicit Debug
  Using Debugger
  Debugger Commands
  Invoking the Debugger
  Internals of Debugger
  Excess Open
  Excess Close
  Streams Intro
  Input Streams
  Input Functions
  Output Streams
  Output Functions
  Intro to Minibuffers
  Text from Minibuffer
  Object from Minibuffer
  Completion
  Yes-or-No Queries
  Minibuffer Misc
  Basic Completion
  Minibuffer Completion
  Completion Commands
  High-Level Completion
  Reading File Names
  Programmed Completion
  Command Overview
  Defining Commands
  Interactive Call
  Command Loop Info
  Input Events
  Reading Input
  Waiting
  Quitting
  Prefix Command Arguments
  Recursive Editing
  Disabling Commands
  Command History
  Keyboard Macros
  Using Interactive
  Interactive Codes
  Interactive Examples
  Keymap Terminology
  Format of Keymaps
  Creating Keymaps
  Inheritance and Keymaps
  Prefix Keys
  Menu Keymaps
  Active Keymaps
  Key Lookup
  Functions for Key Lookup
  Changing Key Bindings
  Key Binding Commands
  Scanning Keymaps
  Major Modes
  Minor Modes
  Mode Line Format
  Hooks
  Major Mode Conventions
  Example Major Modes
  Auto Major Mode
  Mode Help
  Minor Mode Conventions
  Keymaps and Minor Modes
  Mode Line Data
  Mode Line Variables
  %-Constructs
  Documentation Basics
  Accessing Documentation
  Keys in Documentation
  Describing Characters
  Help Functions
  Visiting Files
  Saving Buffers
  Reading from Files
  Writing to Files
  File Locks
  Information about Files
  Contents of Directories
  Changing Files
  File Names
  Visiting Functions
  Subroutines of Visiting
  Testing Accessibility
  Kinds of Files
  File Attributes
  File Name Components
  Directory Names
  Relative File Names
  File Name Expansion
  Unique File Names
  File Name Completion
  Backup Files
  Auto-Saving
  Reverting
  Making Backups
  Rename or Copy
  Numbered Backups
  Backup Names
  Buffer Basics
  Buffer Names
  Buffer File Name
  Buffer Modification
  Modification Time
  Read Only Buffers
  The Buffer List
  Creating Buffers
  Killing Buffers
  Current Buffer
  Basic Windows
  Splitting Windows
  Deleting Windows
  Selecting Windows
  Cyclic Window Ordering
  Buffers and Windows
  Displaying Buffers
  Window Point
  Window Start
  Vertical Scrolling
  Horizontal Scrolling
  Size of Window
  Resizing Windows
  Window Configurations
  Creating Frames
  Multiple Displays
  Frame Parameters
  Frame Titles
  Deleting Frames
  Finding All Frames
  Frames and Windows
  Minibuffers and Frames
  Input Focus
  Visibility of Frames
  Raising and Lowering
  Frame Configurations
  Mouse Tracking
  Mouse Position
  Pop-Up Menus
  Dialog Boxes
  Pointer Shapes
  Window System Selections
  Color Names
  Resources
  Display Feature Testing
  Point
  Motion
  Excursions
  Narrowing
  Character Motion
  Word Motion
  Buffer End Motion
  Text Lines
  Screen Lines
  List Motion
  Skipping Characters
  Overview of Markers
  Predicates on Markers
  Creating Markers
  Information from Markers
  Moving Markers
  The Mark
  The Region
  Near Point
  Buffer Contents
  Insertion
  Commands for Insertion
  Deletion
  User-Level Deletion
  The Kill Ring
  Undo
  Auto Filling
  Filling
  Margins
  Sorting
  Indentation
  Columns
  Case Changes
  Text Properties
  Substitution
  Transposition
  Registers
  Change Hooks
  Kill Ring Concepts
  Kill Functions
  Yank Commands
  Low-Level Kill Ring
  Internals of Kill Ring
  Primitive Indent
  Mode-Specific Indent
  Region Indent
  Relative Indent
  Indent Tabs
  Motion by Indent
  Examining Properties
  Changing Properties
  Property Search
  Special Properties
  Format Properties
  Sticky Properties
  Saving Properties
  Lazy Properties
  Clickable Text
  Fields
  Not Intervals
  Text Representations
  Converting Representations
  Selecting a Representation
  Character Codes
  Character Sets
  Chars and Bytes
  Splitting Characters
  Scanning Charsets
  Translation of Characters
  Coding Systems
  Input Methods
  Locales
  String Search
  Regular Expressions
  Regexp Search
  Match Data
  Saving Match Data
  Standard Regexps
  Searching and Case
  Syntax of Regexps
  Regexp Example
  Syntax Descriptors
  Syntax Table Functions
  Parsing Expressions
  Standard Syntax Tables
  Syntax Table Internals
  Syntax Class Table
  Syntax Flags
  Abbrev Mode
  Abbrev Tables
  Defining Abbrevs
  Abbrev Files
  Abbrev Expansion
  Standard Abbrev Tables
  Subprocess Creation
  Synchronous Processes
  Asynchronous Processes
  Deleting Processes
  Process Information
  Input to Processes
  Signals to Processes
  Output from Processes
  Sentinels
  Network
  Process Buffers
  Filter Functions
  Accepting Output
  Starting Up
  Getting Out
  System Environment
  Terminal Input
  Terminal Output
  Flow Control
  Batch Mode
  Startup Summary
  Init File
  Terminal-Specific
  Command-Line Arguments
  Killing Emacs
  Suspending Emacs
  Refresh Screen
  Truncation
  The Echo Area
  Selective Display
  Overlay Arrow
  Temporary Displays
  Waiting
  Blinking
  Usual Display
  Beeping
  Window Systems
  Building Emacs
  Pure Storage
  Garbage Collection
  Object Internals
  Writing Emacs Primitives
  Buffer Internals
  Window Internals
  Process Internals

Emacs Lisp Coding Conventions
=============================

   Here are conventions that you should follow when writing Emacs Lisp
code intended for widespread use:

   * Since all global variables share the same name space, and all
     functions share another name space, you should choose a short word
     to distinguish your program from other Lisp programs.(1)  Then
     take care to begin the names of all global variables, constants,
     and functions in your program with the chosen prefix.  This helps
     avoid name conflicts.

     This recommendation applies even to names for traditional Lisp
     primitives that are not primitives in Emacs Lisp--even to
     `copy-list'.  Believe it or not, there is more than one plausible
     way to define `copy-list'.  Play it safe; append your name prefix
     to produce a name like `foo-copy-list' or `mylib-copy-list'
     instead.

     If you write a function that you think ought to be added to Emacs
     under a certain name, such as `twiddle-files', don't call it by
     that name in your program.  Call it `mylib-twiddle-files' in your
     program, and send mail to `bug-gnu-emacs@gnu.org' suggesting we add
     it to Emacs.  If and when we do, we can change the name easily
     enough.

     If one prefix is insufficient, your package may use two or three
     alternative common prefixes, so long as they make sense.

     Separate the prefix from the rest of the symbol name with a hyphen,
     `-'.  This will be consistent with Emacs itself and with most Emacs
     Lisp programs.

   * It is often useful to put a call to `provide' in each separate
     library program, at least if there is more than one entry point to
     the program.

   * If a file requires certain other library programs to be loaded
     beforehand, then the comments at the beginning of the file should
     say so.  Also, use `require' to make sure they are loaded.

   * If one file FOO uses a macro defined in another file BAR, FOO
     should contain this expression before the first use of the macro:

          (eval-when-compile (require 'BAR))

     (And the library BAR should contain `(provide 'BAR)', to make the
     `require' work.)  This will cause BAR to be loaded when you
     byte-compile FOO.  Otherwise, you risk compiling FOO without the
     necessary macro loaded, and that would produce compiled code that
     won't work right.  *Note Compiling Macros::.

     Using `eval-when-compile' avoids loading BAR when the compiled
     version of FOO is _used_.

   * Please don't require the `cl' package of Common Lisp extensions at
     run time.  Use of this package is optional, and it is not part of
     the standard Emacs namespace.  If your package loads `cl' at run
     time, that could cause name clashes for users who don't use that
     package.

     However, there is no problem with using the `cl' package at compile
     time, for the sake of macros.  You do that like this:

          (eval-when-compile (require 'cl))

   * When defining a major mode, please follow the major mode
     conventions.  *Note Major Mode Conventions::.

   * When defining a minor mode, please follow the minor mode
     conventions.  *Note Minor Mode Conventions::.

   * If the purpose of a function is to tell you whether a certain
     condition is true or false, give the function a name that ends in
     `p'.  If the name is one word, add just `p'; if the name is
     multiple words, add `-p'.  Examples are `framep' and
     `frame-live-p'.

   * If a user option variable records a true-or-false condition, give
     it a name that ends in `-flag'.

   * Please do not define `C-c LETTER' as a key in your major modes.
     These sequences are reserved for users; they are the *only*
     sequences reserved for users, so do not block them.

     Instead, define sequences consisting of `C-c' followed by a control
     character, a digit, or certain punctuation characters.  These
     sequences are reserved for major modes.

     Changing all the Emacs major modes to follow this convention was a
     lot of work.  Abandoning this convention would make that work go
     to waste, and inconvenience users.

   * Sequences consisting of `C-c' followed by `{', `}', `<', `>', `:'
     or `;' are also reserved for major modes.

   * Sequences consisting of `C-c' followed by any other punctuation
     character are allocated for minor modes.  Using them in a major
     mode is not absolutely prohibited, but if you do that, the major
     mode binding may be shadowed from time to time by minor modes.

   * Function keys  through  without modifier keys are reserved
     for users to define.

   * Do not bind `C-h' following any prefix character (including
     `C-c').  If you don't bind `C-h', it is automatically available as
     a help character for listing the subcommands of the prefix
     character.

   * Do not bind a key sequence ending in  except following
     another .  (That is, it is OK to bind a sequence ending in
     ` '.)

     The reason for this rule is that a non-prefix binding for  in
     any context prevents recognition of escape sequences as function
     keys in that context.

   * Anything which acts like a temporary mode or state which the user
     can enter and leave should define ` ' or ` 
     ' as a way to escape.

     For a state which accepts ordinary Emacs commands, or more
     generally any kind of state in which  followed by a function
     key or arrow key is potentially meaningful, then you must not
     define ` ', since that would preclude recognizing an
     escape sequence after .  In these states, you should define
     `  ' as the way to escape.  Otherwise, define
     ` ' instead.

   * Applications should not bind mouse events based on button 1 with
     the shift key held down.  These events include `S-mouse-1',
     `M-S-mouse-1', `C-S-mouse-1', and so on.  They are reserved for
     users.

   * Special major modes used for read-only text should usually redefine
     `mouse-2' and  to trace some sort of reference in the text.
     Modes such as Dired, Info, Compilation, and Occur redefine it in
     this way.

   * When a package provides a modification of ordinary Emacs behavior,
     it is good to include a command to enable and disable the feature,
     Provide a command named `WHATEVER-mode' which turns the feature on
     or off, and make it autoload (*note Autoload::).  Design the
     package so that simply loading it has no visible effect--that
     should not enable the feature.(2)  Users will request the feature
     by invoking the command.

   * It is a bad idea to define aliases for the Emacs primitives.  Use
     the standard names instead.

   * If a package needs to define an alias or a new function for
     compatibility with some other version of Emacs, name it with the
     package prefix, not with the raw name with which it occurs in the
     other version.  Here is an example from Gnus, which provides many
     examples of such compatibility issues.

          (defalias 'gnus-point-at-bol
            (if (fboundp 'point-at-bol)
                'point-at-bol
              'line-beginning-position))

   * Redefining (or advising) an Emacs primitive is discouraged.  It
     may do the right thing for a particular program, but there is no
     telling what other programs might break as a result.

   * If a file does replace any of the functions or library programs of
     standard Emacs, prominent comments at the beginning of the file
     should say which functions are replaced, and how the behavior of
     the replacements differs from that of the originals.

   * Please keep the names of your Emacs Lisp source files to 13
     characters or less.  This way, if the files are compiled, the
     compiled files' names will be 14 characters or less, which is
     short enough to fit on all kinds of Unix systems.

   * Don't use `next-line' or `previous-line' in programs; nearly
     always, `forward-line' is more convenient as well as more
     predictable and robust.  *Note Text Lines::.

   * Don't call functions that set the mark, unless setting the mark is
     one of the intended features of your program.  The mark is a
     user-level feature, so it is incorrect to change the mark except
     to supply a value for the user's benefit.  *Note The Mark::.

     In particular, don't use any of these functions:

        * `beginning-of-buffer', `end-of-buffer'

        * `replace-string', `replace-regexp'

     If you just want to move point, or replace a certain string,
     without any of the other features intended for interactive users,
     you can replace these functions with one or two lines of simple
     Lisp code.

   * Use lists rather than vectors, except when there is a particular
     reason to use a vector.  Lisp has more facilities for manipulating
     lists than for vectors, and working with lists is usually more
     convenient.

     Vectors are advantageous for tables that are substantial in size
     and are accessed in random order (not searched front to back),
     provided there is no need to insert or delete elements (only lists
     allow that).

   * The recommended way to print a message in the echo area is with
     the `message' function, not `princ'.  *Note The Echo Area::.

   * When you encounter an error condition, call the function `error'
     (or `signal').  The function `error' does not return.  *Note
     Signaling Errors::.

     Do not use `message', `throw', `sleep-for', or `beep' to report
     errors.

   * An error message should start with a capital letter but should not
     end with a period.

   * In `interactive', if you use a Lisp expression to produce a list
     of arguments, don't try to provide the "correct" default values for
     region or position arguments.  Instead, provide `nil' for those
     arguments if they were not specified, and have the function body
     compute the default value when the argument is `nil'.  For
     instance, write this:

          (defun foo (pos)
            (interactive
             (list (if SPECIFIED SPECIFIED-POS)))
            (unless pos (setq pos DEFAULT-POS))
            ...)

     rather than this:

          (defun foo (pos)
            (interactive
             (list (if SPECIFIED SPECIFIED-POS
                       DEFAULT-POS)))
            ...)

     This is so that repetition of the command will recompute these
     defaults based on the current circumstances.

     You do not need to take such precautions when you use interactive
     specs `d', `m' and `r', because they make special arrangements to
     recompute the argument values on repetition of the command.

   * Many commands that take a long time to execute display a message
     that says something like `Operating...' when they start, and
     change it to `Operating...done' when they finish.  Please keep the
     style of these messages uniform: _no_ space around the ellipsis,
     and _no_ period after `done'.

   * Try to avoid using recursive edits.  Instead, do what the Rmail `e'
     command does: use a new local keymap that contains one command
     defined to switch back to the old local keymap.  Or do what the
     `edit-options' command does: switch to another buffer and let the
     user switch back at will.  *Note Recursive Editing::.

   * In some other systems there is a convention of choosing variable
     names that begin and end with `*'.  We don't use that convention
     in Emacs Lisp, so please don't use it in your programs.  (Emacs
     uses such names only for special-purpose buffers.)  The users will
     find Emacs more coherent if all libraries use the same conventions.

   * Try to avoid compiler warnings about undefined free variables, by
     adding `defvar' definitions for these variables.

     Sometimes adding a `require' for another package is useful to avoid
     compilation warnings for variables and functions defined in that
     package.  If you do this, often it is better if the `require' acts
     only at compile time.  Here's how to do that:

          (eval-when-compile
            (require 'foo)
            (defvar bar-baz))

     If you bind a variable in one function, and use it or set it in
     another function, the compiler warns about the latter function
     unless the variable has a definition.  But often these variables
     have short names, and it is not clean for Lisp packages to define
     such variable names.  Therefore, you should rename the variable to
     start with the name prefix used for the other functions and
     variables in your package.

   * Indent each function with `C-M-q' (`indent-sexp') using the
     default indentation parameters.

   * Don't make a habit of putting close-parentheses on lines by
     themselves; Lisp programmers find this disconcerting.  Once in a
     while, when there is a sequence of many consecutive
     close-parentheses, it may make sense to split the sequence in one
     or two significant places.

   * Please put a copyright notice on the file if you give copies to
     anyone.  Use a message like this one:

          ;; Copyright (C) YEAR NAME
          
          ;; This program is free software; you can redistribute it and/or
          ;; modify it under the terms of the GNU General Public License as
          ;; published by the Free Software Foundation; either version 2 of
          ;; the License, or (at your option) any later version.
          
          ;; This program is distributed in the hope that it will be
          ;; useful, but WITHOUT ANY WARRANTY; without even the implied
          ;; warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
          ;; PURPOSE.  See the GNU General Public License for more details.
          
          ;; You should have received a copy of the GNU General Public
          ;; License along with this program; if not, write to the Free
          ;; Software Foundation, Inc., 59 Temple Place, Suite 330, Boston,
          ;; MA 02111-1307 USA

     If you have signed papers to assign the copyright to the
     Foundation, then use `Free Software Foundation, Inc.' as NAME.
     Otherwise, use your name.

   ---------- Footnotes ----------

   (1) The benefits of a Common Lisp-style package system are
considered not to outweigh the costs.

   (2) Consider that the package may be loaded arbitrarily by Custom
for instance.

back to top
elisp : Coding Conventions

table of contents

  Introduction
  Coding Conventions
  Lisp Data Types
  Numbers
  Strings and Characters
  Lists
  Sequences Arrays Vectors
  Hash Tables
  Symbols
  Evaluation
  Control Structures
  Variables
  Functions
  Macros
  Customization
  Loading
  Byte Compilation
  Advising Functions
  Debugging
  Read and Print
  Minibuffers
  Command Loop
  Keymaps
  Modes
  Documentation
  Files
  Backups and Auto-Saving
  Buffers
  Windows
  Frames
  Positions
  Markers
  Text
  Non-ASCII Characters
  Searching and Matching
  Syntax Tables
  Abbrevs
  Processes
  Display
  Calendar
  System Interface
  Antinews
  GNU Free Documentation License
  GPL
  Tips
  GNU Emacs Internals
  Standard Errors
  Standard Buffer-Local Variables
  Standard Keymaps
  Standard Hooks
  Index
  New Symbols
  Caveats
  Lisp History
  Conventions
  Acknowledgements
  Some Terms
  nil and t
  Evaluation Notation
  Printing Notation
  Error Messages
  Buffer Text Notation
  Format of Descriptions
  Coding Conventions
  Compilation Tips
  Documentation Tips
  Comment Tips
  Library Headers
  A Sample Function Description
  A Sample Variable Description
  Printed Representation
  Comments
  Programming Types
  Editing Types
  Type Predicates
  Equality Predicates
  Integer Type
  Floating Point Type
  Character Type
  Sequence Type
  Cons Cell Type
  Array Type
  String Type
  Vector Type
  Symbol Type
  Function Type
  Macro Type
  Primitive Function Type
  Byte-Code Type
  Autoload Type
  Dotted Pair Notation
  Association List Type
  Buffer Type
  Window Type
  Window Configuration Type
  Marker Type
  Process Type
  Stream Type
  Keymap Type
  Overlay Type
  Integer Basics
  Float Basics
  Predicates on Numbers
  Comparison of Numbers
  Arithmetic Operations
  Bitwise Operations
  Numeric Conversions
  Math Functions
  Random Numbers
  String Basics
  Predicates for Strings
  Creating Strings
  Text Comparison
  String Conversion
  Formatting Strings
  Case Conversion
  Cons Cells
  Lists as Boxes
  List-related Predicates
  List Elements
  Building Lists
  Modifying Lists
  Sets And Lists
  Association Lists
  Setcar
  Setcdr
  Rearrangement
  Sequence Functions
  Arrays
  Array Functions
  Vectors
  Symbol Components
  Definitions
  Creating Symbols
  Property Lists
  Intro Eval
  Eval
  Forms
  Quoting
  Self-Evaluating Forms
  Symbol Forms
  Classifying Lists
  Function Forms
  Macro Forms
  Special Forms
  Autoloading
  Sequencing
  Conditionals
  Combining Conditions
  Iteration
  Nonlocal Exits
  Catch and Throw
  Examples of Catch
  Errors
  Cleanups
  Signaling Errors
  Processing of Errors
  Handling Errors
  Error Symbols
  Global Variables
  Constant Variables
  Local Variables
  Void Variables
  Defining Variables
  Accessing Variables
  Setting Variables
  Variable Scoping
  Buffer-Local Variables
  Scope
  Extent
  Impl of Scope
  Using Scoping
  Intro to Buffer-Local
  Creating Buffer-Local
  Default Value
  What Is a Function
  Lambda Expressions
  Function Names
  Defining Functions
  Calling Functions
  Mapping Functions
  Anonymous Functions
  Function Cells
  Related Topics
  Lambda Components
  Simple Lambda
  Argument List
  Function Documentation
  Simple Macro
  Expansion
  Compiling Macros
  Defining Macros
  Backquote
  Problems with Macros
  How Programs Do Loading
  Autoload
  Named Features
  Repeated Loading
  Compilation Functions
  Disassembly
  Simple Advice
  Defining Advice
  Computed Advice
  Activation of Advice
  Enabling Advice
  Preactivation
  Argument Access in Advice
  Subr Arguments
  Combined Definition
  Debugger
  Syntax Errors
  Compilation Errors
  Edebug
  Error Debugging
  Function Debugging
  Explicit Debug
  Using Debugger
  Debugger Commands
  Invoking the Debugger
  Internals of Debugger
  Excess Open
  Excess Close
  Streams Intro
  Input Streams
  Input Functions
  Output Streams
  Output Functions
  Intro to Minibuffers
  Text from Minibuffer
  Object from Minibuffer
  Completion
  Yes-or-No Queries
  Minibuffer Misc
  Basic Completion
  Minibuffer Completion
  Completion Commands
  High-Level Completion
  Reading File Names
  Programmed Completion
  Command Overview
  Defining Commands
  Interactive Call
  Command Loop Info
  Input Events
  Reading Input
  Waiting
  Quitting
  Prefix Command Arguments
  Recursive Editing
  Disabling Commands
  Command History
  Keyboard Macros
  Using Interactive
  Interactive Codes
  Interactive Examples
  Keymap Terminology
  Format of Keymaps
  Creating Keymaps
  Inheritance and Keymaps
  Prefix Keys
  Menu Keymaps
  Active Keymaps
  Key Lookup
  Functions for Key Lookup
  Changing Key Bindings
  Key Binding Commands
  Scanning Keymaps
  Major Modes
  Minor Modes
  Mode Line Format
  Hooks
  Major Mode Conventions
  Example Major Modes
  Auto Major Mode
  Mode Help
  Minor Mode Conventions
  Keymaps and Minor Modes
  Mode Line Data
  Mode Line Variables
  %-Constructs
  Documentation Basics
  Accessing Documentation
  Keys in Documentation
  Describing Characters
  Help Functions
  Visiting Files
  Saving Buffers
  Reading from Files
  Writing to Files
  File Locks
  Information about Files
  Contents of Directories
  Changing Files
  File Names
  Visiting Functions
  Subroutines of Visiting
  Testing Accessibility
  Kinds of Files
  File Attributes
  File Name Components
  Directory Names
  Relative File Names
  File Name Expansion
  Unique File Names
  File Name Completion
  Backup Files
  Auto-Saving
  Reverting
  Making Backups
  Rename or Copy
  Numbered Backups
  Backup Names
  Buffer Basics
  Buffer Names
  Buffer File Name
  Buffer Modification
  Modification Time
  Read Only Buffers
  The Buffer List
  Creating Buffers
  Killing Buffers
  Current Buffer
  Basic Windows
  Splitting Windows
  Deleting Windows
  Selecting Windows
  Cyclic Window Ordering
  Buffers and Windows
  Displaying Buffers
  Window Point
  Window Start
  Vertical Scrolling
  Horizontal Scrolling
  Size of Window
  Resizing Windows
  Window Configurations
  Creating Frames
  Multiple Displays
  Frame Parameters
  Frame Titles
  Deleting Frames
  Finding All Frames
  Frames and Windows
  Minibuffers and Frames
  Input Focus
  Visibility of Frames
  Raising and Lowering
  Frame Configurations
  Mouse Tracking
  Mouse Position
  Pop-Up Menus
  Dialog Boxes
  Pointer Shapes
  Window System Selections
  Color Names
  Resources
  Display Feature Testing
  Point
  Motion
  Excursions
  Narrowing
  Character Motion
  Word Motion
  Buffer End Motion
  Text Lines
  Screen Lines
  List Motion
  Skipping Characters
  Overview of Markers
  Predicates on Markers
  Creating Markers
  Information from Markers
  Moving Markers
  The Mark
  The Region
  Near Point
  Buffer Contents
  Insertion
  Commands for Insertion
  Deletion
  User-Level Deletion
  The Kill Ring
  Undo
  Auto Filling
  Filling
  Margins
  Sorting
  Indentation
  Columns
  Case Changes
  Text Properties
  Substitution
  Transposition
  Registers
  Change Hooks
  Kill Ring Concepts
  Kill Functions
  Yank Commands
  Low-Level Kill Ring
  Internals of Kill Ring
  Primitive Indent
  Mode-Specific Indent
  Region Indent
  Relative Indent
  Indent Tabs
  Motion by Indent
  Examining Properties
  Changing Properties
  Property Search
  Special Properties
  Format Properties
  Sticky Properties
  Saving Properties
  Lazy Properties
  Clickable Text
  Fields
  Not Intervals
  Text Representations
  Converting Representations
  Selecting a Representation
  Character Codes
  Character Sets
  Chars and Bytes
  Splitting Characters
  Scanning Charsets
  Translation of Characters
  Coding Systems
  Input Methods
  Locales
  String Search
  Regular Expressions
  Regexp Search
  Match Data
  Saving Match Data
  Standard Regexps
  Searching and Case
  Syntax of Regexps
  Regexp Example
  Syntax Descriptors
  Syntax Table Functions
  Parsing Expressions
  Standard Syntax Tables
  Syntax Table Internals
  Syntax Class Table
  Syntax Flags
  Abbrev Mode
  Abbrev Tables
  Defining Abbrevs
  Abbrev Files
  Abbrev Expansion
  Standard Abbrev Tables
  Subprocess Creation
  Synchronous Processes
  Asynchronous Processes
  Deleting Processes
  Process Information
  Input to Processes
  Signals to Processes
  Output from Processes
  Sentinels
  Network
  Process Buffers
  Filter Functions
  Accepting Output
  Starting Up
  Getting Out
  System Environment
  Terminal Input
  Terminal Output
  Flow Control
  Batch Mode
  Startup Summary
  Init File
  Terminal-Specific
  Command-Line Arguments
  Killing Emacs
  Suspending Emacs
  Refresh Screen
  Truncation
  The Echo Area
  Selective Display
  Overlay Arrow
  Temporary Displays
  Waiting
  Blinking
  Usual Display
  Beeping
  Window Systems
  Building Emacs
  Pure Storage
  Garbage Collection
  Object Internals
  Writing Emacs Primitives
  Buffer Internals
  Window Internals
  Process Internals