| • Copying: | Conditions for copying and changing GNU Emacs. | |
| • Introduction: | Introduction and conventions used. | |
| • Standards: | Coding conventions for Emacs Lisp. | |
| • Lisp Data Types: | Data types of objects in Emacs Lisp. | |
| • Numbers: | Numbers and arithmetic functions. | |
| • Strings and Characters: | Strings, and functions that work on them. | |
| • Lists: | Lists, cons cells, and related functions. | |
| • Sequences Arrays Vectors: | Lists, strings and vectors are called sequences. Certain functions act on any kind of sequence. The description of vectors is here as well. | |
| • Symbols: | Symbols represent names, uniquely. | |
| • Evaluation: | How Lisp expressions are evaluated. | |
| • Control Structures: | Conditionals, loops, nonlocal exits. | |
| • Variables: | Using symbols in programs to stand for values. | |
| • Functions: | A function is a Lisp program that can be invoked from other functions. | |
| • Macros: | Macros are a way to extend the Lisp language. | |
| • Customization: | Writing customization declarations. | |
| • Loading: | Reading files of Lisp code into Lisp. | |
| • Byte Compilation: | Compilation makes programs run faster. | |
| • Advising Functions: | Adding to the definition of a function. | |
| • Debugging: | Tools and tips for debugging Lisp programs. | |
| • Read and Print: | Converting Lisp objects to text and back. | |
| • Minibuffers: | Using the minibuffer to read input. | |
| • Command Loop: | How the editor command loop works, and how you can call its subroutines. | |
| • Keymaps: | Defining the bindings from keys to commands. | |
| • Modes: | Defining major and minor modes. | |
| • Documentation: | Writing and using documentation strings. | |
| • Files: | Accessing files. | |
| • Backups and Auto-Saving: | Controlling how backups and auto-save files are made. | |
| • Buffers: | Creating and using buffer objects. | |
| • Windows: | Manipulating windows and displaying buffers. | |
| • Frames: | Making multiple X windows. | |
| • Positions: | Buffer positions and motion functions. | |
| • Markers: | Markers represent positions and update automatically when the text is changed. | |
| • Text: | Examining and changing text in buffers. | |
| • Non-ASCII Characters: | Non-ASCII text in buffers and strings. | |
| • Searching and Matching: | Searching buffers for strings or regexps. | |
| • Syntax Tables: | The syntax table controls word and list parsing. | |
| • Abbrevs: | How Abbrev mode works, and its data structures. | |
| • Processes: | Running and communicating with subprocesses. | |
| • System Interface: | Getting the user id, system type, environment variables, and other such things. | |
| • Display: | Parameters controlling screen usage. The bell. Waiting for input. | |
| • Calendar: | Customizing the calendar and diary. | |
ÉÕÏ¿ | ||
| • Tips: | Advice and coding conventions for Emacs Lisp. | |
| • GNU Emacs Internals: | Building and dumping Emacs; internal data structures. | |
| • Standard Errors: | List of all error symbols. | |
| • Standard Buffer-Local Variables: | List of variables buffer-local in all buffers. | |
| • Standard Keymaps: | List of standard keymaps. | |
| • Standard Hooks: | List of standard hook variables. | |
| • Index: | Index including concepts, functions, variables, and other terms. | |
| • New Symbols: | New functions and variables in Emacs 20. | |
¡Ý¡Ý¡Ý ¾ÜºÙ¥Î¡¼¥É°ìÍ÷ ¡Ý¡Ý¡Ý
°Ê²¼¤Ï¡¢¾å¤Ë¤¢¤²¤¿¥Î¡¼¥É¤Î²¼°Ì¥Î¡¼¥É¤Ç¤¹¡£
ľÀÜ°ÜÆ°¤Ç¤¤ë¤è¤¦¤Ë·ÇºÜ¤·¤Æ¤ª¤¤Þ¤¹¡£
ƳÆþ
| ||
| • Caveats: | Flaws and a request for help. | |
| • Lisp History: | Emacs Lisp is descended from Maclisp. | |
| • Conventions: | How the manual is formatted. | |
| • Acknowledgements: | The authors, editors, and sponsors of this manual. | |
´·½¬ | ||
| • Some Terms: | Explanation of terms we use in this manual. | |
| • nil and t: | How the symbols nil and t are used.
| |
| • Evaluation Notation: | The format we use for examples of evaluation. | |
| • Printing Notation: | The format we use for examples that print output. | |
| • Error Messages: | The format we use for examples of errors. | |
| • Buffer Text Notation: | The format we use for buffer contents in examples. | |
| • Format of Descriptions: | Notation for describing functions, variables, etc. | |
¥Ò¥ó¥È¤È´·½¬ | ||
| • Coding Conventions: | Conventions for clean and robust programs. | |
| • Compilation Tips: | Making compiled code run fast. | |
| • Documentation Tips: | Writing readable documentation strings. | |
| • Comment Tips: | Conventions for writing comments. | |
| • Library Headers: | Standard headers for library packages. | |
µ½Ò·Á¼° | ||
| • A Sample Function Description: | ||
| • A Sample Variable Description: | ||
Lisp¥Ç¡¼¥¿·¿ | ||
| • Printed Representation: | How Lisp objects are represented as text. | |
| • Comments: | Comments and their formatting conventions. | |
| • Programming Types: | Types found in all Lisp systems. | |
| • Editing Types: | Types specific to Emacs. | |
| • Type Predicates: | Tests related to types. | |
| • Equality Predicates: | Tests of equality between any two objects. | |
¥×¥í¥°¥é¥ß¥ó¥°¸þ¤±¤Î·¿ | ||
| • Integer Type: | Numbers without fractional parts. | |
| • Floating Point Type: | Numbers with fractional parts and with a large range. | |
| • Character Type: | The representation of letters, numbers and control characters. | |
| • Sequence Type: | Both lists and arrays are classified as sequences. | |
| • Cons Cell Type: | Cons cells, and lists (which are made from cons cells). | |
| • Array Type: | Arrays include strings and vectors. | |
| • String Type: | An (efficient) array of characters. | |
| • Vector Type: | One-dimensional arrays. | |
| • Symbol Type: | A multi-use object that refers to a function, variable, property list, or itself. | |
| • Function Type: | A piece of executable code you can call from elsewhere. | |
| • Macro Type: | A method of expanding an expression into another expression, more fundamental but less pretty. | |
| • Primitive Function Type: | A function written in C, callable from Lisp. | |
| • Byte-Code Type: | A function written in Lisp, then compiled. | |
| • Autoload Type: | A type used for automatically loading seldom-used functions. | |
¥ê¥¹¥È·¿ | ||
| • Dotted Pair Notation: | An alternative syntax for lists. | |
| • Association List Type: | A specially constructed list. | |
ÊÔ½¸¸þ¤±¤Î·¿ | ||
| • Buffer Type: | The basic object of editing. | |
| • Window Type: | What makes buffers visible. | |
| • Window Configuration Type: | Save what the screen looks like. | |
| • Marker Type: | A position in a buffer. | |
| • Process Type: | A process running on the underlying OS. | |
| • Stream Type: | Receive or send characters. | |
| • Keymap Type: | What function a keystroke invokes. | |
| • Overlay Type: | How an overlay is represented. | |
¿ô | ||
| • Integer Basics: | Representation and range of integers. | |
| • Float Basics: | Representation and range of floating point. | |
| • Predicates on Numbers: | Testing for numbers. | |
| • Comparison of Numbers: | Equality and inequality predicates. | |
| • Arithmetic Operations: | How to add, subtract, multiply and divide. | |
| • Bitwise Operations: | Logical and, or, not, shifting. | |
| • Numeric Conversions: | Converting float to integer and vice versa. | |
| • Math Functions: | Trig, exponential and logarithmic functions. | |
| • Random Numbers: | Obtaining random integers, predictable or not. | |
ʸ»úÎó¤Èʸ»ú | ||
| • String Basics: | Basic properties of strings and characters. | |
| • Predicates for Strings: | Testing whether an object is a string or char. | |
| • Creating Strings: | Functions to allocate new strings. | |
| • Text Comparison: | Comparing characters or strings. | |
| • String Conversion: | Converting characters or strings and vice versa. | |
| • Formatting Strings: | format: Emacs’s analogue of printf.
| |
| • Case Conversion: | Case conversion functions. | |
¥ê¥¹¥È | ||
| • Cons Cells: | How lists are made out of cons cells. | |
| • Lists as Boxes: | Graphical notation to explain lists. | |
| • List-related Predicates: | Is this object a list? Comparing two lists. | |
| • List Elements: | Extracting the pieces of a list. | |
| • Building Lists: | Creating list structure. | |
| • Modifying Lists: | Storing new pieces into an existing list. | |
| • Sets And Lists: | A list can represent a finite mathematical set. | |
| • Association Lists: | A list can represent a finite relation or mapping. | |
´û¸¥ê¥¹¥È¹½Â¤¤ÎÊѹ¹ | ||
| • Setcar: | Replacing an element in a list. | |
| • Setcdr: | Replacing part of the list backbone. This can be used to remove or add elements. | |
| • Rearrangement: | Reordering the elements in a list; combining lists. | |
¥·¡¼¥±¥ó¥¹¡¢ÇÛÎó¡¢¥Ù¥¯¥È¥ë | ||
| • Sequence Functions: | Functions that accept any kind of sequence. | |
| • Arrays: | Characteristics of arrays in Emacs Lisp. | |
| • Array Functions: | Functions specifically for arrays. | |
| • Vectors: | Functions specifically for vectors. | |
¥·¥ó¥Ü¥ë | ||
| • Symbol Components: | Symbols have names, values, function definitions and property lists. | |
| • Definitions: | A definition says how a symbol will be used. | |
| • Creating Symbols: | How symbols are kept unique. | |
| • Property Lists: | Each symbol has a property list for recording miscellaneous information. | |
ɾ²Á | ||
| • Intro Eval: | Evaluation in the scheme of things. | |
| • Eval: | How to invoke the Lisp interpreter explicitly. | |
| • Forms: | How various sorts of objects are evaluated. | |
| • Quoting: | Avoiding evaluation (to put constants in the program). | |
¥Õ¥©¡¼¥à¤Î¼ïÎà | ||
| • Self-Evaluating Forms: | Forms that evaluate to themselves. | |
| • Symbol Forms: | Symbols evaluate as variables. | |
| • Classifying Lists: | How to distinguish various sorts of list forms. | |
| • Function Forms: | Forms that call functions. | |
| • Macro Forms: | Forms that call macros. | |
| • Special Forms: | “Special forms” are idiosyncratic primitives, most of them extremely important. | |
| • Autoloading: | Functions set up to load files containing their real definitions. | |
À©¸æ¹½Â¤ | ||
| • Sequencing: | Evaluation in textual order. | |
| • Conditionals: | if, cond.
| |
| • Combining Conditions: | and, or, not.
| |
| • Iteration: | while loops.
| |
| • Nonlocal Exits: | Jumping out of a sequence. | |
Èó¥í¡¼¥«¥ëæ½Ð | ||
| • Catch and Throw: | Nonlocal exits for the program’s own purposes. | |
| • Examples of Catch: | Showing how such nonlocal exits can be written. | |
| • Errors: | How errors are signaled and handled. | |
| • Cleanups: | Arranging to run a cleanup form if an error happens. | |
¥¨¥é¡¼ | ||
| • Signaling Errors: | How to report an error. | |
| • Processing of Errors: | What Emacs does when you report an error. | |
| • Handling Errors: | How you can trap errors and continue execution. | |
| • Error Symbols: | How errors are classified for trapping them. | |
ÊÑ¿ô | ||
| • Global Variables: | Variable values that exist permanently, everywhere. | |
| • Constant Variables: | Certain "variables" have values that never change. | |
| • Local Variables: | Variable values that exist only temporarily. | |
| • Void Variables: | Symbols that lack values. | |
| • Defining Variables: | A definition says a symbol is used as a variable. | |
| • Accessing Variables: | Examining values of variables whose names are known only at run time. | |
| • Setting Variables: | Storing new values in variables. | |
| • Variable Scoping: | How Lisp chooses among local and global values. | |
| • Buffer-Local Variables: | Variable values in effect only in one buffer. | |
¥¹¥³¡¼¥×¥ë¡¼¥ë¤ÈÊÑ¿ô«Çû | ||
| • Scope: | Scope means where in the program a value is visible. Comparison with other languages. | |
| • Extent: | Extent means how long in time a value exists. | |
| • Impl of Scope: | Two ways to implement dynamic scoping. | |
| • Using Scoping: | How to use dynamic scoping carefully and avoid problems. | |
¥Ð¥Ã¥Õ¥¡¥í¡¼¥«¥ë¤ÊÊÑ¿ô | ||
| • Intro to Buffer-Local: | Introduction and concepts. | |
| • Creating Buffer-Local: | Creating and destroying buffer-local bindings. | |
| • Default Value: | The default value is seen in buffers that don’t have their own buffer-local values. | |
´Ø¿ô | ||
| • What Is a Function: | Lisp functions vs primitives; terminology. | |
| • Lambda Expressions: | How functions are expressed as Lisp objects. | |
| • Function Names: | A symbol can serve as the name of a function. | |
| • Defining Functions: | Lisp expressions for defining functions. | |
| • Calling Functions: | How to use an existing function. | |
| • Mapping Functions: | Applying a function to each element of a list, etc. | |
| • Anonymous Functions: | Lambda-expressions are functions with no names. | |
| • Function Cells: | Accessing or setting the function definition of a symbol. | |
| • Related Topics: | Cross-references to specific Lisp primitives that have a special bearing on how functions work. | |
¥é¥à¥À¼° | ||
| • Lambda Components: | The parts of a lambda expression. | |
| • Simple Lambda: | A simple example. | |
| • Argument List: | Details and special features of argument lists. | |
| • Function Documentation: | How to put documentation in a function. | |
¥Þ¥¯¥í | ||
| • Simple Macro: | A basic example. | |
| • Expansion: | How, when and why macros are expanded. | |
| • Compiling Macros: | How macros are expanded by the compiler. | |
| • Defining Macros: | How to write a macro definition. | |
| • Backquote: | Easier construction of list structure. | |
| • Problems with Macros: | Don’t evaluate the macro arguments too many times. Don’t hide the user’s variables. | |
¥í¡¼¥É | ||
| • How Programs Do Loading: | The load function and others.
| |
| • Autoload: | Setting up a function to autoload. | |
| • Named Features: | Loading a library if it isn’t already loaded. | |
| • Repeated Loading: | Precautions about loading a file twice. | |
¥Ð¥¤¥È¥³¥ó¥Ñ¥¤¥ë | ||
| • Compilation Functions: | Byte compilation functions. | |
| • Disassembly: | Disassembling byte-code; how to read byte-code. | |
´Ø¿ô¤Î¥¢¥É¥Ð¥¤¥¹ | ||
| • Simple Advice: | A simple example to explain the basics of advice. | |
| • Defining Advice: | Detailed description of defadvice.
| |
| • Computed Advice: | ...is to defadvice as fset is to defun.
| |
| • Activation of Advice: | Advice doesn’t do anything until you activate it. | |
| • Enabling Advice: | You can enable or disable each piece of advice. | |
| • Preactivation: | Preactivation is a way of speeding up the loading of compiled advice. | |
| • Argument Access in Advice: | How advice can access the function’s arguments. | |
| • Subr Arguments: | Accessing arguments when advising a primitive. | |
| • Combined Definition: | How advice is implemented. | |
Lisp¥×¥í¥°¥é¥à¤Î¥Ç¥Ð¥Ã¥° | ||
| • Debugger: | How the Emacs Lisp debugger is implemented. | |
| • Syntax Errors: | How to find syntax errors. | |
| • Compilation Errors: | How to find errors that show up in byte compilation. | |
| • Edebug: | A source-level Emacs Lisp debugger. | |
Lisp¥Ç¥Ð¥Ã¥¬ | ||
| • Error Debugging: | Entering the debugger when an error happens. | |
| • Function Debugging: | Entering it when a certain function is called. | |
| • Explicit Debug: | Entering it at a certain point in the program. | |
| • Using Debugger: | What the debugger does; what you see while in it. | |
| • Debugger Commands: | Commands used while in the debugger. | |
| • Invoking the Debugger: | How to call the function debug.
| |
| • Internals of Debugger: | Subroutines of the debugger, and global variables. | |
ÉÔÀµ¤ÊLisp¹½Ê¸¤Î¥Ç¥Ð¥Ã¥° | ||
| • Excess Open: | How to find a spurious open paren or missing close. | |
| • Excess Close: | How to find a spurious close paren or missing open. | |
Lisp¥ª¥Ö¥¸¥§¥¯¥È¤ÎÆɤ߼è¤ê¤Èɽ¼¨ | ||
| • Streams Intro: | Overview of streams, reading and printing. | |
| • Input Streams: | Various data types that can be used as input streams. | |
| • Input Functions: | Functions to read Lisp objects from text. | |
| • Output Streams: | Various data types that can be used as output streams. | |
| • Output Functions: | Functions to print Lisp objects as text. | |
¥ß¥Ë¥Ð¥Ã¥Õ¥¡ | ||
| • Intro to Minibuffers: | Basic information about minibuffers. | |
| • Text from Minibuffer: | How to read a straight text string. | |
| • Object from Minibuffer: | How to read a Lisp object or expression. | |
| • Completion: | How to invoke and customize completion. | |
| • Yes-or-No Queries: | Asking a question with a simple answer. | |
| • Minibuffer Misc: | Various customization hooks and variables. | |
Êä´° | ||
| • Basic Completion: | Low-level functions for completing strings. (These are too low level to use the minibuffer.) | |
| • Minibuffer Completion: | Invoking the minibuffer with completion. | |
| • Completion Commands: | Minibuffer commands that do completion. | |
| • High-Level Completion: | Convenient special cases of completion (reading buffer name, file name, etc.) | |
| • Reading File Names: | Using completion to read file names. | |
| • Programmed Completion: | Finding the completions for a given file name. | |
¥³¥Þ¥ó¥É¥ë¡¼¥× | ||
| • Command Overview: | How the command loop reads commands. | |
| • Defining Commands: | Specifying how a function should read arguments. | |
| • Interactive Call: | Calling a command, so that it will read arguments. | |
| • Command Loop Info: | Variables set by the command loop for you to examine. | |
| • Input Events: | What input looks like when you read it. | |
| • Reading Input: | How to read input events from the keyboard or mouse. | |
| • Waiting: | Waiting for user input or elapsed time. | |
| • Quitting: | How C-g works. How to catch or defer quitting. | |
| • Prefix Command Arguments: | How the commands to set prefix args work. | |
| • Recursive Editing: | Entering a recursive edit, and why you usually shouldn’t. | |
| • Disabling Commands: | How the command loop handles disabled commands. | |
| • Command History: | How the command history is set up, and how accessed. | |
| • Keyboard Macros: | How keyboard macros are implemented. | |
¥³¥Þ¥ó¥É¤ÎÄêµÁ | ||
| • Using Interactive: | General rules for interactive.
| |
| • Interactive Codes: | The standard letter-codes for reading arguments in various ways. | |
| • Interactive Examples: | Examples of how to read interactive arguments. | |
¥¡¼¥Þ¥Ã¥× | ||
| • Keymap Terminology: | Definitions of terms pertaining to keymaps. | |
| • Format of Keymaps: | What a keymap looks like as a Lisp object. | |
| • Creating Keymaps: | Functions to create and copy keymaps. | |
| • Inheritance and Keymaps: | How one keymap can inherit the bindings of another keymap. | |
| • Prefix Keys: | Defining a key with a keymap as its definition. | |
| • Menu Keymaps: | A keymap can define a menu for X windows or for use from the terminal. | |
| • Active Keymaps: | Each buffer has a local keymap to override the standard (global) bindings. Each minor mode can also override them. | |
| • Key Lookup: | How extracting elements from keymaps works. | |
| • Functions for Key Lookup: | How to request key lookup. | |
| • Changing Key Bindings: | Redefining a key in a keymap. | |
| • Key Binding Commands: | Interactive interfaces for redefining keys. | |
| • Scanning Keymaps: | Looking through all keymaps, for printing help. | |
¥á¥¸¥ã¡¼¥â¡¼¥É¤È¥Þ¥¤¥Ê¥â¡¼¥É | ||
| • Major Modes: | Defining major modes. | |
| • Minor Modes: | Defining minor modes. | |
| • Mode Line Format: | Customizing the text that appears in the mode line. | |
| • Hooks: | How to use hooks; how to write code that provides hooks. | |
¥á¥¸¥ã¡¼¥â¡¼¥É | ||
| • Major Mode Conventions: | Coding conventions for keymaps, etc. | |
| • Example Major Modes: | Text mode and Lisp modes. | |
| • Auto Major Mode: | How Emacs chooses the major mode automatically. | |
| • Mode Help: | Finding out how to use a mode. | |
¥Þ¥¤¥Ê¥â¡¼¥É | ||
| • Minor Mode Conventions: | Tips for writing a minor mode. | |
| • Keymaps and Minor Modes: | How a minor mode can have its own keymap. | |
¥â¡¼¥É¹Ô¤Î½ñ¼° | ||
| • Mode Line Data: | The data structure that controls the mode line. | |
| • Mode Line Variables: | Variables used in that data structure. | |
| • %-Constructs: | Putting information into a mode line. | |
ÀâÌÀʸ | ||
| • Documentation Basics: | Good style for doc strings. Where to put them. How Emacs stores them. | |
| • Accessing Documentation: | How Lisp programs can access doc strings. | |
| • Keys in Documentation: | Substituting current key bindings. | |
| • Describing Characters: | Making printable descriptions of non-printing characters and key sequences. | |
| • Help Functions: | Subroutines used by Emacs help facilities. | |
¥Õ¥¡¥¤¥ë | ||
| • Visiting Files: | Reading files into Emacs buffers for editing. | |
| • Saving Buffers: | Writing changed buffers back into files. | |
| • Reading from Files: | Reading files into other buffers. | |
| • Writing to Files: | Writing new files from parts of buffers. | |
| • File Locks: | Locking and unlocking files, to prevent simultaneous editing by two people. | |
| • Information about Files: | Testing existence, accessibility, size of files. | |
| • Contents of Directories: | Getting a list of the files in a directory. | |
| • Changing Files: | Renaming files, changing protection, etc. | |
| • File Names: | Decomposing and expanding file names. | |
¥Õ¥¡¥¤¥ë¤òˬÌ䤹¤ë | ||
| • Visiting Functions: | The usual interface functions for visiting. | |
| • Subroutines of Visiting: | Lower-level subroutines that they use. | |
¥Õ¥¡¥¤¥ë¤Ë´Ø¤¹¤ë¾ðÊó | ||
| • Testing Accessibility: | Is a given file readable? Writable? | |
| • Kinds of Files: | Is it a directory? A link? | |
| • File Attributes: | How large is it? Any other names? Etc. | |
¥Õ¥¡¥¤¥ë̾ | ||
| • File Name Components: | The directory part of a file name, and the rest. | |
| • Directory Names: | A directory’s name as a directory is different from its name as a file. | |
| • Relative File Names: | Some file names are relative to a current directory. | |
| • File Name Expansion: | Converting relative file names to absolute ones. | |
| • Unique File Names: | Generating names for temporary files. | |
| • File Name Completion: | Finding the completions for a given file name. | |
¥Ð¥Ã¥¯¥¢¥Ã¥×¤È¼«Æ°Êݸ | ||
| • Backup Files: | How backup files are made; how their names are chosen. | |
| • Auto-Saving: | How auto-save files are made; how their names are chosen. | |
| • Reverting: | revert-buffer, and how to customize
what it does.
| |
¥Ð¥Ã¥¯¥¢¥Ã¥×¥Õ¥¡¥¤¥ë | ||
| • Making Backups: | How Emacs makes backup files, and when. | |
| • Rename or Copy: | Two alternatives: renaming the old file or copying it. | |
| • Numbered Backups: | Keeping multiple backups for each source file. | |
| • Backup Names: | How backup file names are computed; customization. | |
¥Ð¥Ã¥Õ¥¡ | ||
| • Buffer Basics: | What is a buffer? | |
| • Buffer Names: | Accessing and changing buffer names. | |
| • Buffer File Name: | The buffer file name indicates which file is visited. | |
| • Buffer Modification: | A buffer is modified if it needs to be saved. | |
| • Modification Time: | Determining whether the visited file was changed “behind Emacs’s back”. | |
| • Read Only Buffers: | Modifying text is not allowed in a read-only buffer. | |
| • The Buffer List: | How to look at all the existing buffers. | |
| • Creating Buffers: | Functions that create buffers. | |
| • Killing Buffers: | Buffers exist until explicitly killed. | |
| • Current Buffer: | Designating a buffer as current so primitives will access its contents. | |
¥¦¥£¥ó¥É¥¦ | ||
| • Basic Windows: | Basic information on using windows. | |
| • Splitting Windows: | Splitting one window into two windows. | |
| • Deleting Windows: | Deleting a window gives its space to other windows. | |
| • Selecting Windows: | The selected window is the one that you edit in. | |
| • Cyclic Window Ordering: | Moving around the existing windows. | |
| • Buffers and Windows: | Each window displays the contents of a buffer. | |
| • Displaying Buffers: | Higher-lever functions for displaying a buffer and choosing a window for it. | |
| • Window Point: | Each window has its own location of point. | |
| • Window Start: | The display-start position controls which text is on-screen in the window. | |
| • Vertical Scrolling: | Moving text up and down in the window. | |
| • Horizontal Scrolling: | Moving text sideways on the window. | |
| • Size of Window: | Accessing the size of a window. | |
| • Resizing Windows: | Changing the size of a window. | |
| • Window Configurations: | Saving and restoring the state of the screen. | |
¥Õ¥ì¡¼¥à | ||
| • Creating Frames: | Creating additional frames. | |
| • Multiple Displays: | Creating frames on other X displays. | |
| • Frame Parameters: | Controlling frame size, position, font, etc. | |
| • Frame Titles: | Automatic updating of frame titles. | |
| • Deleting Frames: | Frames last until explicitly deleted. | |
| • Finding All Frames: | How to examine all existing frames. | |
| • Frames and Windows: | A frame contains windows; display of text always works through windows. | |
| • Minibuffers and Frames: | How a frame finds the minibuffer to use. | |
| • Input Focus: | Specifying the selected frame. | |
| • Visibility of Frames: | Frames may be visible or invisible, or icons. | |
| • Raising and Lowering: | Raising a frame makes it hide other X windows; lowering it puts it underneath the others. | |
| • Frame Configurations: | Saving the state of all frames. | |
| • Mouse Tracking: | Getting events that say when the mouse moves. | |
| • Mouse Position: | Asking where the mouse is, or moving it. | |
| • Pop-Up Menus: | Displaying a menu for the user to select from. | |
| • Dialog Boxes: | Displaying a box to ask yes or no. | |
| • Pointer Shapes: | Specifying the shape of the mouse pointer. | |
| • Window System Selections: | Transferring text to and from other windows. | |
| • Color Names: | Getting the definitions of color names. | |
| • Resources: | Getting resource values from the server. | |
| • Server Data: | Getting info about the X server. | |
¥Ð¥Ã¥Õ¥¡Æâ¤Î°ÌÃÖ | ||
| • Point: | The special position where editing takes place. | |
| • Motion: | Changing point. | |
| • Excursions: | Temporary motion and buffer changes. | |
| • Narrowing: | Restricting editing to a portion of the buffer. | |
°ÜÆ° | ||
| • Character Motion: | Moving in terms of characters. | |
| • Word Motion: | Moving in terms of words. | |
| • Buffer End Motion: | Moving to the beginning or end of the buffer. | |
| • Text Lines: | Moving in terms of lines of text. | |
| • Screen Lines: | Moving in terms of lines as displayed. | |
| • List Motion: | Moving by parsing lists and sexps. | |
| • Skipping Characters: | Skipping characters belonging to a certain set. | |
¥Þ¡¼¥« | ||
| • Overview of Markers: | The components of a marker, and how it relocates. | |
| • Predicates on Markers: | Testing whether an object is a marker. | |
| • Creating Markers: | Making empty markers or markers at certain places. | |
| • Information from Markers: | Finding the marker’s buffer or character position. | |
| • Moving Markers: | Moving the marker to a new buffer or position. | |
| • The Mark: | How “the mark” is implemented with a marker. | |
| • The Region: | How to access “the region”. | |
¥Æ¥¥¹¥È | ||
| • Near Point: | Examining text in the vicinity of point. | |
| • Buffer Contents: | Examining text in a general fashion. | |
| • Insertion: | Adding new text to a buffer. | |
| • Commands for Insertion: | User-level commands to insert text. | |
| • Deletion: | Removing text from a buffer. | |
| • User-Level Deletion: | User-level commands to delete text. | |
| • The Kill Ring: | Where removed text sometimes is saved for later use. | |
| • Undo: | Undoing changes to the text of a buffer. | |
| • Auto Filling: | How auto-fill mode is implemented to break lines. | |
| • Filling: | Functions for explicit filling. | |
| • Margins: | How to specify margins for filling commands. | |
| • Sorting: | Functions for sorting parts of the buffer. | |
| • Indentation: | Functions to insert or adjust indentation. | |
| • Columns: | Computing horizontal positions, and using them. | |
| • Case Changes: | Case conversion of parts of the buffer. | |
| • Text Properties: | Assigning Lisp property lists to text characters. | |
| • Substitution: | Replacing a given character wherever it appears. | |
| • Transposition: | Swapping two portions of a buffer. | |
| • Registers: | How registers are implemented. Accessing the text or position stored in a register. | |
| • Change Hooks: | Supplying functions to be run when text is changed. | |
¥¥ë¥ê¥ó¥° | ||
| • Kill Ring Concepts: | What text looks like in the kill ring. | |
| • Kill Functions: | Functions that kill text. | |
| • Yank Commands: | Commands that access the kill ring. | |
| • Low-Level Kill Ring: | Functions and variables for kill ring access. | |
| • Internals of Kill Ring: | Variables that hold kill-ring data. | |
»ú²¼¤² | ||
| • Primitive Indent: | Functions used to count and insert indentation. | |
| • Mode-Specific Indent: | Customize indentation for different modes. | |
| • Region Indent: | Indent all the lines in a region. | |
| • Relative Indent: | Indent the current line based on previous lines. | |
| • Indent Tabs: | Adjustable, typewriter-like tab stops. | |
| • Motion by Indent: | Move to first non-blank character. | |
¥Æ¥¥¹¥È°À | ||
| • Examining Properties: | Looking at the properties of one character. | |
| • Changing Properties: | Setting the properties of a range of text. | |
| • Property Search: | Searching for where a property changes value. | |
| • Special Properties: | Particular properties with special meanings. | |
| • Format Properties: | Properties for representing formatting of text. | |
| • Sticky Properties: | How inserted text gets properties from neighboring text. | |
| • Saving Properties: | Saving text properties in files, and reading them back. | |
| • Lazy Properties: | Computing text properties in a lazy fashion only when text is examined. | |
| • Not Intervals: | Why text properties do not use Lisp-visible text intervals. | |
õº÷¤È°ìÃ× | ||
| • String Search: | Search for an exact match. | |
| • Regular Expressions: | Describing classes of strings. | |
| • Regexp Search: | Searching for a match for a regexp. | |
| • Match Data: | Finding out which part of the text matched various parts of a regexp, after regexp search. | |
| • Saving Match Data: | Saving and restoring this information. | |
| • Standard Regexps: | Useful regexps for finding sentences, pages,... | |
| • Searching and Case: | Case-independent or case-significant searching. | |
Àµµ¬É½¸½ | ||
| • Syntax of Regexps: | Rules for writing regular expressions. | |
| • Regexp Example: | Illustrates regular expression syntax. | |
¹½Ê¸¥Æ¡¼¥Ö¥ë | ||
| • Syntax Descriptors: | How characters are classified. | |
| • Syntax Table Functions: | How to create, examine and alter syntax tables. | |
| • Parsing Expressions: | Parsing balanced expressions using the syntax table. | |
| • Standard Syntax Tables: | Syntax tables used by various major modes. | |
| • Syntax Table Internals: | How syntax table information is stored. | |
¹½Ê¸µ½Ò»Ò | ||
| • Syntax Class Table: | Table of syntax classes. | |
| • Syntax Flags: | Additional flags each character can have. | |
ά¸ì¤Èά¸ì¤ÎŸ³« | ||
| • Abbrev Mode: | Setting up Emacs for abbreviation. | |
| • Tables: | Creating and working with abbrev tables. | |
| • Defining Abbrevs: | Specifying abbreviations and their expansions. | |
| • Files: | Saving abbrevs in files. | |
| • Expansion: | Controlling expansion; expansion subroutines. | |
| • Standard Abbrev Tables: | Abbrev tables used by various major modes. | |
¥×¥í¥»¥¹ | ||
| • Subprocess Creation: | Functions that start subprocesses. | |
| • Synchronous Processes: | Details of using synchronous subprocesses. | |
| • Asynchronous Processes: | Starting up an asynchronous subprocess. | |
| • Deleting Processes: | Eliminating an asynchronous subprocess. | |
| • Process Information: | Accessing run-status and other attributes. | |
| • Input to Processes: | Sending input to an asynchronous subprocess. | |
| • Signals to Processes: | Stopping, continuing or interrupting an asynchronous subprocess. | |
| • Output from Processes: | Collecting output from an asynchronous subprocess. | |
| • Sentinels: | Sentinels run when process run-status changes. | |
| • Network: | Opening network connections. | |
¥×¥í¥»¥¹¤«¤é¤Î½ÐÎϤò¼õ¤±¼è¤ë | ||
| • Process Buffers: | If no filter, output is put in a buffer. | |
| • Filter Functions: | Filter functions accept output from the process. | |
| • Accepting Output: | How to wait until process output arrives. | |
¥ª¥Ú¥ì¡¼¥Æ¥£¥ó¥°¥·¥¹¥Æ¥à¤È¤Î¥¤¥ó¥¿¡¼¥Õ¥§¥¤¥¹ | ||
| • Starting Up: | Customizing Emacs start-up processing. | |
| • Getting Out: | How exiting works (permanent or temporary). | |
| • System Environment: | Distinguish the name and kind of system. | |
| • Terminal Input: | Recording terminal input for debugging. | |
| • Terminal Output: | Recording terminal output for debugging. | |
| • Flow Control: | How to turn output flow control on or off. | |
| • Batch Mode: | Running Emacs without terminal interaction. | |
Emacs¤Î»ÏÆ° | ||
| • Start-up Summary: | Sequence of actions Emacs performs at start-up. | |
| • Init File: | Details on reading the init file (.emacs). | |
| • Terminal-Specific: | How the terminal-specific Lisp file is read. | |
| • Command Line Arguments: | How command line arguments are processed, and how you can customize them. | |
Emacs¤«¤éÈ´¤±¤ë | ||
| • Killing Emacs: | Exiting Emacs irreversibly. | |
| • Suspending Emacs: | Exiting Emacs reversibly. | |
Emacs¤Î²èÌÌɽ¼¨ | ||
| • Refresh Screen: | Clearing the screen and redrawing everything on it. | |
| • Truncation: | Folding or wrapping long text lines. | |
| • The Echo Area: | Where messages are displayed. | |
| • Selective Display: | Hiding part of the buffer text. | |
| • Overlay Arrow: | Display of an arrow to indicate position. | |
| • Temporary Displays: | Displays that go away automatically. | |
| • Waiting: | Forcing display update and waiting for user. | |
| • Blinking: | How Emacs shows the matching open parenthesis. | |
| • Usual Display: | How control characters are displayed. | |
| • Beeping: | Audible signal to the user. | |
| • Window Systems: | Which window system is being used. | |
GNU Emacs¤ÎÆâÉô | ||
| • Building Emacs: | How to preload Lisp libraries into Emacs. | |
| • Pure Storage: | A kludge to make preloaded Lisp functions sharable. | |
| • Garbage Collection: | Reclaiming space for Lisp objects no longer used. | |
| • Object Internals: | Data formats of buffers, windows, processes. | |
| • Writing Emacs Primitives: | Writing C code for Emacs. | |
¥ª¥Ö¥¸¥§¥¯¥È¤ÎÆâÉô | ||
| • Buffer Internals: | Components of a buffer structure. | |
| • Window Internals: | Components of a window structure. | |
| • Process Internals: | Components of a process structure. | |