Mercurial > emacs
comparison lispref/vol2.texi @ 90951:3619e7770f2e
Merge from emacs--devo--0
Patches applied:
* emacs--devo--0 (patch 793-802)
- Update from CVS
- Remove RCS keywords
- Merge from emacs--rel--22
* emacs--rel--22 (patch 42-50)
- Update from CVS
- Merge from gnus--rel--5.10
- Gnus ChangeLog tweaks
* gnus--rel--5.10 (patch 229-232)
- Merge from emacs--devo--0, emacs--rel--22
- ChangeLog tweak
- Update from CVS
Revision: emacs@sv.gnu.org/emacs--unicode--0--patch-223
author | Miles Bader <miles@gnu.org> |
---|---|
date | Sat, 16 Jun 2007 22:32:13 +0000 |
parents | 95d0cdf160ea f1e994e8bc4d |
children | 988f1edc9674 |
comparison
equal
deleted
inserted
replaced
90950:8568c29985a3 | 90951:3619e7770f2e |
---|---|
1 This file is obsolete, and no longer part of the Emacs Lisp Reference Manual. | 1 \input texinfo @c -*-texinfo-*- |
2 It is still present in CVS in case we ever want to use some of it again. | 2 @c This file is used for printing the GNU Emacs Lisp Reference Manual |
3 | 3 @c in two volumes. It is a modified version of elisp.texi. |
4 @c This is part of the GNU Emacs Lisp Reference Manual. | |
5 @c Copyright (C) 1990, 1991, 1992, 1993, 1994, 1995, 1998, 1999, 2001, | 4 @c Copyright (C) 1990, 1991, 1992, 1993, 1994, 1995, 1998, 1999, 2001, |
6 @c 2002, 2003, 2004, 2005, 2006, 2007 Free Software Foundation, Inc. | 5 @c 2002, 2003, 2004, 2005, 2006, 2007 Free Software Foundation, Inc. |
7 @c See the file elisp.texi for copying conditions. | |
8 | |
9 | |
10 \input texinfo @c -*-texinfo-*- | |
11 @c %**start of header | 6 @c %**start of header |
12 @setfilename elisp | 7 @setfilename elisp |
13 @settitle GNU Emacs Lisp Reference Manual: Volume 2 | 8 @settitle GNU Emacs Lisp Reference Manual: Volume 2 |
9 @c %**end of header | |
10 | |
11 @c See two-volume-cross-refs.txt. | |
12 @tex | |
13 \message{Formatting for two volume edition...Volume 2...} | |
14 % | |
15 % Read special toc file, set up in two-volume.make. | |
16 \gdef\tocreadfilename{elisp2-toc-ready.toc} | |
17 % | |
18 % Don't make outlines, they're not needed and \readdatafile can't pay | |
19 % attention to the special definition above. | |
20 \global\let\pdfmakeoutlines=\relax | |
21 % | |
22 % Start volume 2 chapter numbering at 27; this must be listed as chapno26 | |
23 \global\chapno=26 | |
24 @end tex | |
25 | |
26 @c Version of the manual and of Emacs. | |
27 @c Please remember to update the edition number in README as well. | |
28 @set VERSION 2.9 | |
29 @set EMACSVER 22.0.99 | |
30 | |
31 @dircategory Emacs | |
32 @direntry | |
33 * Elisp: (elisp). The Emacs Lisp Reference Manual. | |
34 @end direntry | |
35 | |
36 @c in general, keep the following line commented out, unless doing a | |
37 @c copy of this manual that will be published. the manual should go | |
38 @c onto the distribution in the full, 8.5 x 11" size. | |
39 @set smallbook | |
40 | |
41 @ifset smallbook | |
14 @smallbook | 42 @smallbook |
15 @c %**end of header | 43 @end ifset |
16 | 44 |
17 | 45 @c per rms and peterb, use 10pt fonts for the main text, mostly to |
46 @c save on paper cost. | |
47 @c Do this inside @tex for now, so current makeinfo does not complain. | |
18 @tex | 48 @tex |
19 %%%% Experiment with smaller skip before sections and subsections. | 49 @ifset smallbook |
20 %%%% --rjc 30mar92 | 50 @fonttextsize 10 |
21 | 51 @set EMACSVER 22 |
22 \global\secheadingskip = 17pt plus 6pt minus 3pt | 52 \global\let\urlcolor=\Black % don't print links in grayscale |
23 \global\subsecheadingskip = 14pt plus 6pt minus 3pt | 53 \global\let\linkcolor=\Black |
24 | 54 @end ifset |
25 % The defaults are: | 55 \global\hbadness=6666 % don't worry about not-too-underfull boxes |
26 % \secheadingskip = 21pt plus 8pt minus 4pt | |
27 % \subsecheadingskip = 17pt plus 8pt minus 4pt | |
28 @end tex | 56 @end tex |
29 | 57 |
30 @finalout | |
31 @c tex | |
32 @c \overfullrule=0pt | |
33 @c end tex | |
34 | |
35 @c Start volume 2 chapter numbering on chapter 21; | |
36 @c this must be listed as chapno 20. | |
37 @tex | |
38 \global\chapno=20 | |
39 @end tex | |
40 | |
41 @c ================================================================ | |
42 @c Note: I was unable to figure out how to get .aux files copied | |
43 @c properly in the time I had. Hence need to copy .aux file before | |
44 @c running Tex. --rjc | |
45 | |
46 @tex | |
47 | |
48 \message{} | |
49 \message{Redefining contents commands...} | |
50 \message{} | |
51 | |
52 % Special @contents command | |
53 | |
54 % This inputs fixed up table of contents file rather than create new one. | |
55 \global\def\contents{% | |
56 \startcontents{Table of Contents}% | |
57 \input elisp2-toc-ready.toc | |
58 \endgroup | |
59 \vfill \eject | |
60 } | |
61 | |
62 % Special @summarycontents command | |
63 % This inputs fixed up table of contents file rather than create new one. | |
64 \global\def\summarycontents{% | |
65 \startcontents{Short Contents}% | |
66 % | |
67 \let\chapentry = \shortchapentry | |
68 \let\unnumbchapentry = \shortunnumberedentry | |
69 % We want a true roman here for the page numbers. | |
70 \secfonts | |
71 \let\rm=\shortcontrm \let\bf=\shortcontbf \let\sl=\shortcontsl | |
72 \rm | |
73 \advance\baselineskip by 1pt % Open it up a little. | |
74 \def\secentry ##1##2##3##4{} | |
75 \def\unnumbsecentry ##1##2{} | |
76 \def\subsecentry ##1##2##3##4##5{} | |
77 \def\unnumbsubsecentry ##1##2{} | |
78 \def\subsubsecentry ##1##2##3##4##5##6{} | |
79 \def\unnumbsubsubsecentry ##1##2{} | |
80 \input elisp2-toc-ready.toc | |
81 \endgroup | |
82 \vfill \eject | |
83 } | |
84 | |
85 \message{} | |
86 \message{Formatting special two volume edition...Volume 2...} | |
87 \message{} | |
88 @end tex | |
89 @c ================================================================ | |
90 | |
91 | |
92 @c ==> This `elisp-small.texi' is a `smallbook' version of the manual. | |
93 | |
94 @c ==== Following are acceptable over and underfull hboxes in TeX ==== | |
95 | |
96 @c ----- | |
97 @c [163] [164] [165] [166]) (loading.texi Chapter 13 [167] [168] [169] | |
98 @c Overfull \hbox (20.5428pt too wide) in paragraph at lines 131--131 | |
99 @c []@ninett | |
100 @c setenv EMAC-SLOAD-PATH .:/user/bil/emacs:/usr/local/lib/emacs/lisp[] | |
101 @c ----- | |
102 @c (minibuf.texi Chapter 17 [206] [207] [208] [209] [210] [211] [212] [213] | |
103 @c [214] [215] | |
104 @c Overfull \hbox (2.09094pt too wide) in paragraph at lines 550--560 | |
105 @c @texttt map[] @textrm if @textsl require-match @textrm is | |
106 @c @texttt nil[]@textrm , or else with the keymap @texttt minibuffer- | |
107 @c ----- | |
108 @c (locals.texi Appendix @char 68 [533] [534] | |
109 @c Underfull \hbox (badness 2512) in paragraph at lines 4--4 | |
110 @c []@chaprm Appendix DStandard Buffer-Local | |
111 | |
112 @c ------------------------------------------------------------------- | |
113 | |
114 @c | |
115 @c Combine indices. | 58 @c Combine indices. |
116 @synindex cp fn | 59 @synindex cp fn |
117 @syncodeindex vr fn | 60 @syncodeindex vr fn |
118 @syncodeindex ky fn | 61 @syncodeindex ky fn |
119 @syncodeindex pg fn | 62 @syncodeindex pg fn |
120 @syncodeindex tp fn | 63 @c We use the "type index" to index new functions and variables. |
121 @c oops: texinfo-format-buffer ignores synindex | 64 @c @syncodeindex tp fn |
122 @c | 65 |
123 | 66 @copying |
124 @ifinfo | 67 This is edition @value{VERSION} of the GNU Emacs Lisp Reference Manual,@* |
125 This file documents GNU Emacs Lisp. | 68 corresponding to Emacs version @value{EMACSVER}. |
126 | 69 |
127 @c The edition number appears in several places in this file | 70 Copyright @copyright{} 1990, 1991, 1992, 1993, 1994, 1995, 1996, 1998, |
128 @c and also in the file intro.texi. | 71 1999, 2000, 2001, 2002, 2003, 2004, 2005, 2006, 2007 Free Software |
129 This is edition 2.4 of the GNU Emacs Lisp Reference | 72 Foundation, Inc. |
130 Manual. It corresponds to Emacs Version 19.29. | 73 |
131 @c Please REMEMBER to update edition number in *four* places in this file | 74 @quotation |
132 @c and also in *one* place in ==> intro.texi <== | 75 Permission is granted to copy, distribute and/or modify this document |
133 @c huh? i only found three real places where the edition is stated, and | 76 under the terms of the GNU Free Documentation License, Version 1.2 or |
134 @c one place where it is not stated explicitly ("this info file is newer | 77 any later version published by the Free Software Foundation; with the |
135 @c than the foobar edition"). --mew 13sep93 | 78 Invariant Sections being ``GNU General Public License,'' with the |
136 | 79 Front-Cover texts being ``A GNU Manual,'' and with the Back-Cover |
137 Published by the Free Software Foundation | 80 Texts as in (a) below. A copy of the license is included in the |
138 51 Franklin Street, Fifth Floor | 81 section entitled ``GNU Free Documentation License.'' |
139 Boston, MA 02110-1301 USA | 82 |
140 @end ifinfo | 83 (a) The FSF's Back-Cover Text is: ``You have freedom to copy and modify |
141 | 84 this GNU Manual, like GNU software. Copies published by the Free |
142 @setchapternewpage odd | 85 Software Foundation raise funds for GNU development.'' |
143 | 86 @end quotation |
144 @iftex | 87 @end copying |
145 @shorttitlepage The GNU Emacs Lisp Reference Manual: Volume 2 | 88 |
146 @end iftex | |
147 @titlepage | 89 @titlepage |
148 @sp 1 | 90 @title GNU Emacs Lisp Reference Manual |
149 @center @titlefont{The} | 91 @subtitle Volume 2 |
150 @sp 1 | 92 @subtitle For Emacs Version @value{EMACSVER} |
151 @center @titlefont{GNU Emacs Lisp} | 93 @subtitle Revision @value{VERSION}, June 2007 |
152 @sp 1 | 94 |
153 @center @titlefont{Reference Manual} | 95 @author by Bil Lewis, Dan LaLiberte, Richard Stallman |
154 @sp 2 | 96 @author and the GNU Manual Group |
155 @center GNU Emacs Version 19.29 | |
156 @center for Unix Users | |
157 @sp 1 | |
158 @center Edition 2.4, June 1995 | |
159 @sp 2 | |
160 @center @titlefont{Volume 2} | |
161 @sp 3 | |
162 @center by Bil Lewis, Dan LaLiberte, | |
163 @center and the GNU Manual Group | |
164 @page | 97 @page |
165 @vskip 0pt plus 1filll | 98 @vskip 0pt plus 1filll |
166 Copyright @copyright{} 1990, 1991, 1992, 1993, 1994, 1995 Free Software Foundation, Inc. | 99 @insertcopying |
167 | |
168 @sp 2 | |
169 Edition 2.4 @* | |
170 Revised for Emacs Version 19.29,@* | |
171 June, 1995.@* | |
172 @sp 2 | |
173 ISBN 1-882114-71-X | |
174 | 100 |
175 @sp 2 | 101 @sp 2 |
176 Published by the Free Software Foundation @* | 102 Published by the Free Software Foundation @* |
177 51 Franklin Street, Fifth Floor @* | 103 51 Franklin St, Fifth Floor @* |
178 Boston, MA 02110-1301 USA | 104 Boston, MA 02110-1301 @* |
179 | 105 USA @* |
180 @sp 1 | 106 ISBN 1-882114-74-4 |
181 Permission is granted to make and distribute verbatim copies of this | |
182 manual provided the copyright notice and this permission notice are | |
183 preserved on all copies. | |
184 | |
185 Permission is granted to copy and distribute modified versions of this | |
186 manual under the conditions for verbatim copying, provided also that the | |
187 section entitled ``GNU General Public License'' is included | |
188 exactly as in the original, and provided that the entire resulting | |
189 derived work is distributed under the terms of a permission notice | |
190 identical to this one. | |
191 | |
192 Permission is granted to copy and distribute translations of this manual | |
193 into another language, under the above conditions for modified versions, | |
194 except that the section entitled ``GNU General Public License'' may be | |
195 included in a translation approved by the Free Software Foundation | |
196 instead of in the original English. | |
197 | 107 |
198 @sp 2 | 108 @sp 2 |
199 Cover art by Etienne Suvasa. | 109 Cover art by Etienne Suvasa. |
200 @end titlepage | 110 @end titlepage |
201 @page | 111 |
202 | 112 |
203 @node Top, Copying, (dir), (dir) | 113 @c Print the tables of contents |
204 | 114 @summarycontents |
205 @ifinfo | 115 @contents |
206 This Info file contains edition 2.4 of the GNU Emacs Lisp Reference | 116 |
207 Manual, corresponding to GNU Emacs version 19.29. | 117 |
208 @end ifinfo | 118 @ifnottex |
119 @node Top, Introduction, (dir), (dir) | |
120 @top Emacs Lisp | |
121 | |
122 This Info file contains edition @value{VERSION} of the GNU Emacs Lisp | |
123 Reference Manual, corresponding to GNU Emacs version @value{EMACSVER}. | |
124 @end ifnottex | |
209 | 125 |
210 @menu | 126 @menu |
211 * Copying:: Conditions for copying and changing GNU Emacs. | |
212 * Introduction:: Introduction and conventions used. | 127 * Introduction:: Introduction and conventions used. |
213 | 128 |
214 * Lisp Data Types:: Data types of objects in Emacs Lisp. | 129 * Lisp Data Types:: Data types of objects in Emacs Lisp. |
215 * Numbers:: Numbers and arithmetic functions. | 130 * Numbers:: Numbers and arithmetic functions. |
216 * Strings and Characters:: Strings, and functions that work on them. | 131 * Strings and Characters:: Strings, and functions that work on them. |
217 * Lists:: Lists, cons cells, and related functions. | 132 * Lists:: Lists, cons cells, and related functions. |
218 * Sequences Arrays Vectors:: Lists, strings and vectors are called sequences. | 133 * Sequences Arrays Vectors:: Lists, strings and vectors are called sequences. |
219 Certain functions act on any kind of sequence. | 134 Certain functions act on any kind of sequence. |
220 The description of vectors is here as well. | 135 The description of vectors is here as well. |
136 * Hash Tables:: Very fast lookup-tables. | |
221 * Symbols:: Symbols represent names, uniquely. | 137 * Symbols:: Symbols represent names, uniquely. |
222 | 138 |
223 * Evaluation:: How Lisp expressions are evaluated. | 139 * Evaluation:: How Lisp expressions are evaluated. |
224 * Control Structures:: Conditionals, loops, nonlocal exits. | 140 * Control Structures:: Conditionals, loops, nonlocal exits. |
225 * Variables:: Using symbols in programs to stand for values. | 141 * Variables:: Using symbols in programs to stand for values. |
226 * Functions:: A function is a Lisp program | 142 * Functions:: A function is a Lisp program |
227 that can be invoked from other functions. | 143 that can be invoked from other functions. |
228 * Macros:: Macros are a way to extend the Lisp language. | 144 * Macros:: Macros are a way to extend the Lisp language. |
145 * Customization:: Writing customization declarations. | |
229 | 146 |
230 * Loading:: Reading files of Lisp code into Lisp. | 147 * Loading:: Reading files of Lisp code into Lisp. |
231 * Byte Compilation:: Compilation makes programs run faster. | 148 * Byte Compilation:: Compilation makes programs run faster. |
149 * Advising Functions:: Adding to the definition of a function. | |
232 * Debugging:: Tools and tips for debugging Lisp programs. | 150 * Debugging:: Tools and tips for debugging Lisp programs. |
233 | 151 |
234 * Read and Print:: Converting Lisp objects to text and back. | 152 * Read and Print:: Converting Lisp objects to text and back. |
235 * Minibuffers:: Using the minibuffer to read input. | 153 * Minibuffers:: Using the minibuffer to read input. |
236 * Command Loop:: How the editor command loop works, | 154 * Command Loop:: How the editor command loop works, |
242 * Files:: Accessing files. | 160 * Files:: Accessing files. |
243 * Backups and Auto-Saving:: Controlling how backups and auto-save | 161 * Backups and Auto-Saving:: Controlling how backups and auto-save |
244 files are made. | 162 files are made. |
245 * Buffers:: Creating and using buffer objects. | 163 * Buffers:: Creating and using buffer objects. |
246 * Windows:: Manipulating windows and displaying buffers. | 164 * Windows:: Manipulating windows and displaying buffers. |
247 * Frames:: Making multiple X windows. | 165 * Frames:: Making multiple system-level windows. |
248 * Positions:: Buffer positions and motion functions. | 166 * Positions:: Buffer positions and motion functions. |
249 * Markers:: Markers represent positions and update | 167 * Markers:: Markers represent positions and update |
250 automatically when the text is changed. | 168 automatically when the text is changed. |
251 | 169 |
252 * Text:: Examining and changing text in buffers. | 170 * Text:: Examining and changing text in buffers. |
171 * Non-ASCII Characters:: Non-ASCII text in buffers and strings. | |
253 * Searching and Matching:: Searching buffers for strings or regexps. | 172 * Searching and Matching:: Searching buffers for strings or regexps. |
254 * Syntax Tables:: The syntax table controls word and list parsing. | 173 * Syntax Tables:: The syntax table controls word and list parsing. |
255 * Abbrevs:: How Abbrev mode works, and its data structures. | 174 * Abbrevs:: How Abbrev mode works, and its data structures. |
256 | 175 |
257 * Processes:: Running and communicating with subprocesses. | 176 * Processes:: Running and communicating with subprocesses. |
177 * Display:: Features for controlling the screen display. | |
258 * System Interface:: Getting the user id, system type, environment | 178 * System Interface:: Getting the user id, system type, environment |
259 variables, and other such things. | 179 variables, and other such things. |
260 * Display:: Parameters controlling screen usage. | |
261 The bell. Waiting for input. | |
262 | 180 |
263 Appendices | 181 Appendices |
264 | 182 |
265 * Tips:: Advice for writing Lisp programs. | 183 * Antinews:: Info for users downgrading to Emacs 21. |
184 * GNU Free Documentation License:: The license for this documentation | |
185 * GPL:: Conditions for copying and changing GNU Emacs. | |
186 * Tips:: Advice and coding conventions for Emacs Lisp. | |
266 * GNU Emacs Internals:: Building and dumping Emacs; | 187 * GNU Emacs Internals:: Building and dumping Emacs; |
267 internal data structures. | 188 internal data structures. |
268 * Standard Errors:: List of all error symbols. | 189 * Standard Errors:: List of all error symbols. |
269 * Standard Buffer-Local Variables:: List of variables local in all buffers. | 190 * Standard Buffer-Local Variables:: |
191 List of variables buffer-local in all buffers. | |
270 * Standard Keymaps:: List of standard keymaps. | 192 * Standard Keymaps:: List of standard keymaps. |
271 * Standard Hooks:: List of standard hook variables. | 193 * Standard Hooks:: List of standard hook variables. |
272 | 194 |
273 * Index:: Index including concepts, functions, variables, | 195 * Index:: Index including concepts, functions, variables, |
274 and other terms. | 196 and other terms. |
275 | 197 |
276 --- The Detailed Node Listing --- | 198 @ignore |
199 * New Symbols:: New functions and variables in Emacs @value{EMACSVER}. | |
200 @end ignore | |
201 | |
202 @c Do NOT modify the following 3 lines! They must have this form to | |
203 @c be correctly identified by `texinfo-multiple-files-update'. In | |
204 @c particular, the detailed menu header line MUST be identical to the | |
205 @c value of `texinfo-master-menu-header'. See texnfo-upd.el. | |
206 | |
207 @detailmenu | |
208 --- The Detailed Node Listing --- | |
209 --------------------------------- | |
277 | 210 |
278 Here are other nodes that are inferiors of those already listed, | 211 Here are other nodes that are inferiors of those already listed, |
279 mentioned here so you can get to them in one step: | 212 mentioned here so you can get to them in one step: |
280 | 213 |
281 Introduction | 214 Introduction |
282 | 215 |
283 * Caveats:: Flaws and a request for help. | 216 * Caveats:: Flaws and a request for help. |
284 * Lisp History:: Emacs Lisp is descended from Maclisp. | 217 * Lisp History:: Emacs Lisp is descended from Maclisp. |
285 * Conventions:: How the manual is formatted. | 218 * Conventions:: How the manual is formatted. |
219 * Version Info:: Which Emacs version is running? | |
286 * Acknowledgements:: The authors, editors, and sponsors of this manual. | 220 * Acknowledgements:: The authors, editors, and sponsors of this manual. |
287 | 221 |
288 Conventions | 222 Conventions |
289 | 223 |
290 * Some Terms:: Explanation of terms we use in this manual. | 224 * Some Terms:: Explanation of terms we use in this manual. |
295 * Buffer Text Notation:: The format we use for buffer contents in examples. | 229 * Buffer Text Notation:: The format we use for buffer contents in examples. |
296 * Format of Descriptions:: Notation for describing functions, variables, etc. | 230 * Format of Descriptions:: Notation for describing functions, variables, etc. |
297 | 231 |
298 Format of Descriptions | 232 Format of Descriptions |
299 | 233 |
300 * A Sample Function Description:: | 234 * A Sample Function Description:: A description of an imaginary |
301 * A Sample Variable Description:: | 235 function, @code{foo}. |
236 * A Sample Variable Description:: A description of an imaginary | |
237 variable, @code{electric-future-map}. | |
302 | 238 |
303 Lisp Data Types | 239 Lisp Data Types |
304 | 240 |
305 * Printed Representation:: How Lisp objects are represented as text. | 241 * Printed Representation:: How Lisp objects are represented as text. |
306 * Comments:: Comments and their formatting conventions. | 242 * Comments:: Comments and their formatting conventions. |
307 * Programming Types:: Types found in all Lisp systems. | 243 * Programming Types:: Types found in all Lisp systems. |
308 * Editing Types:: Types specific to Emacs. | 244 * Editing Types:: Types specific to Emacs. |
245 * Circular Objects:: Read syntax for circular structure. | |
309 * Type Predicates:: Tests related to types. | 246 * Type Predicates:: Tests related to types. |
310 * Equality Predicates:: Tests of equality between any two objects. | 247 * Equality Predicates:: Tests of equality between any two objects. |
311 | 248 |
312 Programming Types | 249 Programming Types |
313 | 250 |
314 * Integer Type:: Numbers without fractional parts. | 251 * Integer Type:: Numbers without fractional parts. |
315 * Floating Point Type:: Numbers with fractional parts and with a large range. | 252 * Floating Point Type:: Numbers with fractional parts and with a large range. |
316 * Character Type:: The representation of letters, numbers and | 253 * Character Type:: The representation of letters, numbers and |
317 control characters. | 254 control characters. |
255 * Symbol Type:: A multi-use object that refers to a function, | |
256 variable, property list, or itself. | |
318 * Sequence Type:: Both lists and arrays are classified as sequences. | 257 * Sequence Type:: Both lists and arrays are classified as sequences. |
319 * Cons Cell Type:: Cons cells, and lists (which are made from cons cells). | 258 * Cons Cell Type:: Cons cells, and lists (which are made from cons cells). |
320 * Array Type:: Arrays include strings and vectors. | 259 * Array Type:: Arrays include strings and vectors. |
321 * String Type:: An (efficient) array of characters. | 260 * String Type:: An (efficient) array of characters. |
322 * Vector Type:: One-dimensional arrays. | 261 * Vector Type:: One-dimensional arrays. |
323 * Symbol Type:: A multi-use object that refers to a function, | 262 * Char-Table Type:: One-dimensional sparse arrays indexed by characters. |
324 variable, property list, or itself. | 263 * Bool-Vector Type:: One-dimensional arrays of @code{t} or @code{nil}. |
264 * Hash Table Type:: Super-fast lookup tables. | |
325 * Function Type:: A piece of executable code you can call from elsewhere. | 265 * Function Type:: A piece of executable code you can call from elsewhere. |
326 * Macro Type:: A method of expanding an expression into another | 266 * Macro Type:: A method of expanding an expression into another |
327 expression, more fundamental but less pretty. | 267 expression, more fundamental but less pretty. |
328 * Primitive Function Type:: A function written in C, callable from Lisp. | 268 * Primitive Function Type:: A function written in C, callable from Lisp. |
329 * Byte-Code Type:: A function written in Lisp, then compiled. | 269 * Byte-Code Type:: A function written in Lisp, then compiled. |
330 * Autoload Type:: A type used for automatically loading seldom-used | 270 * Autoload Type:: A type used for automatically loading seldom-used |
331 functions. | 271 functions. |
332 | 272 |
333 List Type | 273 Character Type |
334 | 274 |
275 * Basic Char Syntax:: Syntax for regular characters. | |
276 * General Escape Syntax:: How to specify characters by their codes. | |
277 * Ctl-Char Syntax:: Syntax for control characters. | |
278 * Meta-Char Syntax:: Syntax for meta-characters. | |
279 * Other Char Bits:: Syntax for hyper-, super-, and alt-characters. | |
280 | |
281 Cons Cell and List Types | |
282 | |
283 * Box Diagrams:: Drawing pictures of lists. | |
335 * Dotted Pair Notation:: An alternative syntax for lists. | 284 * Dotted Pair Notation:: An alternative syntax for lists. |
336 * Association List Type:: A specially constructed list. | 285 * Association List Type:: A specially constructed list. |
337 | 286 |
287 String Type | |
288 | |
289 * Syntax for Strings:: How to specify Lisp strings. | |
290 * Non-ASCII in Strings:: International characters in strings. | |
291 * Nonprinting Characters:: Literal unprintable characters in strings. | |
292 * Text Props and Strings:: Strings with text properties. | |
293 | |
338 Editing Types | 294 Editing Types |
339 | 295 |
340 * Buffer Type:: The basic object of editing. | 296 * Buffer Type:: The basic object of editing. |
297 * Marker Type:: A position in a buffer. | |
341 * Window Type:: What makes buffers visible. | 298 * Window Type:: What makes buffers visible. |
342 * Window Configuration Type::Save what the screen looks like. | 299 * Frame Type:: Windows subdivide frames. |
343 * Marker Type:: A position in a buffer. | 300 * Window Configuration Type:: Recording the way a frame is subdivided. |
301 * Frame Configuration Type:: Recording the status of all frames. | |
344 * Process Type:: A process running on the underlying OS. | 302 * Process Type:: A process running on the underlying OS. |
345 * Stream Type:: Receive or send characters. | 303 * Stream Type:: Receive or send characters. |
346 * Keymap Type:: What function a keystroke invokes. | 304 * Keymap Type:: What function a keystroke invokes. |
347 * Syntax Table Type:: What a character means. | 305 * Overlay Type:: How an overlay is represented. |
348 | 306 |
349 Numbers | 307 Numbers |
350 | 308 |
351 * Integer Basics:: Representation and range of integers. | 309 * Integer Basics:: Representation and range of integers. |
352 * Float Basics:: Representation and range of floating point. | 310 * Float Basics:: Representation and range of floating point. |
353 * Predicates on Numbers:: Testing for numbers. | 311 * Predicates on Numbers:: Testing for numbers. |
354 * Comparison of Numbers:: Equality and inequality predicates. | 312 * Comparison of Numbers:: Equality and inequality predicates. |
355 * Arithmetic Operations:: How to add, subtract, multiply and divide. | 313 * Numeric Conversions:: Converting float to integer and vice versa. |
356 * Bitwise Operations:: Logical and, or, not, shifting. | 314 * Arithmetic Operations:: How to add, subtract, multiply and divide. |
357 * Numeric Conversions:: Converting float to integer and vice versa. | 315 * Rounding Operations:: Explicitly rounding floating point numbers. |
358 * Math Functions:: Trig, exponential and logarithmic functions. | 316 * Bitwise Operations:: Logical and, or, not, shifting. |
359 * Random Numbers:: Obtaining random integers, predictable or not. | 317 * Math Functions:: Trig, exponential and logarithmic functions. |
318 * Random Numbers:: Obtaining random integers, predictable or not. | |
360 | 319 |
361 Strings and Characters | 320 Strings and Characters |
362 | 321 |
363 * String Basics:: Basic properties of strings and characters. | 322 * String Basics:: Basic properties of strings and characters. |
364 * Predicates for Strings:: Testing whether an object is a string or char. | 323 * Predicates for Strings:: Testing whether an object is a string or char. |
365 * Creating Strings:: Functions to allocate new strings. | 324 * Creating Strings:: Functions to allocate new strings. |
325 * Modifying Strings:: Altering the contents of an existing string. | |
366 * Text Comparison:: Comparing characters or strings. | 326 * Text Comparison:: Comparing characters or strings. |
367 * String Conversion:: Converting characters or strings and vice versa. | 327 * String Conversion:: Converting characters to strings and vice versa. |
368 * Formatting Strings:: @code{format}: Emacs's analog of @code{printf}. | 328 * Formatting Strings:: @code{format}: Emacs's analogue of @code{printf}. |
369 * Character Case:: Case conversion functions. | 329 * Case Conversion:: Case conversion functions. |
330 * Case Tables:: Customizing case conversion. | |
370 | 331 |
371 Lists | 332 Lists |
372 | 333 |
373 * Cons Cells:: How lists are made out of cons cells. | 334 * Cons Cells:: How lists are made out of cons cells. |
374 * Lists as Boxes:: Graphical notation to explain lists. | |
375 * List-related Predicates:: Is this object a list? Comparing two lists. | 335 * List-related Predicates:: Is this object a list? Comparing two lists. |
376 * List Elements:: Extracting the pieces of a list. | 336 * List Elements:: Extracting the pieces of a list. |
377 * Building Lists:: Creating list structure. | 337 * Building Lists:: Creating list structure. |
338 * List Variables:: Modifying lists stored in variables. | |
378 * Modifying Lists:: Storing new pieces into an existing list. | 339 * Modifying Lists:: Storing new pieces into an existing list. |
379 * Sets And Lists:: A list can represent a finite mathematical set. | 340 * Sets And Lists:: A list can represent a finite mathematical set. |
380 * Association Lists:: A list can represent a finite relation or mapping. | 341 * Association Lists:: A list can represent a finite relation or mapping. |
342 * Rings:: Managing a fixed-size ring of objects. | |
381 | 343 |
382 Modifying Existing List Structure | 344 Modifying Existing List Structure |
383 | 345 |
384 * Setcar:: Replacing an element in a list. | 346 * Setcar:: Replacing an element in a list. |
385 * Setcdr:: Replacing part of the list backbone. | 347 * Setcdr:: Replacing part of the list backbone. |
389 Sequences, Arrays, and Vectors | 351 Sequences, Arrays, and Vectors |
390 | 352 |
391 * Sequence Functions:: Functions that accept any kind of sequence. | 353 * Sequence Functions:: Functions that accept any kind of sequence. |
392 * Arrays:: Characteristics of arrays in Emacs Lisp. | 354 * Arrays:: Characteristics of arrays in Emacs Lisp. |
393 * Array Functions:: Functions specifically for arrays. | 355 * Array Functions:: Functions specifically for arrays. |
394 * Vectors:: Functions specifically for vectors. | 356 * Vectors:: Special characteristics of Emacs Lisp vectors. |
357 * Vector Functions:: Functions specifically for vectors. | |
358 * Char-Tables:: How to work with char-tables. | |
359 * Bool-Vectors:: How to work with bool-vectors. | |
360 | |
361 Hash Tables | |
362 | |
363 * Creating Hash:: Functions to create hash tables. | |
364 * Hash Access:: Reading and writing the hash table contents. | |
365 * Defining Hash:: Defining new comparison methods | |
366 * Other Hash:: Miscellaneous. | |
395 | 367 |
396 Symbols | 368 Symbols |
397 | 369 |
398 * Symbol Components:: Symbols have names, values, function definitions | 370 * Symbol Components:: Symbols have names, values, function definitions |
399 and property lists. | 371 and property lists. |
400 * Definitions:: A definition says how a symbol will be used. | 372 * Definitions:: A definition says how a symbol will be used. |
401 * Creating Symbols:: How symbols are kept unique. | 373 * Creating Symbols:: How symbols are kept unique. |
402 * Property Lists:: Each symbol has a property list | 374 * Property Lists:: Each symbol has a property list |
403 for recording miscellaneous information. | 375 for recording miscellaneous information. |
404 | 376 |
377 Property Lists | |
378 | |
379 * Plists and Alists:: Comparison of the advantages of property | |
380 lists and association lists. | |
381 * Symbol Plists:: Functions to access symbols' property lists. | |
382 * Other Plists:: Accessing property lists stored elsewhere. | |
383 | |
405 Evaluation | 384 Evaluation |
406 | 385 |
407 * Intro Eval:: Evaluation in the scheme of things. | 386 * Intro Eval:: Evaluation in the scheme of things. |
408 * Eval:: How to invoke the Lisp interpreter explicitly. | |
409 * Forms:: How various sorts of objects are evaluated. | 387 * Forms:: How various sorts of objects are evaluated. |
410 * Quoting:: Avoiding evaluation (to put constants in | 388 * Quoting:: Avoiding evaluation (to put constants in |
411 the program). | 389 the program). |
390 * Eval:: How to invoke the Lisp interpreter explicitly. | |
412 | 391 |
413 Kinds of Forms | 392 Kinds of Forms |
414 | 393 |
415 * Self-Evaluating Forms:: Forms that evaluate to themselves. | 394 * Self-Evaluating Forms:: Forms that evaluate to themselves. |
416 * Symbol Forms:: Symbols evaluate as variables. | 395 * Symbol Forms:: Symbols evaluate as variables. |
417 * Classifying Lists:: How to distinguish various sorts of list forms. | 396 * Classifying Lists:: How to distinguish various sorts of list forms. |
397 * Function Indirection:: When a symbol appears as the car of a list, | |
398 we find the real function via the symbol. | |
418 * Function Forms:: Forms that call functions. | 399 * Function Forms:: Forms that call functions. |
419 * Macro Forms:: Forms that call macros. | 400 * Macro Forms:: Forms that call macros. |
420 * Special Forms:: "Special forms" are idiosyncratic primitives, | 401 * Special Forms:: "Special forms" are idiosyncratic primitives, |
421 most of them extremely important. | 402 most of them extremely important. |
422 * Autoloading:: Functions set up to load files | 403 * Autoloading:: Functions set up to load files |
423 containing their real definitions. | 404 containing their real definitions. |
424 | 405 |
425 Control Structures | 406 Control Structures |
426 | 407 |
427 * Sequencing:: Evaluation in textual order. | 408 * Sequencing:: Evaluation in textual order. |
428 * Conditionals:: @code{if}, @code{cond}. | 409 * Conditionals:: @code{if}, @code{cond}, @code{when}, @code{unless}. |
429 * Combining Conditions:: @code{and}, @code{or}, @code{not}. | 410 * Combining Conditions:: @code{and}, @code{or}, @code{not}. |
430 * Iteration:: @code{while} loops. | 411 * Iteration:: @code{while} loops. |
431 * Nonlocal Exits:: Jumping out of a sequence. | 412 * Nonlocal Exits:: Jumping out of a sequence. |
432 | 413 |
433 Nonlocal Exits | 414 Nonlocal Exits |
442 | 423 |
443 * Signaling Errors:: How to report an error. | 424 * Signaling Errors:: How to report an error. |
444 * Processing of Errors:: What Emacs does when you report an error. | 425 * Processing of Errors:: What Emacs does when you report an error. |
445 * Handling Errors:: How you can trap errors and continue execution. | 426 * Handling Errors:: How you can trap errors and continue execution. |
446 * Error Symbols:: How errors are classified for trapping them. | 427 * Error Symbols:: How errors are classified for trapping them. |
428 * Standard Errors:: List of all error symbols. | |
447 | 429 |
448 Variables | 430 Variables |
449 | 431 |
450 * Global Variables:: Variable values that exist permanently, everywhere. | 432 * Global Variables:: Variable values that exist permanently, everywhere. |
451 * Constant Variables:: Certain "variables" have values that never change. | 433 * Constant Variables:: Certain "variables" have values that never change. |
452 * Local Variables:: Variable values that exist only temporarily. | 434 * Local Variables:: Variable values that exist only temporarily. |
453 * Void Variables:: Symbols that lack values. | 435 * Void Variables:: Symbols that lack values. |
454 * Defining Variables:: A definition says a symbol is used as a variable. | 436 * Defining Variables:: A definition says a symbol is used as a variable. |
437 * Tips for Defining:: Things you should think about when you | |
438 define a variable. | |
455 * Accessing Variables:: Examining values of variables whose names | 439 * Accessing Variables:: Examining values of variables whose names |
456 are known only at run time. | 440 are known only at run time. |
457 * Setting Variables:: Storing new values in variables. | 441 * Setting Variables:: Storing new values in variables. |
458 * Variable Scoping:: How Lisp chooses among local and global values. | 442 * Variable Scoping:: How Lisp chooses among local and global values. |
459 * Buffer-Local Variables:: Variable values in effect only in one buffer. | 443 * Buffer-Local Variables:: Variable values in effect only in one buffer. |
444 * Frame-Local Variables:: Variable values in effect only in one frame. | |
445 * Future Local Variables:: New kinds of local values we might add some day. | |
446 * File Local Variables:: Handling local variable lists in files. | |
447 * Variable Aliases:: Variables that are aliases for other variables. | |
448 * Variables with Restricted Values:: Non-constant variables whose value can | |
449 @emph{not} be an arbitrary Lisp object. | |
450 * Standard Buffer-Local Variables:: | |
451 List of variables buffer-local in all buffers. | |
460 | 452 |
461 Scoping Rules for Variable Bindings | 453 Scoping Rules for Variable Bindings |
462 | 454 |
463 * Scope:: Scope means where in the program a value | 455 * Scope:: Scope means where in the program a value |
464 is visible. Comparison with other languages. | 456 is visible. Comparison with other languages. |
470 Buffer-Local Variables | 462 Buffer-Local Variables |
471 | 463 |
472 * Intro to Buffer-Local:: Introduction and concepts. | 464 * Intro to Buffer-Local:: Introduction and concepts. |
473 * Creating Buffer-Local:: Creating and destroying buffer-local bindings. | 465 * Creating Buffer-Local:: Creating and destroying buffer-local bindings. |
474 * Default Value:: The default value is seen in buffers | 466 * Default Value:: The default value is seen in buffers |
475 that don't have their own local values. | 467 that don't have their own buffer-local values. |
476 | 468 |
477 Functions | 469 Functions |
478 | 470 |
479 * What Is a Function:: Lisp functions vs primitives; terminology. | 471 * What Is a Function:: Lisp functions vs primitives; terminology. |
480 * Lambda Expressions:: How functions are expressed as Lisp objects. | 472 * Lambda Expressions:: How functions are expressed as Lisp objects. |
483 * Calling Functions:: How to use an existing function. | 475 * Calling Functions:: How to use an existing function. |
484 * Mapping Functions:: Applying a function to each element of a list, etc. | 476 * Mapping Functions:: Applying a function to each element of a list, etc. |
485 * Anonymous Functions:: Lambda-expressions are functions with no names. | 477 * Anonymous Functions:: Lambda-expressions are functions with no names. |
486 * Function Cells:: Accessing or setting the function definition | 478 * Function Cells:: Accessing or setting the function definition |
487 of a symbol. | 479 of a symbol. |
480 * Obsolete Functions:: Declaring functions obsolete. | |
481 * Inline Functions:: Defining functions that the compiler will open code. | |
482 * Function Safety:: Determining whether a function is safe to call. | |
488 * Related Topics:: Cross-references to specific Lisp primitives | 483 * Related Topics:: Cross-references to specific Lisp primitives |
489 that have a special bearing on how | 484 that have a special bearing on how |
490 functions work. | 485 functions work. |
491 | 486 |
492 Lambda Expressions | 487 Lambda Expressions |
503 * Compiling Macros:: How macros are expanded by the compiler. | 498 * Compiling Macros:: How macros are expanded by the compiler. |
504 * Defining Macros:: How to write a macro definition. | 499 * Defining Macros:: How to write a macro definition. |
505 * Backquote:: Easier construction of list structure. | 500 * Backquote:: Easier construction of list structure. |
506 * Problems with Macros:: Don't evaluate the macro arguments too many times. | 501 * Problems with Macros:: Don't evaluate the macro arguments too many times. |
507 Don't hide the user's variables. | 502 Don't hide the user's variables. |
503 * Indenting Macros:: Specifying how to indent macro calls. | |
504 | |
505 Common Problems Using Macros | |
506 | |
507 * Wrong Time:: Do the work in the expansion, not in the macro. | |
508 * Argument Evaluation:: The expansion should evaluate each macro arg once. | |
509 * Surprising Local Vars:: Local variable bindings in the expansion | |
510 require special care. | |
511 * Eval During Expansion:: Don't evaluate them; put them in the expansion. | |
512 * Repeated Expansion:: Avoid depending on how many times expansion is done. | |
513 | |
514 Writing Customization Definitions | |
515 | |
516 * Common Keywords:: Common keyword arguments for all kinds of | |
517 customization declarations. | |
518 * Group Definitions:: Writing customization group definitions. | |
519 * Variable Definitions:: Declaring user options. | |
520 * Customization Types:: Specifying the type of a user option. | |
521 | |
522 Customization Types | |
523 | |
524 * Simple Types:: Simple customization types: sexp, integer, number, | |
525 string, file, directory, alist. | |
526 * Composite Types:: Build new types from other types or data. | |
527 * Splicing into Lists:: Splice elements into list with @code{:inline}. | |
528 * Type Keywords:: Keyword-argument pairs in a customization type. | |
529 * Defining New Types:: Give your type a name. | |
508 | 530 |
509 Loading | 531 Loading |
510 | 532 |
511 * How Programs Do Loading:: The @code{load} function and others. | 533 * How Programs Do Loading:: The @code{load} function and others. |
534 * Load Suffixes:: Details about the suffixes that @code{load} tries. | |
535 * Library Search:: Finding a library to load. | |
536 * Loading Non-ASCII:: Non-@acronym{ASCII} characters in Emacs Lisp files. | |
512 * Autoload:: Setting up a function to autoload. | 537 * Autoload:: Setting up a function to autoload. |
538 * Repeated Loading:: Precautions about loading a file twice. | |
513 * Named Features:: Loading a library if it isn't already loaded. | 539 * Named Features:: Loading a library if it isn't already loaded. |
514 * Repeated Loading:: Precautions about loading a file twice. | 540 * Where Defined:: Finding which file defined a certain symbol. |
541 * Unloading:: How to "unload" a library that was loaded. | |
542 * Hooks for Loading:: Providing code to be run when | |
543 particular libraries are loaded. | |
515 | 544 |
516 Byte Compilation | 545 Byte Compilation |
517 | 546 |
547 * Speed of Byte-Code:: An example of speedup from byte compilation. | |
518 * Compilation Functions:: Byte compilation functions. | 548 * Compilation Functions:: Byte compilation functions. |
549 * Docs and Compilation:: Dynamic loading of documentation strings. | |
550 * Dynamic Loading:: Dynamic loading of individual functions. | |
551 * Eval During Compile:: Code to be evaluated when you compile. | |
552 * Compiler Errors:: Handling compiler error messages. | |
553 * Byte-Code Objects:: The data type used for byte-compiled functions. | |
519 * Disassembly:: Disassembling byte-code; how to read byte-code. | 554 * Disassembly:: Disassembling byte-code; how to read byte-code. |
520 | 555 |
556 Advising Emacs Lisp Functions | |
557 | |
558 * Simple Advice:: A simple example to explain the basics of advice. | |
559 * Defining Advice:: Detailed description of @code{defadvice}. | |
560 * Around-Advice:: Wrapping advice around a function's definition. | |
561 * Computed Advice:: ...is to @code{defadvice} as @code{fset} is to @code{defun}. | |
562 * Activation of Advice:: Advice doesn't do anything until you activate it. | |
563 * Enabling Advice:: You can enable or disable each piece of advice. | |
564 * Preactivation:: Preactivation is a way of speeding up the | |
565 loading of compiled advice. | |
566 * Argument Access in Advice:: How advice can access the function's arguments. | |
567 * Advising Primitives:: Accessing arguments when advising a primitive. | |
568 * Combined Definition:: How advice is implemented. | |
569 | |
521 Debugging Lisp Programs | 570 Debugging Lisp Programs |
522 | 571 |
523 * Debugger:: How the Emacs Lisp debugger is implemented. | 572 * Debugger:: How the Emacs Lisp debugger is implemented. |
573 * Edebug:: A source-level Emacs Lisp debugger. | |
524 * Syntax Errors:: How to find syntax errors. | 574 * Syntax Errors:: How to find syntax errors. |
575 * Test Coverage:: Ensuring you have tested all branches in your code. | |
525 * Compilation Errors:: How to find errors that show up in | 576 * Compilation Errors:: How to find errors that show up in |
526 byte compilation. | 577 byte compilation. |
527 * Edebug:: A source-level Emacs Lisp debugger. | |
528 | 578 |
529 The Lisp Debugger | 579 The Lisp Debugger |
530 | 580 |
531 * Error Debugging:: Entering the debugger when an error happens. | 581 * Error Debugging:: Entering the debugger when an error happens. |
582 * Infinite Loops:: Stopping and debugging a program that doesn't exit. | |
532 * Function Debugging:: Entering it when a certain function is called. | 583 * Function Debugging:: Entering it when a certain function is called. |
533 * Explicit Debug:: Entering it at a certain point in the program. | 584 * Explicit Debug:: Entering it at a certain point in the program. |
534 * Using Debugger:: What the debugger does; what you see while in it. | 585 * Using Debugger:: What the debugger does; what you see while in it. |
535 * Debugger Commands:: Commands used while in the debugger. | 586 * Debugger Commands:: Commands used while in the debugger. |
536 * Invoking the Debugger:: How to call the function @code{debug}. | 587 * Invoking the Debugger:: How to call the function @code{debug}. |
537 * Internals of Debugger:: Subroutines of the debugger, and global variables. | 588 * Internals of Debugger:: Subroutines of the debugger, and global variables. |
589 | |
590 Edebug | |
591 | |
592 * Using Edebug:: Introduction to use of Edebug. | |
593 * Instrumenting:: You must instrument your code | |
594 in order to debug it with Edebug. | |
595 * Edebug Execution Modes:: Execution modes, stopping more or less often. | |
596 * Jumping:: Commands to jump to a specified place. | |
597 * Edebug Misc:: Miscellaneous commands. | |
598 * Breaks:: Setting breakpoints to make the program stop. | |
599 * Trapping Errors:: Trapping errors with Edebug. | |
600 * Edebug Views:: Views inside and outside of Edebug. | |
601 * Edebug Eval:: Evaluating expressions within Edebug. | |
602 * Eval List:: Expressions whose values are displayed | |
603 each time you enter Edebug. | |
604 * Printing in Edebug:: Customization of printing. | |
605 * Trace Buffer:: How to produce trace output in a buffer. | |
606 * Coverage Testing:: How to test evaluation coverage. | |
607 * The Outside Context:: Data that Edebug saves and restores. | |
608 * Edebug and Macros:: Specifying how to handle macro calls. | |
609 * Edebug Options:: Option variables for customizing Edebug. | |
538 | 610 |
539 Debugging Invalid Lisp Syntax | 611 Debugging Invalid Lisp Syntax |
540 | 612 |
541 * Excess Open:: How to find a spurious open paren or missing close. | 613 * Excess Open:: How to find a spurious open paren or missing close. |
542 * Excess Close:: How to find a spurious close paren or missing open. | 614 * Excess Close:: How to find a spurious close paren or missing open. |
548 input streams. | 620 input streams. |
549 * Input Functions:: Functions to read Lisp objects from text. | 621 * Input Functions:: Functions to read Lisp objects from text. |
550 * Output Streams:: Various data types that can be used as | 622 * Output Streams:: Various data types that can be used as |
551 output streams. | 623 output streams. |
552 * Output Functions:: Functions to print Lisp objects as text. | 624 * Output Functions:: Functions to print Lisp objects as text. |
625 * Output Variables:: Variables that control what the printing | |
626 functions do. | |
553 | 627 |
554 Minibuffers | 628 Minibuffers |
555 | 629 |
556 * Intro to Minibuffers:: Basic information about minibuffers. | 630 * Intro to Minibuffers:: Basic information about minibuffers. |
557 * Text from Minibuffer:: How to read a straight text string. | 631 * Text from Minibuffer:: How to read a straight text string. |
558 * Object from Minibuffer:: How to read a Lisp object or expression. | 632 * Object from Minibuffer:: How to read a Lisp object or expression. |
633 * Minibuffer History:: Recording previous minibuffer inputs | |
634 so the user can reuse them. | |
635 * Initial Input:: Specifying initial contents for the minibuffer. | |
559 * Completion:: How to invoke and customize completion. | 636 * Completion:: How to invoke and customize completion. |
560 * Yes-or-No Queries:: Asking a question with a simple answer. | 637 * Yes-or-No Queries:: Asking a question with a simple answer. |
638 * Multiple Queries:: Asking a series of similar questions. | |
639 * Reading a Password:: Reading a password from the terminal. | |
640 * Minibuffer Commands:: Commands used as key bindings in minibuffers. | |
641 * Minibuffer Contents:: How such commands access the minibuffer text. | |
642 * Minibuffer Windows:: Operating on the special minibuffer windows. | |
643 * Recursive Mini:: Whether recursive entry to minibuffer is allowed. | |
561 * Minibuffer Misc:: Various customization hooks and variables. | 644 * Minibuffer Misc:: Various customization hooks and variables. |
562 | 645 |
563 Completion | 646 Completion |
564 | 647 |
565 * Basic Completion:: Low-level functions for completing strings. | 648 * Basic Completion:: Low-level functions for completing strings. |
575 | 658 |
576 * Command Overview:: How the command loop reads commands. | 659 * Command Overview:: How the command loop reads commands. |
577 * Defining Commands:: Specifying how a function should read arguments. | 660 * Defining Commands:: Specifying how a function should read arguments. |
578 * Interactive Call:: Calling a command, so that it will read arguments. | 661 * Interactive Call:: Calling a command, so that it will read arguments. |
579 * Command Loop Info:: Variables set by the command loop for you to examine. | 662 * Command Loop Info:: Variables set by the command loop for you to examine. |
663 * Adjusting Point:: Adjustment of point after a command. | |
580 * Input Events:: What input looks like when you read it. | 664 * Input Events:: What input looks like when you read it. |
581 * Reading Input:: How to read input events from the keyboard or mouse. | 665 * Reading Input:: How to read input events from the keyboard or mouse. |
666 * Special Events:: Events processed immediately and individually. | |
582 * Waiting:: Waiting for user input or elapsed time. | 667 * Waiting:: Waiting for user input or elapsed time. |
583 * Quitting:: How @kbd{C-g} works. How to catch or defer quitting. | 668 * Quitting:: How @kbd{C-g} works. How to catch or defer quitting. |
584 * Prefix Command Arguments:: How the commands to set prefix args work. | 669 * Prefix Command Arguments:: How the commands to set prefix args work. |
585 * Recursive Editing:: Entering a recursive edit, | 670 * Recursive Editing:: Entering a recursive edit, |
586 and why you usually shouldn't. | 671 and why you usually shouldn't. |
593 * Using Interactive:: General rules for @code{interactive}. | 678 * Using Interactive:: General rules for @code{interactive}. |
594 * Interactive Codes:: The standard letter-codes for reading arguments | 679 * Interactive Codes:: The standard letter-codes for reading arguments |
595 in various ways. | 680 in various ways. |
596 * Interactive Examples:: Examples of how to read interactive arguments. | 681 * Interactive Examples:: Examples of how to read interactive arguments. |
597 | 682 |
683 Input Events | |
684 | |
685 * Keyboard Events:: Ordinary characters--keys with symbols on them. | |
686 * Function Keys:: Function keys--keys with names, not symbols. | |
687 * Mouse Events:: Overview of mouse events. | |
688 * Click Events:: Pushing and releasing a mouse button. | |
689 * Drag Events:: Moving the mouse before releasing the button. | |
690 * Button-Down Events:: A button was pushed and not yet released. | |
691 * Repeat Events:: Double and triple click (or drag, or down). | |
692 * Motion Events:: Just moving the mouse, not pushing a button. | |
693 * Focus Events:: Moving the mouse between frames. | |
694 * Misc Events:: Other events the system can generate. | |
695 * Event Examples:: Examples of the lists for mouse events. | |
696 * Classifying Events:: Finding the modifier keys in an event symbol. | |
697 * Accessing Events:: Functions to extract info from events. | |
698 * Strings of Events:: Special considerations for putting | |
699 keyboard character events in a string. | |
700 | |
701 Reading Input | |
702 | |
703 * Key Sequence Input:: How to read one key sequence. | |
704 * Reading One Event:: How to read just one event. | |
705 * Event Mod:: How Emacs modifies events as they are read. | |
706 * Invoking the Input Method:: How reading an event uses the input method. | |
707 * Quoted Character Input:: Asking the user to specify a character. | |
708 * Event Input Misc:: How to reread or throw away input events. | |
709 | |
598 Keymaps | 710 Keymaps |
599 | 711 |
600 * Keymap Terminology:: Definitions of terms pertaining to keymaps. | 712 * Key Sequences:: Key sequences as Lisp objects. |
601 * Format of Keymaps:: What a keymap looks like as a Lisp object. | 713 * Keymap Basics:: Basic concepts of keymaps. |
602 * Creating Keymaps:: Functions to create and copy keymaps. | 714 * Format of Keymaps:: What a keymap looks like as a Lisp object. |
603 * Inheritance and Keymaps:: How one keymap can inherit the bindings | 715 * Creating Keymaps:: Functions to create and copy keymaps. |
604 of another keymap. | 716 * Inheritance and Keymaps:: How one keymap can inherit the bindings |
605 * Prefix Keys:: Defining a key with a keymap as its definition. | 717 of another keymap. |
606 * Menu Keymaps:: A keymap can define a menu for X | 718 * Prefix Keys:: Defining a key with a keymap as its definition. |
607 or for use from the terminal. | 719 * Active Keymaps:: How Emacs searches the active keymaps |
608 * Active Keymaps:: Each buffer has a local keymap | 720 for a key binding. |
609 to override the standard (global) bindings. | 721 * Searching Keymaps:: A pseudo-Lisp summary of searching active maps. |
610 Each minor mode can also override them. | 722 * Controlling Active Maps:: Each buffer has a local keymap |
611 * Key Lookup:: How extracting elements from keymaps works. | 723 to override the standard (global) bindings. |
724 A minor mode can also override them. | |
725 * Key Lookup:: How extracting elements from keymaps works. | |
612 * Functions for Key Lookup:: How to request key lookup. | 726 * Functions for Key Lookup:: How to request key lookup. |
613 * Changing Key Bindings:: Redefining a key in a keymap. | 727 * Changing Key Bindings:: Redefining a key in a keymap. |
614 * Key Binding Commands:: Interactive interfaces for redefining keys. | 728 * Remapping Commands:: A keymap can translate one command to another. |
615 * Scanning Keymaps:: Looking through all keymaps, for printing help. | 729 * Translation Keymaps:: Keymaps for translating sequences of events. |
730 * Key Binding Commands:: Interactive interfaces for redefining keys. | |
731 * Scanning Keymaps:: Looking through all keymaps, for printing help. | |
732 * Menu Keymaps:: A keymap can define a menu for X | |
733 or for use from the terminal. | |
734 * Standard Keymaps:: List of standard keymaps. | |
616 | 735 |
617 Major and Minor Modes | 736 Major and Minor Modes |
618 | 737 |
738 * Hooks:: How to use hooks; how to write code that | |
739 provides hooks. | |
619 * Major Modes:: Defining major modes. | 740 * Major Modes:: Defining major modes. |
620 * Minor Modes:: Defining minor modes. | 741 * Minor Modes:: Defining minor modes. |
621 * Mode Line Format:: Customizing the text that appears in the mode line. | 742 * Mode Line Format:: Customizing the text that appears in the mode line. |
622 * Hooks:: How to use hooks; how to write code that | 743 * Imenu:: How a mode can provide a menu |
623 provides hooks. | 744 of definitions in the buffer. |
745 * Font Lock Mode:: How modes can highlight text according to syntax. | |
746 * Desktop Save Mode:: How modes can have buffer state saved between | |
747 Emacs sessions. | |
748 | |
749 Menu Keymaps | |
750 | |
751 * Defining Menus:: How to make a keymap that defines a menu. | |
752 * Mouse Menus:: How users actuate the menu with the mouse. | |
753 * Keyboard Menus:: How users actuate the menu with the keyboard. | |
754 * Menu Example:: Making a simple menu. | |
755 * Menu Bar:: How to customize the menu bar. | |
756 * Tool Bar:: A tool bar is a row of images. | |
757 * Modifying Menus:: How to add new items to a menu. | |
758 | |
759 Defining Menus | |
760 | |
761 * Simple Menu Items:: A simple kind of menu key binding, | |
762 limited in capabilities. | |
763 * Extended Menu Items:: More powerful menu item definitions | |
764 let you specify keywords to enable | |
765 various features. | |
766 * Menu Separators:: Drawing a horizontal line through a menu. | |
767 * Alias Menu Items:: Using command aliases in menu items. | |
768 | |
769 Major and Minor Modes | |
770 | |
771 * Hooks:: How to use hooks; how to write code that provides hooks. | |
772 * Major Modes:: Defining major modes. | |
773 * Minor Modes:: Defining minor modes. | |
774 * Mode Line Format:: Customizing the text that appears in the mode line. | |
775 * Imenu:: How a mode can provide a menu | |
776 of definitions in the buffer. | |
777 * Font Lock Mode:: How modes can highlight text according to syntax. | |
778 * Desktop Save Mode:: How modes can have buffer state saved between | |
779 Emacs sessions. | |
624 | 780 |
625 Major Modes | 781 Major Modes |
626 | 782 |
783 * Major Mode Basics:: | |
627 * Major Mode Conventions:: Coding conventions for keymaps, etc. | 784 * Major Mode Conventions:: Coding conventions for keymaps, etc. |
628 * Example Major Modes:: Text mode and Lisp modes. | 785 * Example Major Modes:: Text mode and Lisp modes. |
629 * Auto Major Mode:: How Emacs chooses the major mode automatically. | 786 * Auto Major Mode:: How Emacs chooses the major mode automatically. |
630 * Mode Help:: Finding out how to use a mode. | 787 * Mode Help:: Finding out how to use a mode. |
788 * Derived Modes:: Defining a new major mode based on another major | |
789 mode. | |
790 * Generic Modes:: Defining a simple major mode that supports | |
791 comment syntax and Font Lock mode. | |
792 * Mode Hooks:: Hooks run at the end of major mode functions. | |
631 | 793 |
632 Minor Modes | 794 Minor Modes |
633 | 795 |
634 * Minor Mode Conventions:: Tips for writing a minor mode. | 796 * Minor Mode Conventions:: Tips for writing a minor mode. |
635 * Keymaps and Minor Modes:: How a minor mode can have its own keymap. | 797 * Keymaps and Minor Modes:: How a minor mode can have its own keymap. |
798 * Defining Minor Modes:: A convenient facility for defining minor modes. | |
636 | 799 |
637 Mode Line Format | 800 Mode Line Format |
638 | 801 |
802 * Mode Line Basics:: | |
639 * Mode Line Data:: The data structure that controls the mode line. | 803 * Mode Line Data:: The data structure that controls the mode line. |
640 * Mode Line Variables:: Variables used in that data structure. | 804 * Mode Line Variables:: Variables used in that data structure. |
641 * %-Constructs:: Putting information into a mode line. | 805 * %-Constructs:: Putting information into a mode line. |
806 * Properties in Mode:: Using text properties in the mode line. | |
807 * Header Lines:: Like a mode line, but at the top. | |
808 * Emulating Mode Line:: Formatting text as the mode line would. | |
809 | |
810 Font Lock Mode | |
811 | |
812 * Font Lock Basics:: Overview of customizing Font Lock. | |
813 * Search-based Fontification:: Fontification based on regexps. | |
814 * Customizing Keywords:: Customizing search-based fontification. | |
815 * Other Font Lock Variables:: Additional customization facilities. | |
816 * Levels of Font Lock:: Each mode can define alternative levels | |
817 so that the user can select more or less. | |
818 * Precalculated Fontification:: How Lisp programs that produce the buffer | |
819 contents can also specify how to fontify it. | |
820 * Faces for Font Lock:: Special faces specifically for Font Lock. | |
821 * Syntactic Font Lock:: Fontification based on syntax tables. | |
822 * Setting Syntax Properties:: Defining character syntax based on context | |
823 using the Font Lock mechanism. | |
824 * Multiline Font Lock:: How to coerce Font Lock into properly | |
825 highlighting multiline constructs. | |
826 | |
827 Multiline Font Lock Constructs | |
828 | |
829 * Font Lock Multiline:: Marking multiline chunks with a text property | |
830 * Region to Fontify:: Controlling which region gets refontified | |
831 after a buffer change. | |
642 | 832 |
643 Documentation | 833 Documentation |
644 | 834 |
645 * Documentation Basics:: Good style for doc strings. | 835 * Documentation Basics:: Good style for doc strings. |
646 Where to put them. How Emacs stores them. | 836 Where to put them. How Emacs stores them. |
655 * Visiting Files:: Reading files into Emacs buffers for editing. | 845 * Visiting Files:: Reading files into Emacs buffers for editing. |
656 * Saving Buffers:: Writing changed buffers back into files. | 846 * Saving Buffers:: Writing changed buffers back into files. |
657 * Reading from Files:: Reading files into other buffers. | 847 * Reading from Files:: Reading files into other buffers. |
658 * Writing to Files:: Writing new files from parts of buffers. | 848 * Writing to Files:: Writing new files from parts of buffers. |
659 * File Locks:: Locking and unlocking files, to prevent | 849 * File Locks:: Locking and unlocking files, to prevent |
660 simultaneous editing by two people. | 850 simultaneous editing by two people. |
661 * Information about Files:: Testing existence, accessibility, size of files. | 851 * Information about Files:: Testing existence, accessibility, size of files. |
662 * Contents of Directories:: Getting a list of the files in a directory. | 852 * Changing Files:: Renaming files, changing protection, etc. |
663 * Changing File Attributes:: Renaming files, changing protection, etc. | 853 * File Names:: Decomposing and expanding file names. |
664 * File Names:: Decomposing and expanding file names. | 854 * Contents of Directories:: Getting a list of the files in a directory. |
855 * Create/Delete Dirs:: Creating and Deleting Directories. | |
856 * Magic File Names:: Defining "magic" special handling | |
857 for certain file names. | |
858 * Format Conversion:: Conversion to and from various file formats. | |
665 | 859 |
666 Visiting Files | 860 Visiting Files |
667 | 861 |
668 * Visiting Functions:: The usual interface functions for visiting. | 862 * Visiting Functions:: The usual interface functions for visiting. |
669 * Subroutines of Visiting:: Lower-level subroutines that they use. | 863 * Subroutines of Visiting:: Lower-level subroutines that they use. |
670 | 864 |
671 Information about Files | 865 Information about Files |
672 | 866 |
673 * Testing Accessibility:: Is a given file readable? Writable? | 867 * Testing Accessibility:: Is a given file readable? Writable? |
674 * Kinds of Files:: Is it a directory? A link? | 868 * Kinds of Files:: Is it a directory? A symbolic link? |
869 * Truenames:: Eliminating symbolic links from a file name. | |
675 * File Attributes:: How large is it? Any other names? Etc. | 870 * File Attributes:: How large is it? Any other names? Etc. |
871 * Locating Files:: How to find a file in standard places. | |
676 | 872 |
677 File Names | 873 File Names |
678 | 874 |
679 * File Name Components:: The directory part of a file name, and the rest. | 875 * File Name Components:: The directory part of a file name, and the rest. |
876 * Relative File Names:: Some file names are relative to a | |
877 current directory. | |
680 * Directory Names:: A directory's name as a directory | 878 * Directory Names:: A directory's name as a directory |
681 is different from its name as a file. | 879 is different from its name as a file. |
682 * Relative File Names:: Some file names are relative to a | |
683 current directory. | |
684 * File Name Expansion:: Converting relative file names to absolute ones. | 880 * File Name Expansion:: Converting relative file names to absolute ones. |
685 * Unique File Names:: Generating names for temporary files. | 881 * Unique File Names:: Generating names for temporary files. |
686 * File Name Completion:: Finding the completions for a given file name. | 882 * File Name Completion:: Finding the completions for a given file name. |
883 * Standard File Names:: If your package uses a fixed file name, | |
884 how to handle various operating systems simply. | |
687 | 885 |
688 Backups and Auto-Saving | 886 Backups and Auto-Saving |
689 | 887 |
690 * Backup Files:: How backup files are made; how their names | 888 * Backup Files:: How backup files are made; how their names |
691 are chosen. | 889 are chosen. |
703 * Backup Names:: How backup file names are computed; customization. | 901 * Backup Names:: How backup file names are computed; customization. |
704 | 902 |
705 Buffers | 903 Buffers |
706 | 904 |
707 * Buffer Basics:: What is a buffer? | 905 * Buffer Basics:: What is a buffer? |
906 * Current Buffer:: Designating a buffer as current | |
907 so primitives will access its contents. | |
708 * Buffer Names:: Accessing and changing buffer names. | 908 * Buffer Names:: Accessing and changing buffer names. |
709 * Buffer File Name:: The buffer file name indicates which file | 909 * Buffer File Name:: The buffer file name indicates which file |
710 is visited. | 910 is visited. |
711 * Buffer Modification:: A buffer is @dfn{modified} if it needs to be saved. | 911 * Buffer Modification:: A buffer is @dfn{modified} if it needs to be saved. |
712 * Modification Time:: Determining whether the visited file was changed | 912 * Modification Time:: Determining whether the visited file was changed |
713 "behind Emacs's back". | 913 ``behind Emacs's back''. |
714 * Read Only Buffers:: Modifying text is not allowed in a | 914 * Read Only Buffers:: Modifying text is not allowed in a |
715 read-only buffer. | 915 read-only buffer. |
716 * The Buffer List:: How to look at all the existing buffers. | 916 * The Buffer List:: How to look at all the existing buffers. |
717 * Creating Buffers:: Functions that create buffers. | 917 * Creating Buffers:: Functions that create buffers. |
718 * Killing Buffers:: Buffers exist until explicitly killed. | 918 * Killing Buffers:: Buffers exist until explicitly killed. |
719 * Current Buffer:: Designating a buffer as current | 919 * Indirect Buffers:: An indirect buffer shares text with some |
720 so primitives will access its contents. | 920 other buffer. |
921 * Buffer Gap:: The gap in the buffer. | |
721 | 922 |
722 Windows | 923 Windows |
723 | 924 |
724 * Basic Windows:: Basic information on using windows. | 925 * Basic Windows:: Basic information on using windows. |
725 * Splitting Windows:: Splitting one window into two windows. | 926 * Splitting Windows:: Splitting one window into two windows. |
726 * Deleting Windows:: Deleting a window gives its space to other windows. | 927 * Deleting Windows:: Deleting a window gives its space to other windows. |
727 * Selecting Windows:: The selected window is the one that you edit in. | 928 * Selecting Windows:: The selected window is the one that you edit in. |
728 * Cyclic Window Ordering:: Moving around the existing windows. | 929 * Cyclic Window Ordering:: Moving around the existing windows. |
729 * Buffers and Windows:: Each window displays the contents of a buffer. | 930 * Buffers and Windows:: Each window displays the contents of a buffer. |
730 * Displaying Buffers:: Higher-lever functions for displaying a buffer | 931 * Displaying Buffers:: Higher-level functions for displaying a buffer |
731 and choosing a window for it. | 932 and choosing a window for it. |
933 * Choosing Window:: How to choose a window for displaying a buffer. | |
732 * Window Point:: Each window has its own location of point. | 934 * Window Point:: Each window has its own location of point. |
733 * Window Start:: The display-start position controls which text | 935 * Window Start:: The display-start position controls which text |
734 is on-screen in the window. | 936 is on-screen in the window. |
735 * Vertical Scrolling:: Moving text up and down in the window. | 937 * Textual Scrolling:: Moving text up and down through the window. |
736 * Horizontal Scrolling:: Moving text sideways on the window. | 938 * Vertical Scrolling:: Moving the contents up and down on the window. |
939 * Horizontal Scrolling:: Moving the contents sideways on the window. | |
737 * Size of Window:: Accessing the size of a window. | 940 * Size of Window:: Accessing the size of a window. |
738 * Resizing Windows:: Changing the size of a window. | 941 * Resizing Windows:: Changing the size of a window. |
942 * Coordinates and Windows:: Converting coordinates to windows. | |
943 * Window Tree:: The layout and sizes of all windows in a frame. | |
739 * Window Configurations:: Saving and restoring the state of the screen. | 944 * Window Configurations:: Saving and restoring the state of the screen. |
945 * Window Hooks:: Hooks for scrolling, window size changes, | |
946 redisplay going past a certain point, | |
947 or window configuration changes. | |
740 | 948 |
741 Frames | 949 Frames |
742 | 950 |
743 * Creating Frames:: Creating additional frames. | 951 * Creating Frames:: Creating additional frames. |
744 * Multiple Displays:: Creating frames on other X displays. | 952 * Multiple Displays:: Creating frames on other displays. |
745 * Frame Parameters:: Controlling frame size, position, font, etc. | 953 * Frame Parameters:: Controlling frame size, position, font, etc. |
746 * Frame Titles:: Automatic updating of frame titles. | 954 * Frame Titles:: Automatic updating of frame titles. |
747 * Deleting Frames:: Frames last until explicitly deleted. | 955 * Deleting Frames:: Frames last until explicitly deleted. |
748 * Finding All Frames:: How to examine all existing frames. | 956 * Finding All Frames:: How to examine all existing frames. |
749 * Frames and Windows:: A frame contains windows; | 957 * Frames and Windows:: A frame contains windows; |
750 display of text always works through windows. | 958 display of text always works through windows. |
751 * Minibuffers and Frames:: How a frame finds the minibuffer to use. | 959 * Minibuffers and Frames:: How a frame finds the minibuffer to use. |
752 * Input Focus:: Specifying the selected frame. | 960 * Input Focus:: Specifying the selected frame. |
753 * Visibility of Frames:: Frames may be visible or invisible, or icons. | 961 * Visibility of Frames:: Frames may be visible or invisible, or icons. |
754 * Raising and Lowering:: Raising a frame makes it hide other X windows; | 962 * Raising and Lowering:: Raising a frame makes it hide other windows; |
755 lowering it makes the others hide them. | 963 lowering it puts it underneath the others. |
756 * Frame Configurations:: Saving the state of all frames. | 964 * Frame Configurations:: Saving the state of all frames. |
757 * Mouse Tracking:: Getting events that say when the mouse moves. | 965 * Mouse Tracking:: Getting events that say when the mouse moves. |
758 * Mouse Position:: Asking where the mouse is, or moving it. | 966 * Mouse Position:: Asking where the mouse is, or moving it. |
759 * Pop-Up Menus:: Displaying a menu for the user to select from. | 967 * Pop-Up Menus:: Displaying a menu for the user to select from. |
760 * Dialog Boxes:: Displaying a box to ask yes or no. | 968 * Dialog Boxes:: Displaying a box to ask yes or no. |
761 * Pointer Shapes:: Specifying the shape of the mouse pointer. | 969 * Pointer Shape:: Specifying the shape of the mouse pointer. |
762 * X Selections:: Transferring text to and from other X clients. | 970 * Window System Selections::Transferring text to and from other windows. |
971 * Drag and Drop:: Internals of Drag-and-Drop implementation. | |
763 * Color Names:: Getting the definitions of color names. | 972 * Color Names:: Getting the definitions of color names. |
973 * Text Terminal Colors:: Defining colors for text-only terminals. | |
764 * Resources:: Getting resource values from the server. | 974 * Resources:: Getting resource values from the server. |
765 * Server Data:: Getting info about the X server. | 975 * Display Feature Testing:: Determining the features of a terminal. |
976 | |
977 Frame Parameters | |
978 | |
979 * Parameter Access:: How to change a frame's parameters. | |
980 * Initial Parameters:: Specifying frame parameters when you make a frame. | |
981 * Window Frame Parameters:: List of frame parameters for window systems. | |
982 * Size and Position:: Changing the size and position of a frame. | |
983 * Geometry:: Parsing geometry specifications. | |
984 | |
985 Window Frame Parameters | |
986 | |
987 * Basic Parameters:: Parameters that are fundamental. | |
988 * Position Parameters:: The position of the frame on the screen. | |
989 * Size Parameters:: Frame's size. | |
990 * Layout Parameters:: Size of parts of the frame, and | |
991 enabling or disabling some parts. | |
992 * Buffer Parameters:: Which buffers have been or should be shown. | |
993 * Management Parameters:: Communicating with the window manager. | |
994 * Cursor Parameters:: Controlling the cursor appearance. | |
995 * Color Parameters:: Colors of various parts of the frame. | |
766 | 996 |
767 Positions | 997 Positions |
768 | 998 |
769 * Point:: The special position where editing takes place. | 999 * Point:: The special position where editing takes place. |
770 * Motion:: Changing point. | 1000 * Motion:: Changing point. |
784 Markers | 1014 Markers |
785 | 1015 |
786 * Overview of Markers:: The components of a marker, and how it relocates. | 1016 * Overview of Markers:: The components of a marker, and how it relocates. |
787 * Predicates on Markers:: Testing whether an object is a marker. | 1017 * Predicates on Markers:: Testing whether an object is a marker. |
788 * Creating Markers:: Making empty markers or markers at certain places. | 1018 * Creating Markers:: Making empty markers or markers at certain places. |
789 * Information from Markers:: Finding the marker's buffer or character | 1019 * Information from Markers::Finding the marker's buffer or character |
790 position. | 1020 position. |
791 * Changing Markers:: Moving the marker to a new buffer or position. | 1021 * Marker Insertion Types:: Two ways a marker can relocate when you |
1022 insert where it points. | |
1023 * Moving Markers:: Moving the marker to a new buffer or position. | |
792 * The Mark:: How "the mark" is implemented with a marker. | 1024 * The Mark:: How "the mark" is implemented with a marker. |
793 * The Region:: How to access "the region". | 1025 * The Region:: How to access "the region". |
794 | 1026 |
795 Text | 1027 Text |
796 | 1028 |
797 * Near Point:: Examining text in the vicinity of point. | 1029 * Near Point:: Examining text in the vicinity of point. |
798 * Buffer Contents:: Examining text in a general fashion. | 1030 * Buffer Contents:: Examining text in a general fashion. |
1031 * Comparing Text:: Comparing substrings of buffers. | |
799 * Insertion:: Adding new text to a buffer. | 1032 * Insertion:: Adding new text to a buffer. |
800 * Commands for Insertion:: User-level commands to insert text. | 1033 * Commands for Insertion:: User-level commands to insert text. |
801 * Deletion:: Removing text from a buffer. | 1034 * Deletion:: Removing text from a buffer. |
802 * User-Level Deletion:: User-level commands to delete text. | 1035 * User-Level Deletion:: User-level commands to delete text. |
803 * The Kill Ring:: Where removed text sometimes is saved for | 1036 * The Kill Ring:: Where removed text sometimes is saved for |
804 later use. | 1037 later use. |
805 * Undo:: Undoing changes to the text of a buffer. | 1038 * Undo:: Undoing changes to the text of a buffer. |
806 * Auto Filling:: How auto-fill mode is implemented to break lines. | 1039 * Maintaining Undo:: How to enable and disable undo information. |
1040 How to control how much information is kept. | |
807 * Filling:: Functions for explicit filling. | 1041 * Filling:: Functions for explicit filling. |
808 * Margins:: How to specify margins for filling commands. | 1042 * Margins:: How to specify margins for filling commands. |
1043 * Adaptive Fill:: Adaptive Fill mode chooses a fill prefix | |
1044 from context. | |
1045 * Auto Filling:: How auto-fill mode is implemented to break lines. | |
809 * Sorting:: Functions for sorting parts of the buffer. | 1046 * Sorting:: Functions for sorting parts of the buffer. |
1047 * Columns:: Computing horizontal positions, and using them. | |
810 * Indentation:: Functions to insert or adjust indentation. | 1048 * Indentation:: Functions to insert or adjust indentation. |
811 * Columns:: Computing horizontal positions, and using them. | |
812 * Case Changes:: Case conversion of parts of the buffer. | 1049 * Case Changes:: Case conversion of parts of the buffer. |
1050 * Text Properties:: Assigning Lisp property lists to text characters. | |
813 * Substitution:: Replacing a given character wherever it appears. | 1051 * Substitution:: Replacing a given character wherever it appears. |
1052 * Transposition:: Swapping two portions of a buffer. | |
814 * Registers:: How registers are implemented. Accessing | 1053 * Registers:: How registers are implemented. Accessing |
815 the text or position stored in a register. | 1054 the text or position stored in a register. |
1055 * Base 64:: Conversion to or from base 64 encoding. | |
1056 * MD5 Checksum:: Compute the MD5 "message digest"/"checksum". | |
1057 * Atomic Changes:: Installing several buffer changes "atomically". | |
1058 * Change Hooks:: Supplying functions to be run when text is changed. | |
816 | 1059 |
817 The Kill Ring | 1060 The Kill Ring |
818 | 1061 |
819 * Kill Ring Concepts:: What text looks like in the kill ring. | 1062 * Kill Ring Concepts:: What text looks like in the kill ring. |
820 * Kill Functions:: Functions that kill text. | 1063 * Kill Functions:: Functions that kill text. |
1064 * Yanking:: How yanking is done. | |
821 * Yank Commands:: Commands that access the kill ring. | 1065 * Yank Commands:: Commands that access the kill ring. |
822 * Low-Level Kill Ring:: Functions and variables for kill ring access. | 1066 * Low-Level Kill Ring:: Functions and variables for kill ring access. |
823 * Internals of Kill Ring:: Variables that hold kill-ring data. | 1067 * Internals of Kill Ring:: Variables that hold kill-ring data. |
824 | 1068 |
825 Indentation | 1069 Indentation |
829 * Region Indent:: Indent all the lines in a region. | 1073 * Region Indent:: Indent all the lines in a region. |
830 * Relative Indent:: Indent the current line based on previous lines. | 1074 * Relative Indent:: Indent the current line based on previous lines. |
831 * Indent Tabs:: Adjustable, typewriter-like tab stops. | 1075 * Indent Tabs:: Adjustable, typewriter-like tab stops. |
832 * Motion by Indent:: Move to first non-blank character. | 1076 * Motion by Indent:: Move to first non-blank character. |
833 | 1077 |
1078 Text Properties | |
1079 | |
1080 * Examining Properties:: Looking at the properties of one character. | |
1081 * Changing Properties:: Setting the properties of a range of text. | |
1082 * Property Search:: Searching for where a property changes value. | |
1083 * Special Properties:: Particular properties with special meanings. | |
1084 * Format Properties:: Properties for representing formatting of text. | |
1085 * Sticky Properties:: How inserted text gets properties from | |
1086 neighboring text. | |
1087 * Saving Properties:: Saving text properties in files, and reading | |
1088 them back. | |
1089 * Lazy Properties:: Computing text properties in a lazy fashion | |
1090 only when text is examined. | |
1091 * Clickable Text:: Using text properties to make regions of text | |
1092 do something when you click on them. | |
1093 * Links and Mouse-1:: How to make @key{Mouse-1} follow a link. | |
1094 * Fields:: The @code{field} property defines | |
1095 fields within the buffer. | |
1096 * Not Intervals:: Why text properties do not use | |
1097 Lisp-visible text intervals. | |
1098 | |
1099 Non-ASCII Characters | |
1100 | |
1101 * Text Representations:: Unibyte and multibyte representations | |
1102 * Converting Representations:: Converting unibyte to multibyte and vice versa. | |
1103 * Selecting a Representation:: Treating a byte sequence as unibyte or multi. | |
1104 * Character Codes:: How unibyte and multibyte relate to | |
1105 codes of individual characters. | |
1106 * Character Sets:: The space of possible character codes | |
1107 is divided into various character sets. | |
1108 * Chars and Bytes:: More information about multibyte encodings. | |
1109 * Splitting Characters:: Converting a character to its byte sequence. | |
1110 * Scanning Charsets:: Which character sets are used in a buffer? | |
1111 * Translation of Characters:: Translation tables are used for conversion. | |
1112 * Coding Systems:: Coding systems are conversions for saving files. | |
1113 * Input Methods:: Input methods allow users to enter various | |
1114 non-ASCII characters without special keyboards. | |
1115 * Locales:: Interacting with the POSIX locale. | |
1116 | |
1117 Coding Systems | |
1118 | |
1119 * Coding System Basics:: Basic concepts. | |
1120 * Encoding and I/O:: How file I/O functions handle coding systems. | |
1121 * Lisp and Coding Systems:: Functions to operate on coding system names. | |
1122 * User-Chosen Coding Systems:: Asking the user to choose a coding system. | |
1123 * Default Coding Systems:: Controlling the default choices. | |
1124 * Specifying Coding Systems:: Requesting a particular coding system | |
1125 for a single file operation. | |
1126 * Explicit Encoding:: Encoding or decoding text without doing I/O. | |
1127 * Terminal I/O Encoding:: Use of encoding for terminal I/O. | |
1128 * MS-DOS File Types:: How DOS "text" and "binary" files | |
1129 relate to coding systems. | |
1130 | |
834 Searching and Matching | 1131 Searching and Matching |
835 | 1132 |
836 * String Search:: Search for an exact match. | 1133 * String Search:: Search for an exact match. |
1134 * Searching and Case:: Case-independent or case-significant searching. | |
837 * Regular Expressions:: Describing classes of strings. | 1135 * Regular Expressions:: Describing classes of strings. |
838 * Regexp Search:: Searching for a match for a regexp. | 1136 * Regexp Search:: Searching for a match for a regexp. |
839 * Match Data:: Finding out which part of the text matched | 1137 * POSIX Regexps:: Searching POSIX-style for the longest match. |
840 various parts of a regexp, after regexp search. | 1138 * Match Data:: Finding out which part of the text matched, |
841 * Saving Match Data:: Saving and restoring this information. | 1139 after a string or regexp search. |
1140 * Search and Replace:: Commands that loop, searching and replacing. | |
842 * Standard Regexps:: Useful regexps for finding sentences, pages,... | 1141 * Standard Regexps:: Useful regexps for finding sentences, pages,... |
843 * Searching and Case:: Case-independent or case-significant searching. | |
844 | 1142 |
845 Regular Expressions | 1143 Regular Expressions |
846 | 1144 |
847 * Syntax of Regexps:: Rules for writing regular expressions. | 1145 * Syntax of Regexps:: Rules for writing regular expressions. |
848 * Regexp Example:: Illustrates regular expression syntax. | 1146 * Regexp Example:: Illustrates regular expression syntax. |
1147 * Regexp Functions:: Functions for operating on regular expressions. | |
1148 | |
1149 Syntax of Regular Expressions | |
1150 | |
1151 * Regexp Special:: Special characters in regular expressions. | |
1152 * Char Classes:: Character classes used in regular expressions. | |
1153 * Regexp Backslash:: Backslash-sequences in regular expressions. | |
1154 | |
1155 The Match Data | |
1156 | |
1157 * Replacing Match:: Replacing a substring that was matched. | |
1158 * Simple Match Data:: Accessing single items of match data, | |
1159 such as where a particular subexpression started. | |
1160 * Entire Match Data:: Accessing the entire match data at once, as a list. | |
1161 * Saving Match Data:: Saving and restoring the match data. | |
849 | 1162 |
850 Syntax Tables | 1163 Syntax Tables |
851 | 1164 |
1165 * Syntax Basics:: Basic concepts of syntax tables. | |
852 * Syntax Descriptors:: How characters are classified. | 1166 * Syntax Descriptors:: How characters are classified. |
853 * Syntax Table Functions:: How to create, examine and alter syntax tables. | 1167 * Syntax Table Functions:: How to create, examine and alter syntax tables. |
1168 * Syntax Properties:: Overriding syntax with text properties. | |
1169 * Motion and Syntax:: Moving over characters with certain syntaxes. | |
854 * Parsing Expressions:: Parsing balanced expressions | 1170 * Parsing Expressions:: Parsing balanced expressions |
855 using the syntax table. | 1171 using the syntax table. |
856 * Standard Syntax Tables:: Syntax tables used by various major modes. | 1172 * Standard Syntax Tables:: Syntax tables used by various major modes. |
857 * Syntax Table Internals:: How syntax table information is stored. | 1173 * Syntax Table Internals:: How syntax table information is stored. |
1174 * Categories:: Another way of classifying character syntax. | |
858 | 1175 |
859 Syntax Descriptors | 1176 Syntax Descriptors |
860 | 1177 |
861 * Syntax Class Table:: Table of syntax classes. | 1178 * Syntax Class Table:: Table of syntax classes. |
862 * Syntax Flags:: Additional flags each character can have. | 1179 * Syntax Flags:: Additional flags each character can have. |
863 | 1180 |
1181 Parsing Expressions | |
1182 | |
1183 * Motion via Parsing:: Motion functions that work by parsing. | |
1184 * Position Parse:: Determining the syntactic state of a position. | |
1185 * Parser State:: How Emacs represents a syntactic state. | |
1186 * Low-Level Parsing:: Parsing across a specified region. | |
1187 * Control Parsing:: Parameters that affect parsing. | |
1188 | |
864 Abbrevs And Abbrev Expansion | 1189 Abbrevs And Abbrev Expansion |
865 | 1190 |
866 * Abbrev Mode:: Setting up Emacs for abbreviation. | 1191 * Abbrev Mode:: Setting up Emacs for abbreviation. |
867 * Tables: Abbrev Tables. Creating and working with abbrev tables. | 1192 * Abbrev Tables:: Creating and working with abbrev tables. |
868 * Defining Abbrevs:: Specifying abbreviations and their expansions. | 1193 * Defining Abbrevs:: Specifying abbreviations and their expansions. |
869 * Files: Abbrev Files. Saving abbrevs in files. | 1194 * Abbrev Files:: Saving abbrevs in files. |
870 * Expansion: Abbrev Expansion. Controlling expansion; expansion subroutines. | 1195 * Abbrev Expansion:: Controlling expansion; expansion subroutines. |
871 * Standard Abbrev Tables:: Abbrev tables used by various major modes. | 1196 * Standard Abbrev Tables:: Abbrev tables used by various major modes. |
872 | 1197 |
873 Processes | 1198 Processes |
874 | 1199 |
875 * Subprocess Creation:: Functions that start subprocesses. | 1200 * Subprocess Creation:: Functions that start subprocesses. |
1201 * Shell Arguments:: Quoting an argument to pass it to a shell. | |
876 * Synchronous Processes:: Details of using synchronous subprocesses. | 1202 * Synchronous Processes:: Details of using synchronous subprocesses. |
877 * Asynchronous Processes:: Starting up an asynchronous subprocess. | 1203 * Asynchronous Processes:: Starting up an asynchronous subprocess. |
878 * Deleting Processes:: Eliminating an asynchronous subprocess. | 1204 * Deleting Processes:: Eliminating an asynchronous subprocess. |
879 * Process Information:: Accessing run-status and other attributes. | 1205 * Process Information:: Accessing run-status and other attributes. |
880 * Input to Processes:: Sending input to an asynchronous subprocess. | 1206 * Input to Processes:: Sending input to an asynchronous subprocess. |
881 * Signals to Processes:: Stopping, continuing or interrupting | 1207 * Signals to Processes:: Stopping, continuing or interrupting |
882 an asynchronous subprocess. | 1208 an asynchronous subprocess. |
883 * Output from Processes:: Collecting output from an asynchronous subprocess. | 1209 * Output from Processes:: Collecting output from an asynchronous subprocess. |
884 * Sentinels:: Sentinels run when process run-status changes. | 1210 * Sentinels:: Sentinels run when process run-status changes. |
1211 * Query Before Exit:: Whether to query if exiting will kill a process. | |
1212 * Transaction Queues:: Transaction-based communication with subprocesses. | |
885 * Network:: Opening network connections. | 1213 * Network:: Opening network connections. |
1214 * Network Servers:: Network servers let Emacs accept net connections. | |
1215 * Datagrams:: UDP network connections. | |
1216 * Low-Level Network:: Lower-level but more general function | |
1217 to create connections and servers. | |
1218 * Misc Network:: Additional relevant functions for network connections. | |
1219 * Byte Packing:: Using bindat to pack and unpack binary data. | |
886 | 1220 |
887 Receiving Output from Processes | 1221 Receiving Output from Processes |
888 | 1222 |
889 * Process Buffers:: If no filter, output is put in a buffer. | 1223 * Process Buffers:: If no filter, output is put in a buffer. |
890 * Filter Functions:: Filter functions accept output from the process. | 1224 * Filter Functions:: Filter functions accept output from the process. |
1225 * Decoding Output:: Filters can get unibyte or multibyte strings. | |
891 * Accepting Output:: How to wait until process output arrives. | 1226 * Accepting Output:: How to wait until process output arrives. |
1227 | |
1228 Low-Level Network Access | |
1229 | |
1230 * Proc: Network Processes. Using @code{make-network-process}. | |
1231 * Options: Network Options. Further control over network connections. | |
1232 * Features: Network Feature Testing. | |
1233 Determining which network features work on | |
1234 the machine you are using. | |
1235 | |
1236 Packing and Unpacking Byte Arrays | |
1237 | |
1238 * Bindat Spec:: Describing data layout. | |
1239 * Bindat Functions:: Doing the unpacking and packing. | |
1240 * Bindat Examples:: Samples of what bindat.el can do for you! | |
1241 | |
1242 Emacs Display | |
1243 | |
1244 * Refresh Screen:: Clearing the screen and redrawing everything on it. | |
1245 * Forcing Redisplay:: Forcing redisplay. | |
1246 * Truncation:: Folding or wrapping long text lines. | |
1247 * The Echo Area:: Displaying messages at the bottom of the screen. | |
1248 * Warnings:: Displaying warning messages for the user. | |
1249 * Invisible Text:: Hiding part of the buffer text. | |
1250 * Selective Display:: Hiding part of the buffer text (the old way). | |
1251 * Temporary Displays:: Displays that go away automatically. | |
1252 * Overlays:: Use overlays to highlight parts of the buffer. | |
1253 * Width:: How wide a character or string is on the screen. | |
1254 * Line Height:: Controlling the height of lines. | |
1255 * Faces:: A face defines a graphics style | |
1256 for text characters: font, colors, etc. | |
1257 * Fringes:: Controlling window fringes. | |
1258 * Scroll Bars:: Controlling vertical scroll bars. | |
1259 * Display Property:: Enabling special display features. | |
1260 * Images:: Displaying images in Emacs buffers. | |
1261 * Buttons:: Adding clickable buttons to Emacs buffers. | |
1262 * Abstract Display:: Emacs' Widget for Object Collections. | |
1263 * Blinking:: How Emacs shows the matching open parenthesis. | |
1264 * Usual Display:: The usual conventions for displaying nonprinting chars. | |
1265 * Display Tables:: How to specify other conventions. | |
1266 * Beeping:: Audible signal to the user. | |
1267 * Window Systems:: Which window system is being used. | |
1268 | |
1269 The Echo Area | |
1270 | |
1271 * Displaying Messages:: Explicitly displaying text in the echo area. | |
1272 * Progress:: Informing user about progress of a long operation. | |
1273 * Logging Messages:: Echo area messages are logged for the user. | |
1274 * Echo Area Customization:: Controlling the echo area. | |
1275 | |
1276 Reporting Warnings | |
1277 | |
1278 * Warning Basics:: Warnings concepts and functions to report them. | |
1279 * Warning Variables:: Variables programs bind to customize their warnings. | |
1280 * Warning Options:: Variables users set to control display of warnings. | |
1281 | |
1282 Overlays | |
1283 | |
1284 * Managing Overlays:: Creating and moving overlays. | |
1285 * Overlay Properties:: How to read and set properties. | |
1286 What properties do to the screen display. | |
1287 * Finding Overlays:: Searching for overlays. | |
1288 | |
1289 Faces | |
1290 | |
1291 * Defining Faces:: How to define a face with @code{defface}. | |
1292 * Face Attributes:: What is in a face? | |
1293 * Attribute Functions:: Functions to examine and set face attributes. | |
1294 * Displaying Faces:: How Emacs combines the faces specified for | |
1295 a character. | |
1296 * Font Selection:: Finding the best available font for a face. | |
1297 * Face Functions:: How to define and examine faces. | |
1298 * Auto Faces:: Hook for automatic face assignment. | |
1299 * Font Lookup:: Looking up the names of available fonts | |
1300 and information about them. | |
1301 * Fontsets:: A fontset is a collection of fonts | |
1302 that handle a range of character sets. | |
1303 | |
1304 Fringes | |
1305 | |
1306 * Fringe Size/Pos:: Specifying where to put the window fringes. | |
1307 * Fringe Indicators:: Displaying indicator icons in the window fringes. | |
1308 * Fringe Cursors:: Displaying cursors in the right fringe. | |
1309 * Fringe Bitmaps:: Specifying bitmaps for fringe indicators. | |
1310 * Customizing Bitmaps:: Specifying your own bitmaps to use in the fringes. | |
1311 * Overlay Arrow:: Display of an arrow to indicate position. | |
1312 | |
1313 The @code{display} Property | |
1314 | |
1315 * Specified Space:: Displaying one space with a specified width. | |
1316 * Pixel Specification:: Specifying space width or height in pixels. | |
1317 * Other Display Specs:: Displaying an image; magnifying text; moving it | |
1318 up or down on the page; adjusting the width | |
1319 of spaces within text. | |
1320 * Display Margins:: Displaying text or images to the side of | |
1321 the main text. | |
1322 | |
1323 Images | |
1324 | |
1325 * Image Descriptors:: How to specify an image for use in @code{:display}. | |
1326 * XBM Images:: Special features for XBM format. | |
1327 * XPM Images:: Special features for XPM format. | |
1328 * GIF Images:: Special features for GIF format. | |
1329 * PostScript Images:: Special features for PostScript format. | |
1330 * Other Image Types:: Various other formats are supported. | |
1331 * Defining Images:: Convenient ways to define an image for later use. | |
1332 * Showing Images:: Convenient ways to display an image once | |
1333 it is defined. | |
1334 * Image Cache:: Internal mechanisms of image display. | |
1335 | |
1336 Buttons | |
1337 | |
1338 * Button Properties:: Button properties with special meanings. | |
1339 * Button Types:: Defining common properties for classes of buttons. | |
1340 * Making Buttons:: Adding buttons to Emacs buffers. | |
1341 * Manipulating Buttons:: Getting and setting properties of buttons. | |
1342 * Button Buffer Commands:: Buffer-wide commands and bindings for buttons. | |
1343 | |
1344 Abstract Display | |
1345 | |
1346 * Abstract Display Functions:: Functions in the Ewoc package. | |
1347 * Abstract Display Example:: Example of using Ewoc. | |
1348 | |
1349 Display Tables | |
1350 | |
1351 * Display Table Format:: What a display table consists of. | |
1352 * Active Display Table:: How Emacs selects a display table to use. | |
1353 * Glyphs:: How to define a glyph, and what glyphs mean. | |
892 | 1354 |
893 Operating System Interface | 1355 Operating System Interface |
894 | 1356 |
895 * Starting Up:: Customizing Emacs start-up processing. | 1357 * Starting Up:: Customizing Emacs start-up processing. |
896 * Getting Out:: How exiting works (permanent or temporary). | 1358 * Getting Out:: How exiting works (permanent or temporary). |
897 * System Environment:: Distinguish the name and kind of system. | 1359 * System Environment:: Distinguish the name and kind of system. |
898 * Terminal Input:: Recording terminal input for debugging. | 1360 * User Identification:: Finding the name and user id of the user. |
899 * Terminal Output:: Recording terminal output for debugging. | 1361 * Time of Day:: Getting the current time. |
900 * Flow Control:: How to turn output flow control on or off. | 1362 * Time Conversion:: Converting a time from numeric form to a string, or |
1363 to calendrical data (or vice versa). | |
1364 * Time Parsing:: Converting a time from numeric form to text | |
1365 and vice versa. | |
1366 * Processor Run Time:: Getting the run time used by Emacs. | |
1367 * Time Calculations:: Adding, subtracting, comparing times, etc. | |
1368 * Timers:: Setting a timer to call a function at a certain time. | |
1369 * Idle Timers:: Setting a timer to call a function when Emacs has | |
1370 been idle for a certain length of time. | |
1371 * Terminal Input:: Accessing and recording terminal input. | |
1372 * Terminal Output:: Controlling and recording terminal output. | |
1373 * Sound Output:: Playing sounds on the computer's speaker. | |
1374 * X11 Keysyms:: Operating on key symbols for X Windows | |
901 * Batch Mode:: Running Emacs without terminal interaction. | 1375 * Batch Mode:: Running Emacs without terminal interaction. |
1376 * Session Management:: Saving and restoring state with X Session Management. | |
902 | 1377 |
903 Starting Up Emacs | 1378 Starting Up Emacs |
904 | 1379 |
905 * Start-up Summary:: Sequence of actions Emacs performs at start-up. | 1380 * Startup Summary:: Sequence of actions Emacs performs at start-up. |
906 * Init File:: Details on reading the init file (@file{.emacs}). | 1381 * Init File:: Details on reading the init file (@file{.emacs}). |
907 * Terminal-Specific:: How the terminal-specific Lisp file is read. | 1382 * Terminal-Specific:: How the terminal-specific Lisp file is read. |
908 * Command Line Arguments:: How command line arguments are processed, | 1383 * Command-Line Arguments:: How command-line arguments are processed, |
909 and how you can customize them. | 1384 and how you can customize them. |
910 | 1385 |
911 Getting out of Emacs | 1386 Getting Out of Emacs |
912 | 1387 |
913 * Killing Emacs:: Exiting Emacs irreversibly. | 1388 * Killing Emacs:: Exiting Emacs irreversibly. |
914 * Suspending Emacs:: Exiting Emacs reversibly. | 1389 * Suspending Emacs:: Exiting Emacs reversibly. |
915 | 1390 |
916 Emacs Display | 1391 Terminal Input |
917 | 1392 |
918 * Refresh Screen:: Clearing the screen and redrawing everything on it. | 1393 * Input Modes:: Options for how input is processed. |
919 * Truncation:: Folding or wrapping long text lines. | 1394 * Recording Input:: Saving histories of recent or all input events. |
920 * The Echo Area:: Where messages are displayed. | 1395 |
921 * Selective Display:: Hiding part of the buffer text. | 1396 Tips and Conventions |
922 * Overlay Arrow:: Display of an arrow to indicate position. | 1397 |
923 * Temporary Displays:: Displays that go away automatically. | 1398 * Coding Conventions:: Conventions for clean and robust programs. |
924 * Waiting:: Forcing display update and waiting for user. | 1399 * Key Binding Conventions:: Which keys should be bound by which programs. |
925 * Blinking:: How Emacs shows the matching open parenthesis. | 1400 * Programming Tips:: Making Emacs code fit smoothly in Emacs. |
926 * Usual Display:: How control characters are displayed. | 1401 * Compilation Tips:: Making compiled code run fast. |
927 * Beeping:: Audible signal to the user. | 1402 * Warning Tips:: Turning off compiler warnings. |
928 * Window Systems:: Which window system is being used. | 1403 * Documentation Tips:: Writing readable documentation strings. |
1404 * Comment Tips:: Conventions for writing comments. | |
1405 * Library Headers:: Standard headers for library packages. | |
929 | 1406 |
930 GNU Emacs Internals | 1407 GNU Emacs Internals |
931 | 1408 |
932 * Building Emacs:: How to preload Lisp libraries into Emacs. | 1409 * Building Emacs:: How the dumped Emacs is made. |
933 * Pure Storage:: A kludge to make preloaded Lisp functions sharable. | 1410 * Pure Storage:: A kludge to make preloaded Lisp functions sharable. |
934 * Garbage Collection:: Reclaiming space for Lisp objects no longer used. | 1411 * Garbage Collection:: Reclaiming space for Lisp objects no longer used. |
1412 * Memory Usage:: Info about total size of Lisp objects made so far. | |
1413 * Writing Emacs Primitives:: Writing C code for Emacs. | |
935 * Object Internals:: Data formats of buffers, windows, processes. | 1414 * Object Internals:: Data formats of buffers, windows, processes. |
936 * Writing Emacs Primitives:: Writing C code for Emacs. | |
937 | 1415 |
938 Object Internals | 1416 Object Internals |
939 | 1417 |
940 * Buffer Internals:: Components of a buffer structure. | 1418 * Buffer Internals:: Components of a buffer structure. |
941 * Window Internals:: Components of a window structure. | 1419 * Window Internals:: Components of a window structure. |
942 * Process Internals:: Components of a process structure. | 1420 * Process Internals:: Components of a process structure. |
1421 @end detailmenu | |
943 @end menu | 1422 @end menu |
944 | |
945 @c ================ Volume 1 ================ | |
946 | 1423 |
947 @c include intro.texi | 1424 @c include intro.texi |
948 @c include objects.texi | 1425 @c include objects.texi |
949 @c include numbers.texi | 1426 @c include numbers.texi |
950 @c include strings.texi | 1427 @c include strings.texi |
951 | 1428 |
952 @c include lists.texi | 1429 @c include lists.texi |
953 @c include sequences.texi | 1430 @c include sequences.texi |
1431 @c include hash.texi | |
954 @c include symbols.texi | 1432 @c include symbols.texi |
955 @c include eval.texi | 1433 @c include eval.texi |
956 | 1434 |
957 @c include control.texi | 1435 @c include control.texi |
958 @c include variables.texi | 1436 @c include variables.texi |
959 @c include functions.texi | 1437 @c include functions.texi |
960 @c include macros.texi | 1438 @c include macros.texi |
961 | 1439 |
1440 @c include customize.texi | |
962 @c include loading.texi | 1441 @c include loading.texi |
963 @c include compile.texi | 1442 @c include compile.texi |
1443 @c include advice.texi | |
1444 | |
964 @c include debugging.texi | 1445 @c include debugging.texi |
965 @c include streams.texi | 1446 @c include streams.texi |
966 | |
967 @c include minibuf.texi | 1447 @c include minibuf.texi |
968 @c include commands.texi | 1448 @c include commands.texi |
1449 | |
969 @c include keymaps.texi | 1450 @c include keymaps.texi |
970 @c include modes.texi | 1451 @c include modes.texi |
1452 @c include help.texi | |
1453 @c include files.texi | |
1454 | |
1455 @c include backups.texi | |
971 | 1456 |
972 @c ================ Beginning of Volume 2 ================ | 1457 @c ================ Beginning of Volume 2 ================ |
973 | |
974 @include help.texi | |
975 @include files.texi | |
976 @include backups.texi | |
977 @include buffers.texi | 1458 @include buffers.texi |
978 | |
979 @include windows.texi | 1459 @include windows.texi |
980 @include frames.texi | 1460 @include frames.texi |
1461 | |
981 @include positions.texi | 1462 @include positions.texi |
982 @include markers.texi | 1463 @include markers.texi |
983 @include text.texi | 1464 @include text.texi |
1465 @include nonascii.texi | |
984 | 1466 |
985 @include searching.texi | 1467 @include searching.texi |
986 @include syntax.texi | 1468 @include syntax.texi |
987 @include abbrevs.texi | 1469 @include abbrevs.texi |
988 | |
989 @include processes.texi | 1470 @include processes.texi |
1471 | |
1472 @include display.texi | |
990 @include os.texi | 1473 @include os.texi |
991 @include display.texi | |
992 | 1474 |
993 @c MOVE to Emacs Manual: include misc-modes.texi | 1475 @c MOVE to Emacs Manual: include misc-modes.texi |
994 | 1476 |
995 @c appendices | 1477 @c appendices |
996 | 1478 |
997 @c REMOVE this: include non-hacker.texi | 1479 @c REMOVE this: include non-hacker.texi |
998 | 1480 |
1481 @include anti.texi | |
1482 @include doclicense.texi | |
1483 @include gpl.texi | |
999 @include tips.texi | 1484 @include tips.texi |
1000 @include internals.texi | 1485 @include internals.texi |
1001 @include errors.texi | 1486 @include errors.texi |
1002 @include locals.texi | 1487 @include locals.texi |
1003 @include maps.texi | 1488 @include maps.texi |
1004 @include hooks.texi | 1489 @include hooks.texi |
1005 | 1490 |
1006 @include index-vol2.texi | 1491 @include index.texi |
1007 | 1492 |
1008 @page | 1493 @ignore |
1009 @c Print the tables of contents | 1494 @node New Symbols, , Index, Top |
1010 @summarycontents | 1495 @unnumbered New Symbols Since the Previous Edition |
1011 @contents | 1496 |
1012 @c That's all | 1497 @printindex tp |
1498 @end ignore | |
1013 | 1499 |
1014 @bye | 1500 @bye |
1015 | 1501 |
1016 | 1502 |
1017 These words prevent "local variables" above from confusing Emacs. | 1503 These words prevent "local variables" above from confusing Emacs. |