• 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. |