83955
|
1 \input texinfo @c -*-texinfo-*-
|
|
2 @comment %**start of header
|
83965
|
3 @setfilename ../../info/eintr
|
83955
|
4 @c setfilename emacs-lisp-intro.info
|
|
5 @c sethtmlfilename emacs-lisp-intro.html
|
|
6 @settitle Programming in Emacs Lisp
|
|
7 @syncodeindex vr cp
|
|
8 @syncodeindex fn cp
|
|
9 @finalout
|
|
10
|
|
11 @c ---------
|
|
12 @c <<<< For hard copy printing, this file is now
|
|
13 @c set for smallbook, which works for all sizes
|
|
14 @c of paper, and with Postscript figures >>>>
|
98525
|
15 @set smallbook
|
|
16 @ifset smallbook
|
83955
|
17 @smallbook
|
|
18 @clear largebook
|
98525
|
19 @end ifset
|
83955
|
20 @set print-postscript-figures
|
|
21 @c set largebook
|
|
22 @c clear print-postscript-figures
|
|
23 @c ---------
|
|
24
|
|
25 @comment %**end of header
|
|
26
|
98525
|
27 @c per rms and peterb, use 10pt fonts for the main text, mostly to
|
102151
|
28 @c save on paper cost.
|
98525
|
29 @c Do this inside @tex for now, so current makeinfo does not complain.
|
|
30 @tex
|
|
31 @ifset smallbook
|
|
32 @fonttextsize 10
|
105790
a753ed9de6b4
removed lines 33 and 34 of emacs-lisp-intro.texi which said
Robert J. Chassell <bob@rattlesnake.com>
diff
changeset
|
33
|
98525
|
34 @end ifset
|
|
35 \global\hbadness=6666 % don't worry about not-too-underfull boxes
|
|
36 @end tex
|
|
37
|
105790
a753ed9de6b4
removed lines 33 and 34 of emacs-lisp-intro.texi which said
Robert J. Chassell <bob@rattlesnake.com>
diff
changeset
|
38 @set edition-number 3.10
|
a753ed9de6b4
removed lines 33 and 34 of emacs-lisp-intro.texi which said
Robert J. Chassell <bob@rattlesnake.com>
diff
changeset
|
39 @set update-date 28 October 2009
|
105781
|
40
|
83955
|
41 @ignore
|
|
42 ## Summary of shell commands to create various output formats:
|
|
43
|
|
44 pushd /usr/local/src/emacs/lispintro/
|
|
45 ## pushd /u/intro/
|
|
46
|
|
47 ## Info output
|
|
48 makeinfo --paragraph-indent=0 --verbose emacs-lisp-intro.texi
|
|
49
|
|
50 ## ;; (progn (when (bufferp (get-buffer "*info*")) (kill-buffer "*info*")) (info "/usr/local/src/emacs/info/eintr"))
|
|
51
|
|
52 ## DVI output
|
|
53 texi2dvi emacs-lisp-intro.texi
|
|
54
|
|
55 ## xdvi -margins 24pt -topmargin 4pt -offsets 24pt -geometry 760x1140 -s 5 -useTeXpages -mousemode 1 emacs-lisp-intro.dvi &
|
|
56
|
|
57 ## HTML output
|
|
58 makeinfo --html --no-split --verbose emacs-lisp-intro.texi
|
|
59
|
|
60 ## galeon emacs-lisp-intro.html
|
|
61
|
|
62 ## Plain text output
|
|
63 makeinfo --fill-column=70 --no-split --paragraph-indent=0 \
|
|
64 --verbose --no-headers --output=emacs-lisp-intro.txt emacs-lisp-intro.texi
|
|
65
|
|
66 popd
|
|
67
|
|
68 # as user `root'
|
|
69 # insert thumbdrive
|
|
70 mtusb # mount -v -t ext3 /dev/sda /mnt
|
|
71 cp -v /u/intro/emacs-lisp-intro.texi /mnt/backup/intro/emacs-lisp-intro.texi
|
|
72 umtusb # umount -v /mnt
|
|
73 # remove thumbdrive
|
|
74
|
|
75 ## Other shell commands
|
|
76
|
|
77 pushd /usr/local/src/emacs/lispintro/
|
|
78 ## pushd /u/intro/
|
|
79
|
|
80 ## PDF
|
|
81 texi2dvi --pdf emacs-lisp-intro.texi
|
|
82 # xpdf emacs-lisp-intro.pdf &
|
|
83
|
|
84 ## DocBook -- note file extension
|
|
85 makeinfo --docbook --no-split --paragraph-indent=0 \
|
|
86 --verbose --output=emacs-lisp-intro.docbook emacs-lisp-intro.texi
|
|
87
|
|
88 ## XML with a Texinfo DTD -- note file extension
|
|
89 makeinfo --xml --no-split --paragraph-indent=0 \
|
|
90 --verbose --output=emacs-lisp-intro.texinfoxml emacs-lisp-intro.texi
|
|
91
|
|
92 ## PostScript (needs DVI)
|
|
93 # gv emacs-lisp-intro.ps &
|
|
94 # Create DVI if we lack it
|
|
95 # texi2dvi emacs-lisp-intro.texi
|
|
96 dvips emacs-lisp-intro.dvi -o emacs-lisp-intro.ps
|
|
97
|
|
98 ## RTF (needs HTML)
|
|
99 # Use OpenOffice to view RTF
|
|
100 # Create HTML if we lack it
|
|
101 # makeinfo --no-split --html emacs-lisp-intro.texi
|
|
102 /usr/local/src/html2rtf.pl emacs-lisp-intro.html
|
|
103
|
|
104 ## LaTeX (needs RTF)
|
|
105 /usr/bin/rtf2latex emacs-lisp-intro.rtf
|
|
106
|
|
107 popd
|
|
108
|
|
109 @end ignore
|
|
110
|
|
111 @c ================ Included Figures ================
|
|
112
|
|
113 @c Set print-postscript-figures if you print PostScript figures.
|
|
114 @c If you clear this, the ten figures will be printed as ASCII diagrams.
|
|
115 @c (This is not relevant to Info, since Info only handles ASCII.)
|
|
116 @c Your site may require editing changes to print PostScript; in this
|
|
117 @c case, search for `print-postscript-figures' and make appropriate changes.
|
|
118
|
|
119 @c ================ How to Create an Info file ================
|
|
120
|
|
121 @c If you have `makeinfo' installed, run the following command
|
|
122
|
|
123 @c makeinfo emacs-lisp-intro.texi
|
|
124
|
|
125 @c or, if you want a single, large Info file, and no paragraph indents:
|
|
126 @c makeinfo --no-split --paragraph-indent=0 --verbose emacs-lisp-intro.texi
|
|
127
|
|
128 @c After creating the Info file, edit your Info `dir' file, if the
|
|
129 @c `dircategory' section below does not enable your system to
|
|
130 @c install the manual automatically.
|
|
131 @c (The `dir' file is often in the `/usr/local/share/info/' directory.)
|
|
132
|
|
133 @c ================ How to Create an HTML file ================
|
|
134
|
|
135 @c To convert to HTML format
|
|
136 @c makeinfo --html --no-split --verbose emacs-lisp-intro.texi
|
|
137
|
|
138 @c ================ How to Print a Book in Various Sizes ================
|
|
139
|
|
140 @c This book can be printed in any of three different sizes.
|
|
141 @c In the above header, set @-commands appropriately.
|
|
142
|
|
143 @c 7 by 9.25 inches:
|
|
144 @c @smallbook
|
|
145 @c @clear largebook
|
|
146
|
|
147 @c 8.5 by 11 inches:
|
|
148 @c @c smallbook
|
|
149 @c @set largebook
|
|
150
|
|
151 @c European A4 size paper:
|
|
152 @c @c smallbook
|
|
153 @c @afourpaper
|
|
154 @c @set largebook
|
|
155
|
|
156 @c ================ How to Typeset and Print ================
|
|
157
|
|
158 @c If you do not include PostScript figures, run either of the
|
|
159 @c following command sequences, or similar commands suited to your
|
|
160 @c system:
|
|
161
|
|
162 @c texi2dvi emacs-lisp-intro.texi
|
|
163 @c lpr -d emacs-lisp-intro.dvi
|
|
164
|
|
165 @c or else:
|
|
166
|
|
167 @c tex emacs-lisp-intro.texi
|
|
168 @c texindex emacs-lisp-intro.??
|
|
169 @c tex emacs-lisp-intro.texi
|
|
170 @c lpr -d emacs-lisp-intro.dvi
|
|
171
|
|
172 @c If you include the PostScript figures, and you have old software,
|
|
173 @c you may need to convert the .dvi file to a .ps file before
|
|
174 @c printing. Run either of the following command sequences, or one
|
|
175 @c similar:
|
|
176 @c
|
|
177 @c dvips -f < emacs-lisp-intro.dvi > emacs-lisp-intro.ps
|
|
178 @c
|
|
179 @c or else:
|
|
180 @c
|
|
181 @c postscript -p < emacs-lisp-intro.dvi > emacs-lisp-intro.ps
|
|
182 @c
|
|
183
|
|
184 @c (Note: if you edit the book so as to change the length of the
|
|
185 @c table of contents, you may have to change the value of `pageno' below.)
|
|
186
|
|
187 @c ================ End of Formatting Sections ================
|
|
188
|
|
189 @c For next or subsequent edition:
|
|
190 @c create function using with-output-to-temp-buffer
|
|
191 @c create a major mode, with keymaps
|
|
192 @c run an asynchronous process, like grep or diff
|
|
193
|
|
194 @c For 8.5 by 11 inch format: do not use such a small amount of
|
|
195 @c whitespace between paragraphs as smallbook format
|
|
196 @ifset largebook
|
|
197 @tex
|
|
198 \global\parskip 6pt plus 1pt
|
|
199 @end tex
|
|
200 @end ifset
|
|
201
|
|
202 @c For all sized formats: print within-book cross
|
|
203 @c reference with ``...'' rather than [...]
|
|
204
|
|
205 @c This works with the texinfo.tex file, version 2003-05-04.08,
|
|
206 @c in the Texinfo version 4.6 of the 2003 Jun 13 distribution.
|
|
207
|
|
208 @tex
|
|
209 \if \xrefprintnodename
|
|
210 \global\def\xrefprintnodename#1{\unskip, ``#1''}
|
|
211 \else
|
|
212 \global\def\xrefprintnodename#1{ ``#1''}
|
|
213 \fi
|
|
214 % \global\def\xrefprintnodename#1{, ``#1''}
|
|
215 @end tex
|
|
216
|
|
217 @c ----------------------------------------------------
|
|
218
|
|
219 @dircategory Emacs
|
|
220 @direntry
|
|
221 * Emacs Lisp Intro: (eintr).
|
|
222 A simple introduction to Emacs Lisp programming.
|
|
223 @end direntry
|
|
224
|
|
225 @copying
|
|
226 This is an @cite{Introduction to Programming in Emacs Lisp}, for
|
|
227 people who are not programmers.
|
|
228 @sp 1
|
|
229 Edition @value{edition-number}, @value{update-date}
|
|
230 @sp 1
|
|
231 Copyright @copyright{} 1990, 1991, 1992, 1993, 1994, 1995, 1997, 2001,
|
100974
|
232 2002, 2003, 2004, 2005, 2006, 2007, 2008, 2009 Free Software Foundation, Inc.
|
83955
|
233 @sp 1
|
|
234
|
|
235 @iftex
|
|
236 Published by the:@*
|
|
237
|
|
238 GNU Press, @hfill @uref{http://www.gnupress.org}@*
|
|
239 a division of the @hfill General: @email{press@@gnu.org}@*
|
|
240 Free Software Foundation, Inc. @hfill Orders:@w{ } @email{sales@@gnu.org}@*
|
|
241 51 Franklin Street, Fifth Floor @hfill Tel: +1 (617) 542-5942@*
|
|
242 Boston, MA 02110-1301 USA @hfill Fax: +1 (617) 542-2652@*
|
|
243 @end iftex
|
|
244
|
|
245 @ifnottex
|
|
246 Published by the:
|
|
247
|
|
248 @example
|
|
249 GNU Press, Website: http://www.gnupress.org
|
|
250 a division of the General: press@@gnu.org
|
|
251 Free Software Foundation, Inc. Orders: sales@@gnu.org
|
|
252 51 Franklin Street, Fifth Floor Tel: +1 (617) 542-5942
|
|
253 Boston, MA 02110-1301 USA Fax: +1 (617) 542-2652
|
|
254 @end example
|
|
255 @end ifnottex
|
|
256
|
|
257 @sp 1
|
|
258 @c Printed copies are available for $30 each.@*
|
|
259 ISBN 1-882114-43-4
|
|
260
|
|
261 Permission is granted to copy, distribute and/or modify this document
|
99703
|
262 under the terms of the GNU Free Documentation License, Version 1.3 or
|
83955
|
263 any later version published by the Free Software Foundation; there
|
|
264 being no Invariant Section, with the Front-Cover Texts being ``A GNU
|
|
265 Manual'', and with the Back-Cover Texts as in (a) below. A copy of
|
|
266 the license is included in the section entitled ``GNU Free
|
|
267 Documentation License''.
|
|
268
|
88088
|
269 (a) The FSF's Back-Cover Text is: ``You have the freedom to
|
|
270 copy and modify this GNU manual. Buying copies from the FSF
|
|
271 supports it in developing GNU and promoting software freedom.''
|
83955
|
272 @end copying
|
|
273
|
|
274 @c half title; two lines here, so do not use `shorttitlepage'
|
|
275 @tex
|
|
276 {\begingroup%
|
|
277 \hbox{}\vskip 1.5in \chaprm \centerline{An Introduction to}%
|
|
278 \endgroup}%
|
|
279 {\begingroup\hbox{}\vskip 0.25in \chaprm%
|
|
280 \centerline{Programming in Emacs Lisp}%
|
|
281 \endgroup\page\hbox{}\page}
|
|
282 @end tex
|
|
283
|
|
284 @titlepage
|
|
285 @sp 6
|
|
286 @center @titlefont{An Introduction to}
|
|
287 @sp 2
|
|
288 @center @titlefont{Programming in Emacs Lisp}
|
|
289 @sp 2
|
|
290 @center Revised Third Edition
|
|
291 @sp 4
|
|
292 @center by Robert J. Chassell
|
|
293
|
|
294 @page
|
|
295 @vskip 0pt plus 1filll
|
|
296 @insertcopying
|
|
297 @end titlepage
|
|
298
|
|
299 @iftex
|
|
300 @headings off
|
|
301 @evenheading @thispage @| @| @thischapter
|
|
302 @oddheading @thissection @| @| @thispage
|
|
303 @end iftex
|
|
304
|
|
305 @ifnothtml
|
|
306 @c Keep T.O.C. short by tightening up for largebook
|
|
307 @ifset largebook
|
|
308 @tex
|
|
309 \global\parskip 2pt plus 1pt
|
|
310 \global\advance\baselineskip by -1pt
|
|
311 @end tex
|
|
312 @end ifset
|
|
313 @end ifnothtml
|
|
314
|
|
315 @shortcontents
|
|
316 @contents
|
|
317
|
|
318 @ifnottex
|
|
319 @node Top, Preface, (dir), (dir)
|
|
320 @top An Introduction to Programming in Emacs Lisp
|
|
321
|
|
322 @insertcopying
|
|
323
|
|
324 This master menu first lists each chapter and index; then it lists
|
|
325 every node in every chapter.
|
|
326 @end ifnottex
|
|
327
|
|
328 @c >>>> Set pageno appropriately <<<<
|
|
329
|
|
330 @c The first page of the Preface is a roman numeral; it is the first
|
|
331 @c right handed page after the Table of Contents; hence the following
|
|
332 @c setting must be for an odd negative number.
|
|
333
|
98525
|
334 @c iftex
|
|
335 @c global@pageno = -11
|
|
336 @c end iftex
|
83955
|
337
|
|
338 @menu
|
|
339 * Preface:: What to look for.
|
|
340 * List Processing:: What is Lisp?
|
|
341 * Practicing Evaluation:: Running several programs.
|
|
342 * Writing Defuns:: How to write function definitions.
|
|
343 * Buffer Walk Through:: Exploring a few buffer-related functions.
|
|
344 * More Complex:: A few, even more complex functions.
|
|
345 * Narrowing & Widening:: Restricting your and Emacs attention to
|
|
346 a region.
|
|
347 * car cdr & cons:: Fundamental functions in Lisp.
|
|
348 * Cutting & Storing Text:: Removing text and saving it.
|
|
349 * List Implementation:: How lists are implemented in the computer.
|
|
350 * Yanking:: Pasting stored text.
|
|
351 * Loops & Recursion:: How to repeat a process.
|
|
352 * Regexp Search:: Regular expression searches.
|
|
353 * Counting Words:: A review of repetition and regexps.
|
|
354 * Words in a defun:: Counting words in a @code{defun}.
|
|
355 * Readying a Graph:: A prototype graph printing function.
|
|
356 * Emacs Initialization:: How to write a @file{.emacs} file.
|
|
357 * Debugging:: How to run the Emacs Lisp debuggers.
|
|
358 * Conclusion:: Now you have the basics.
|
|
359 * the-the:: An appendix: how to find reduplicated words.
|
|
360 * Kill Ring:: An appendix: how the kill ring works.
|
|
361 * Full Graph:: How to create a graph with labelled axes.
|
|
362 * Free Software and Free Manuals::
|
|
363 * GNU Free Documentation License::
|
|
364 * Index::
|
|
365 * About the Author::
|
|
366
|
|
367 @detailmenu
|
|
368 --- The Detailed Node Listing ---
|
|
369
|
|
370 Preface
|
|
371
|
|
372 * Why:: Why learn Emacs Lisp?
|
|
373 * On Reading this Text:: Read, gain familiarity, pick up habits....
|
|
374 * Who You Are:: For whom this is written.
|
|
375 * Lisp History::
|
|
376 * Note for Novices:: You can read this as a novice.
|
|
377 * Thank You::
|
|
378
|
|
379 List Processing
|
|
380
|
|
381 * Lisp Lists:: What are lists?
|
|
382 * Run a Program:: Any list in Lisp is a program ready to run.
|
|
383 * Making Errors:: Generating an error message.
|
|
384 * Names & Definitions:: Names of symbols and function definitions.
|
|
385 * Lisp Interpreter:: What the Lisp interpreter does.
|
|
386 * Evaluation:: Running a program.
|
|
387 * Variables:: Returning a value from a variable.
|
|
388 * Arguments:: Passing information to a function.
|
|
389 * set & setq:: Setting the value of a variable.
|
|
390 * Summary:: The major points.
|
|
391 * Error Message Exercises::
|
|
392
|
|
393 Lisp Lists
|
|
394
|
|
395 * Numbers Lists:: List have numbers, other lists, in them.
|
|
396 * Lisp Atoms:: Elemental entities.
|
|
397 * Whitespace in Lists:: Formatting lists to be readable.
|
|
398 * Typing Lists:: How GNU Emacs helps you type lists.
|
|
399
|
|
400 The Lisp Interpreter
|
|
401
|
|
402 * Complications:: Variables, Special forms, Lists within.
|
|
403 * Byte Compiling:: Specially processing code for speed.
|
|
404
|
|
405 Evaluation
|
|
406
|
|
407 * How the Interpreter Acts:: Returns and Side Effects...
|
|
408 * Evaluating Inner Lists:: Lists within lists...
|
|
409
|
|
410 Variables
|
|
411
|
|
412 * fill-column Example::
|
|
413 * Void Function:: The error message for a symbol
|
|
414 without a function.
|
|
415 * Void Variable:: The error message for a symbol without a value.
|
|
416
|
|
417 Arguments
|
|
418
|
|
419 * Data types:: Types of data passed to a function.
|
|
420 * Args as Variable or List:: An argument can be the value
|
|
421 of a variable or list.
|
|
422 * Variable Number of Arguments:: Some functions may take a
|
|
423 variable number of arguments.
|
|
424 * Wrong Type of Argument:: Passing an argument of the wrong type
|
|
425 to a function.
|
|
426 * message:: A useful function for sending messages.
|
|
427
|
|
428 Setting the Value of a Variable
|
|
429
|
|
430 * Using set:: Setting values.
|
|
431 * Using setq:: Setting a quoted value.
|
|
432 * Counting:: Using @code{setq} to count.
|
|
433
|
|
434 Practicing Evaluation
|
|
435
|
|
436 * How to Evaluate:: Typing editing commands or @kbd{C-x C-e}
|
|
437 causes evaluation.
|
|
438 * Buffer Names:: Buffers and files are different.
|
|
439 * Getting Buffers:: Getting a buffer itself, not merely its name.
|
|
440 * Switching Buffers:: How to change to another buffer.
|
|
441 * Buffer Size & Locations:: Where point is located and the size of
|
|
442 the buffer.
|
|
443 * Evaluation Exercise::
|
|
444
|
|
445 How To Write Function Definitions
|
|
446
|
|
447 * Primitive Functions::
|
|
448 * defun:: The @code{defun} special form.
|
|
449 * Install:: Install a function definition.
|
|
450 * Interactive:: Making a function interactive.
|
|
451 * Interactive Options:: Different options for @code{interactive}.
|
|
452 * Permanent Installation:: Installing code permanently.
|
|
453 * let:: Creating and initializing local variables.
|
|
454 * if:: What if?
|
|
455 * else:: If--then--else expressions.
|
|
456 * Truth & Falsehood:: What Lisp considers false and true.
|
|
457 * save-excursion:: Keeping track of point, mark, and buffer.
|
|
458 * Review::
|
|
459 * defun Exercises::
|
|
460
|
|
461 Install a Function Definition
|
|
462
|
|
463 * Effect of installation::
|
|
464 * Change a defun:: How to change a function definition.
|
|
465
|
|
466 Make a Function Interactive
|
|
467
|
|
468 * Interactive multiply-by-seven:: An overview.
|
|
469 * multiply-by-seven in detail:: The interactive version.
|
|
470
|
|
471 @code{let}
|
|
472
|
|
473 * Prevent confusion::
|
|
474 * Parts of let Expression::
|
|
475 * Sample let Expression::
|
|
476 * Uninitialized let Variables::
|
|
477
|
|
478 The @code{if} Special Form
|
|
479
|
|
480 * if in more detail::
|
|
481 * type-of-animal in detail:: An example of an @code{if} expression.
|
|
482
|
|
483 Truth and Falsehood in Emacs Lisp
|
|
484
|
|
485 * nil explained:: @code{nil} has two meanings.
|
|
486
|
|
487 @code{save-excursion}
|
|
488
|
|
489 * Point and mark:: A review of various locations.
|
|
490 * Template for save-excursion::
|
|
491
|
|
492 A Few Buffer--Related Functions
|
|
493
|
|
494 * Finding More:: How to find more information.
|
|
495 * simplified-beginning-of-buffer:: Shows @code{goto-char},
|
|
496 @code{point-min}, and @code{push-mark}.
|
|
497 * mark-whole-buffer:: Almost the same as @code{beginning-of-buffer}.
|
|
498 * append-to-buffer:: Uses @code{save-excursion} and
|
|
499 @code{insert-buffer-substring}.
|
|
500 * Buffer Related Review:: Review.
|
|
501 * Buffer Exercises::
|
|
502
|
|
503 The Definition of @code{mark-whole-buffer}
|
|
504
|
|
505 * mark-whole-buffer overview::
|
|
506 * Body of mark-whole-buffer:: Only three lines of code.
|
|
507
|
|
508 The Definition of @code{append-to-buffer}
|
|
509
|
|
510 * append-to-buffer overview::
|
|
511 * append interactive:: A two part interactive expression.
|
|
512 * append-to-buffer body:: Incorporates a @code{let} expression.
|
|
513 * append save-excursion:: How the @code{save-excursion} works.
|
|
514
|
|
515 A Few More Complex Functions
|
|
516
|
|
517 * copy-to-buffer:: With @code{set-buffer}, @code{get-buffer-create}.
|
|
518 * insert-buffer:: Read-only, and with @code{or}.
|
|
519 * beginning-of-buffer:: Shows @code{goto-char},
|
|
520 @code{point-min}, and @code{push-mark}.
|
|
521 * Second Buffer Related Review::
|
|
522 * optional Exercise::
|
|
523
|
|
524 The Definition of @code{insert-buffer}
|
|
525
|
|
526 * insert-buffer code::
|
|
527 * insert-buffer interactive:: When you can read, but not write.
|
|
528 * insert-buffer body:: The body has an @code{or} and a @code{let}.
|
|
529 * if & or:: Using an @code{if} instead of an @code{or}.
|
|
530 * Insert or:: How the @code{or} expression works.
|
|
531 * Insert let:: Two @code{save-excursion} expressions.
|
|
532 * New insert-buffer::
|
|
533
|
|
534 The Interactive Expression in @code{insert-buffer}
|
|
535
|
|
536 * Read-only buffer:: When a buffer cannot be modified.
|
|
537 * b for interactive:: An existing buffer or else its name.
|
|
538
|
|
539 Complete Definition of @code{beginning-of-buffer}
|
|
540
|
|
541 * Optional Arguments::
|
|
542 * beginning-of-buffer opt arg:: Example with optional argument.
|
|
543 * beginning-of-buffer complete::
|
|
544
|
|
545 @code{beginning-of-buffer} with an Argument
|
|
546
|
|
547 * Disentangle beginning-of-buffer::
|
|
548 * Large buffer case::
|
|
549 * Small buffer case::
|
|
550
|
|
551 Narrowing and Widening
|
|
552
|
|
553 * Narrowing advantages:: The advantages of narrowing
|
|
554 * save-restriction:: The @code{save-restriction} special form.
|
|
555 * what-line:: The number of the line that point is on.
|
|
556 * narrow Exercise::
|
|
557
|
|
558 @code{car}, @code{cdr}, @code{cons}: Fundamental Functions
|
|
559
|
|
560 * Strange Names:: An historical aside: why the strange names?
|
|
561 * car & cdr:: Functions for extracting part of a list.
|
|
562 * cons:: Constructing a list.
|
|
563 * nthcdr:: Calling @code{cdr} repeatedly.
|
|
564 * nth::
|
|
565 * setcar:: Changing the first element of a list.
|
|
566 * setcdr:: Changing the rest of a list.
|
|
567 * cons Exercise::
|
|
568
|
|
569 @code{cons}
|
|
570
|
|
571 * Build a list::
|
|
572 * length:: How to find the length of a list.
|
|
573
|
|
574 Cutting and Storing Text
|
|
575
|
|
576 * Storing Text:: Text is stored in a list.
|
|
577 * zap-to-char:: Cutting out text up to a character.
|
|
578 * kill-region:: Cutting text out of a region.
|
|
579 * copy-region-as-kill:: A definition for copying text.
|
|
580 * Digression into C:: Minor note on C programming language macros.
|
|
581 * defvar:: How to give a variable an initial value.
|
|
582 * cons & search-fwd Review::
|
|
583 * search Exercises::
|
|
584
|
|
585 @code{zap-to-char}
|
|
586
|
|
587 * Complete zap-to-char:: The complete implementation.
|
|
588 * zap-to-char interactive:: A three part interactive expression.
|
|
589 * zap-to-char body:: A short overview.
|
|
590 * search-forward:: How to search for a string.
|
|
591 * progn:: The @code{progn} special form.
|
|
592 * Summing up zap-to-char:: Using @code{point} and @code{search-forward}.
|
|
593
|
|
594 @code{kill-region}
|
|
595
|
|
596 * Complete kill-region:: The function definition.
|
|
597 * condition-case:: Dealing with a problem.
|
|
598 * Lisp macro::
|
|
599
|
|
600 @code{copy-region-as-kill}
|
|
601
|
|
602 * Complete copy-region-as-kill:: The complete function definition.
|
|
603 * copy-region-as-kill body:: The body of @code{copy-region-as-kill}.
|
|
604
|
|
605 The Body of @code{copy-region-as-kill}
|
|
606
|
|
607 * last-command & this-command::
|
|
608 * kill-append function::
|
|
609 * kill-new function::
|
|
610
|
|
611 Initializing a Variable with @code{defvar}
|
|
612
|
|
613 * See variable current value::
|
|
614 * defvar and asterisk::
|
|
615
|
|
616 How Lists are Implemented
|
|
617
|
|
618 * Lists diagrammed::
|
|
619 * Symbols as Chest:: Exploring a powerful metaphor.
|
|
620 * List Exercise::
|
|
621
|
|
622 Yanking Text Back
|
|
623
|
|
624 * Kill Ring Overview::
|
|
625 * kill-ring-yank-pointer:: The kill ring is a list.
|
|
626 * yank nthcdr Exercises:: The @code{kill-ring-yank-pointer} variable.
|
|
627
|
|
628 Loops and Recursion
|
|
629
|
|
630 * while:: Causing a stretch of code to repeat.
|
|
631 * dolist dotimes::
|
|
632 * Recursion:: Causing a function to call itself.
|
|
633 * Looping exercise::
|
|
634
|
|
635 @code{while}
|
|
636
|
|
637 * Looping with while:: Repeat so long as test returns true.
|
|
638 * Loop Example:: A @code{while} loop that uses a list.
|
|
639 * print-elements-of-list:: Uses @code{while}, @code{car}, @code{cdr}.
|
|
640 * Incrementing Loop:: A loop with an incrementing counter.
|
|
641 * Incrementing Loop Details::
|
|
642 * Decrementing Loop:: A loop with a decrementing counter.
|
|
643
|
|
644 Details of an Incrementing Loop
|
|
645
|
|
646 * Incrementing Example:: Counting pebbles in a triangle.
|
|
647 * Inc Example parts:: The parts of the function definition.
|
|
648 * Inc Example altogether:: Putting the function definition together.
|
|
649
|
|
650 Loop with a Decrementing Counter
|
|
651
|
|
652 * Decrementing Example:: More pebbles on the beach.
|
|
653 * Dec Example parts:: The parts of the function definition.
|
|
654 * Dec Example altogether:: Putting the function definition together.
|
|
655
|
|
656 Save your time: @code{dolist} and @code{dotimes}
|
|
657
|
|
658 * dolist::
|
|
659 * dotimes::
|
|
660
|
|
661 Recursion
|
|
662
|
|
663 * Building Robots:: Same model, different serial number ...
|
|
664 * Recursive Definition Parts:: Walk until you stop ...
|
|
665 * Recursion with list:: Using a list as the test whether to recurse.
|
|
666 * Recursive triangle function::
|
|
667 * Recursion with cond::
|
|
668 * Recursive Patterns:: Often used templates.
|
|
669 * No Deferment:: Don't store up work ...
|
|
670 * No deferment solution::
|
|
671
|
|
672 Recursion in Place of a Counter
|
|
673
|
|
674 * Recursive Example arg of 1 or 2::
|
|
675 * Recursive Example arg of 3 or 4::
|
|
676
|
|
677 Recursive Patterns
|
|
678
|
|
679 * Every::
|
|
680 * Accumulate::
|
|
681 * Keep::
|
|
682
|
|
683 Regular Expression Searches
|
|
684
|
|
685 * sentence-end:: The regular expression for @code{sentence-end}.
|
|
686 * re-search-forward:: Very similar to @code{search-forward}.
|
|
687 * forward-sentence:: A straightforward example of regexp search.
|
|
688 * forward-paragraph:: A somewhat complex example.
|
|
689 * etags:: How to create your own @file{TAGS} table.
|
|
690 * Regexp Review::
|
|
691 * re-search Exercises::
|
|
692
|
|
693 @code{forward-sentence}
|
|
694
|
|
695 * Complete forward-sentence::
|
|
696 * fwd-sentence while loops:: Two @code{while} loops.
|
|
697 * fwd-sentence re-search:: A regular expression search.
|
|
698
|
|
699 @code{forward-paragraph}: a Goldmine of Functions
|
|
700
|
|
701 * forward-paragraph in brief:: Key parts of the function definition.
|
|
702 * fwd-para let:: The @code{let*} expression.
|
|
703 * fwd-para while:: The forward motion @code{while} loop.
|
|
704
|
|
705 Counting: Repetition and Regexps
|
|
706
|
|
707 * Why Count Words::
|
|
708 * count-words-region:: Use a regexp, but find a problem.
|
|
709 * recursive-count-words:: Start with case of no words in region.
|
|
710 * Counting Exercise::
|
|
711
|
|
712 The @code{count-words-region} Function
|
|
713
|
|
714 * Design count-words-region:: The definition using a @code{while} loop.
|
|
715 * Whitespace Bug:: The Whitespace Bug in @code{count-words-region}.
|
|
716
|
|
717 Counting Words in a @code{defun}
|
|
718
|
|
719 * Divide and Conquer::
|
|
720 * Words and Symbols:: What to count?
|
|
721 * Syntax:: What constitutes a word or symbol?
|
|
722 * count-words-in-defun:: Very like @code{count-words}.
|
|
723 * Several defuns:: Counting several defuns in a file.
|
|
724 * Find a File:: Do you want to look at a file?
|
|
725 * lengths-list-file:: A list of the lengths of many definitions.
|
|
726 * Several files:: Counting in definitions in different files.
|
|
727 * Several files recursively:: Recursively counting in different files.
|
|
728 * Prepare the data:: Prepare the data for display in a graph.
|
|
729
|
|
730 Count Words in @code{defuns} in Different Files
|
|
731
|
|
732 * lengths-list-many-files:: Return a list of the lengths of defuns.
|
|
733 * append:: Attach one list to another.
|
|
734
|
|
735 Prepare the Data for Display in a Graph
|
|
736
|
|
737 * Data for Display in Detail::
|
|
738 * Sorting:: Sorting lists.
|
|
739 * Files List:: Making a list of files.
|
|
740 * Counting function definitions::
|
|
741
|
|
742 Readying a Graph
|
|
743
|
|
744 * Columns of a graph::
|
|
745 * graph-body-print:: How to print the body of a graph.
|
|
746 * recursive-graph-body-print::
|
|
747 * Printed Axes::
|
|
748 * Line Graph Exercise::
|
|
749
|
|
750 Your @file{.emacs} File
|
|
751
|
|
752 * Default Configuration::
|
|
753 * Site-wide Init:: You can write site-wide init files.
|
|
754 * defcustom:: Emacs will write code for you.
|
|
755 * Beginning a .emacs File:: How to write a @code{.emacs file}.
|
|
756 * Text and Auto-fill:: Automatically wrap lines.
|
|
757 * Mail Aliases:: Use abbreviations for email addresses.
|
|
758 * Indent Tabs Mode:: Don't use tabs with @TeX{}
|
|
759 * Keybindings:: Create some personal keybindings.
|
|
760 * Keymaps:: More about key binding.
|
|
761 * Loading Files:: Load (i.e., evaluate) files automatically.
|
|
762 * Autoload:: Make functions available.
|
|
763 * Simple Extension:: Define a function; bind it to a key.
|
|
764 * X11 Colors:: Colors in X.
|
|
765 * Miscellaneous::
|
|
766 * Mode Line:: How to customize your mode line.
|
|
767
|
|
768 Debugging
|
|
769
|
|
770 * debug:: How to use the built-in debugger.
|
|
771 * debug-on-entry:: Start debugging when you call a function.
|
|
772 * debug-on-quit:: Start debugging when you quit with @kbd{C-g}.
|
|
773 * edebug:: How to use Edebug, a source level debugger.
|
|
774 * Debugging Exercises::
|
|
775
|
|
776 Handling the Kill Ring
|
|
777
|
|
778 * What the Kill Ring Does::
|
|
779 * current-kill::
|
|
780 * yank:: Paste a copy of a clipped element.
|
|
781 * yank-pop:: Insert element pointed to.
|
|
782 * ring file::
|
|
783
|
|
784 The @code{current-kill} Function
|
|
785
|
103818
|
786 * Code for current-kill::
|
83955
|
787 * Understanding current-kill::
|
|
788
|
|
789 @code{current-kill} in Outline
|
|
790
|
|
791 * Body of current-kill::
|
|
792 * Digression concerning error:: How to mislead humans, but not computers.
|
|
793 * Determining the Element::
|
|
794
|
|
795 A Graph with Labelled Axes
|
|
796
|
|
797 * Labelled Example::
|
|
798 * print-graph Varlist:: @code{let} expression in @code{print-graph}.
|
|
799 * print-Y-axis:: Print a label for the vertical axis.
|
|
800 * print-X-axis:: Print a horizontal label.
|
|
801 * Print Whole Graph:: The function to print a complete graph.
|
|
802
|
|
803 The @code{print-Y-axis} Function
|
|
804
|
|
805 * print-Y-axis in Detail::
|
|
806 * Height of label:: What height for the Y axis?
|
|
807 * Compute a Remainder:: How to compute the remainder of a division.
|
|
808 * Y Axis Element:: Construct a line for the Y axis.
|
|
809 * Y-axis-column:: Generate a list of Y axis labels.
|
|
810 * print-Y-axis Penultimate:: A not quite final version.
|
|
811
|
|
812 The @code{print-X-axis} Function
|
|
813
|
|
814 * Similarities differences:: Much like @code{print-Y-axis}, but not exactly.
|
|
815 * X Axis Tic Marks:: Create tic marks for the horizontal axis.
|
|
816
|
|
817 Printing the Whole Graph
|
|
818
|
|
819 * The final version:: A few changes.
|
|
820 * Test print-graph:: Run a short test.
|
|
821 * Graphing words in defuns:: Executing the final code.
|
|
822 * lambda:: How to write an anonymous function.
|
|
823 * mapcar:: Apply a function to elements of a list.
|
|
824 * Another Bug:: Yet another bug @dots{} most insidious.
|
|
825 * Final printed graph:: The graph itself!
|
|
826
|
|
827 @end detailmenu
|
|
828 @end menu
|
|
829
|
|
830 @node Preface, List Processing, Top, Top
|
|
831 @comment node-name, next, previous, up
|
|
832 @unnumbered Preface
|
|
833
|
|
834 Most of the GNU Emacs integrated environment is written in the programming
|
|
835 language called Emacs Lisp. The code written in this programming
|
|
836 language is the software---the sets of instructions---that tell the
|
|
837 computer what to do when you give it commands. Emacs is designed so
|
|
838 that you can write new code in Emacs Lisp and easily install it as an
|
|
839 extension to the editor.
|
|
840
|
|
841 (GNU Emacs is sometimes called an ``extensible editor'', but it does
|
|
842 much more than provide editing capabilities. It is better to refer to
|
|
843 Emacs as an ``extensible computing environment''. However, that
|
|
844 phrase is quite a mouthful. It is easier to refer to Emacs simply as
|
|
845 an editor. Moreover, everything you do in Emacs---find the Mayan date
|
|
846 and phases of the moon, simplify polynomials, debug code, manage
|
|
847 files, read letters, write books---all these activities are kinds of
|
|
848 editing in the most general sense of the word.)
|
|
849
|
|
850 @menu
|
|
851 * Why:: Why learn Emacs Lisp?
|
|
852 * On Reading this Text:: Read, gain familiarity, pick up habits....
|
|
853 * Who You Are:: For whom this is written.
|
|
854 * Lisp History::
|
|
855 * Note for Novices:: You can read this as a novice.
|
|
856 * Thank You::
|
|
857 @end menu
|
|
858
|
|
859 @node Why, On Reading this Text, Preface, Preface
|
|
860 @ifnottex
|
|
861 @unnumberedsec Why Study Emacs Lisp?
|
|
862 @end ifnottex
|
|
863
|
|
864 Although Emacs Lisp is usually thought of in association only with Emacs,
|
|
865 it is a full computer programming language. You can use Emacs Lisp as
|
|
866 you would any other programming language.
|
|
867
|
|
868 Perhaps you want to understand programming; perhaps you want to extend
|
|
869 Emacs; or perhaps you want to become a programmer. This introduction to
|
|
870 Emacs Lisp is designed to get you started: to guide you in learning the
|
|
871 fundamentals of programming, and more importantly, to show you how you
|
|
872 can teach yourself to go further.
|
|
873
|
|
874 @node On Reading this Text, Who You Are, Why, Preface
|
|
875 @comment node-name, next, previous, up
|
|
876 @unnumberedsec On Reading this Text
|
|
877
|
|
878 All through this document, you will see little sample programs you can
|
|
879 run inside of Emacs. If you read this document in Info inside of GNU
|
|
880 Emacs, you can run the programs as they appear. (This is easy to do and
|
|
881 is explained when the examples are presented.) Alternatively, you can
|
|
882 read this introduction as a printed book while sitting beside a computer
|
|
883 running Emacs. (This is what I like to do; I like printed books.) If
|
|
884 you don't have a running Emacs beside you, you can still read this book,
|
|
885 but in this case, it is best to treat it as a novel or as a travel guide
|
|
886 to a country not yet visited: interesting, but not the same as being
|
|
887 there.
|
|
888
|
|
889 Much of this introduction is dedicated to walk-throughs or guided tours
|
|
890 of code used in GNU Emacs. These tours are designed for two purposes:
|
|
891 first, to give you familiarity with real, working code (code you use
|
|
892 every day); and, second, to give you familiarity with the way Emacs
|
|
893 works. It is interesting to see how a working environment is
|
|
894 implemented.
|
|
895 Also, I
|
|
896 hope that you will pick up the habit of browsing through source code.
|
|
897 You can learn from it and mine it for ideas. Having GNU Emacs is like
|
|
898 having a dragon's cave of treasures.
|
|
899
|
|
900 In addition to learning about Emacs as an editor and Emacs Lisp as a
|
|
901 programming language, the examples and guided tours will give you an
|
|
902 opportunity to get acquainted with Emacs as a Lisp programming
|
|
903 environment. GNU Emacs supports programming and provides tools that
|
|
904 you will want to become comfortable using, such as @kbd{M-.} (the key
|
|
905 which invokes the @code{find-tag} command). You will also learn about
|
|
906 buffers and other objects that are part of the environment.
|
|
907 Learning about these features of Emacs is like learning new routes
|
|
908 around your home town.
|
|
909
|
|
910 @ignore
|
|
911 In addition, I have written several programs as extended examples.
|
|
912 Although these are examples, the programs are real. I use them.
|
|
913 Other people use them. You may use them. Beyond the fragments of
|
|
914 programs used for illustrations, there is very little in here that is
|
|
915 `just for teaching purposes'; what you see is used. This is a great
|
|
916 advantage of Emacs Lisp: it is easy to learn to use it for work.
|
|
917 @end ignore
|
|
918
|
|
919 Finally, I hope to convey some of the skills for using Emacs to
|
|
920 learn aspects of programming that you don't know. You can often use
|
|
921 Emacs to help you understand what puzzles you or to find out how to do
|
|
922 something new. This self-reliance is not only a pleasure, but an
|
|
923 advantage.
|
|
924
|
|
925 @node Who You Are, Lisp History, On Reading this Text, Preface
|
|
926 @comment node-name, next, previous, up
|
|
927 @unnumberedsec For Whom This is Written
|
|
928
|
|
929 This text is written as an elementary introduction for people who are
|
|
930 not programmers. If you are a programmer, you may not be satisfied with
|
|
931 this primer. The reason is that you may have become expert at reading
|
|
932 reference manuals and be put off by the way this text is organized.
|
|
933
|
|
934 An expert programmer who reviewed this text said to me:
|
|
935
|
|
936 @quotation
|
|
937 @i{I prefer to learn from reference manuals. I ``dive into'' each
|
|
938 paragraph, and ``come up for air'' between paragraphs.}
|
|
939
|
|
940 @i{When I get to the end of a paragraph, I assume that that subject is
|
|
941 done, finished, that I know everything I need (with the
|
|
942 possible exception of the case when the next paragraph starts talking
|
|
943 about it in more detail). I expect that a well written reference manual
|
|
944 will not have a lot of redundancy, and that it will have excellent
|
|
945 pointers to the (one) place where the information I want is.}
|
|
946 @end quotation
|
|
947
|
|
948 This introduction is not written for this person!
|
|
949
|
|
950 Firstly, I try to say everything at least three times: first, to
|
|
951 introduce it; second, to show it in context; and third, to show it in a
|
|
952 different context, or to review it.
|
|
953
|
|
954 Secondly, I hardly ever put all the information about a subject in one
|
|
955 place, much less in one paragraph. To my way of thinking, that imposes
|
|
956 too heavy a burden on the reader. Instead I try to explain only what
|
|
957 you need to know at the time. (Sometimes I include a little extra
|
|
958 information so you won't be surprised later when the additional
|
|
959 information is formally introduced.)
|
|
960
|
|
961 When you read this text, you are not expected to learn everything the
|
|
962 first time. Frequently, you need only make, as it were, a `nodding
|
|
963 acquaintance' with some of the items mentioned. My hope is that I have
|
|
964 structured the text and given you enough hints that you will be alert to
|
|
965 what is important, and concentrate on it.
|
|
966
|
|
967 You will need to ``dive into'' some paragraphs; there is no other way
|
|
968 to read them. But I have tried to keep down the number of such
|
|
969 paragraphs. This book is intended as an approachable hill, rather than
|
|
970 as a daunting mountain.
|
|
971
|
|
972 This introduction to @cite{Programming in Emacs Lisp} has a companion
|
|
973 document,
|
|
974 @iftex
|
|
975 @cite{The GNU Emacs Lisp Reference Manual}.
|
|
976 @end iftex
|
|
977 @ifnottex
|
|
978 @ref{Top, , The GNU Emacs Lisp Reference Manual, elisp, The GNU
|
|
979 Emacs Lisp Reference Manual}.
|
|
980 @end ifnottex
|
|
981 The reference manual has more detail than this introduction. In the
|
|
982 reference manual, all the information about one topic is concentrated
|
|
983 in one place. You should turn to it if you are like the programmer
|
|
984 quoted above. And, of course, after you have read this
|
|
985 @cite{Introduction}, you will find the @cite{Reference Manual} useful
|
|
986 when you are writing your own programs.
|
|
987
|
|
988 @node Lisp History, Note for Novices, Who You Are, Preface
|
|
989 @unnumberedsec Lisp History
|
|
990 @cindex Lisp history
|
|
991
|
|
992 Lisp was first developed in the late 1950s at the Massachusetts
|
|
993 Institute of Technology for research in artificial intelligence. The
|
|
994 great power of the Lisp language makes it superior for other purposes as
|
|
995 well, such as writing editor commands and integrated environments.
|
|
996
|
|
997 @cindex Maclisp
|
|
998 @cindex Common Lisp
|
|
999 GNU Emacs Lisp is largely inspired by Maclisp, which was written at MIT
|
|
1000 in the 1960s. It is somewhat inspired by Common Lisp, which became a
|
|
1001 standard in the 1980s. However, Emacs Lisp is much simpler than Common
|
|
1002 Lisp. (The standard Emacs distribution contains an optional extensions
|
|
1003 file, @file{cl.el}, that adds many Common Lisp features to Emacs Lisp.)
|
|
1004
|
|
1005 @node Note for Novices, Thank You, Lisp History, Preface
|
|
1006 @comment node-name, next, previous, up
|
|
1007 @unnumberedsec A Note for Novices
|
|
1008
|
|
1009 If you don't know GNU Emacs, you can still read this document
|
|
1010 profitably. However, I recommend you learn Emacs, if only to learn to
|
|
1011 move around your computer screen. You can teach yourself how to use
|
|
1012 Emacs with the on-line tutorial. To use it, type @kbd{C-h t}. (This
|
|
1013 means you press and release the @key{CTRL} key and the @kbd{h} at the
|
|
1014 same time, and then press and release @kbd{t}.)
|
|
1015
|
|
1016 Also, I often refer to one of Emacs' standard commands by listing the
|
|
1017 keys which you press to invoke the command and then giving the name of
|
|
1018 the command in parentheses, like this: @kbd{M-C-\}
|
|
1019 (@code{indent-region}). What this means is that the
|
|
1020 @code{indent-region} command is customarily invoked by typing
|
|
1021 @kbd{M-C-\}. (You can, if you wish, change the keys that are typed to
|
|
1022 invoke the command; this is called @dfn{rebinding}. @xref{Keymaps, ,
|
|
1023 Keymaps}.) The abbreviation @kbd{M-C-\} means that you type your
|
|
1024 @key{META} key, @key{CTRL} key and @key{\} key all at the same time.
|
|
1025 (On many modern keyboards the @key{META} key is labelled
|
|
1026 @key{ALT}.)
|
|
1027 Sometimes a combination like this is called a keychord, since it is
|
|
1028 similar to the way you play a chord on a piano. If your keyboard does
|
|
1029 not have a @key{META} key, the @key{ESC} key prefix is used in place
|
|
1030 of it. In this case, @kbd{M-C-\} means that you press and release your
|
|
1031 @key{ESC} key and then type the @key{CTRL} key and the @key{\} key at
|
|
1032 the same time. But usually @kbd{M-C-\} means press the @key{CTRL} key
|
|
1033 along with the key that is labelled @key{ALT} and, at the same time,
|
|
1034 press the @key{\} key.
|
|
1035
|
|
1036 In addition to typing a lone keychord, you can prefix what you type
|
|
1037 with @kbd{C-u}, which is called the `universal argument'. The
|
|
1038 @kbd{C-u} keychord passes an argument to the subsequent command.
|
|
1039 Thus, to indent a region of plain text by 6 spaces, mark the region,
|
|
1040 and then type @w{@kbd{C-u 6 M-C-\}}. (If you do not specify a number,
|
|
1041 Emacs either passes the number 4 to the command or otherwise runs the
|
|
1042 command differently than it would otherwise.) @xref{Arguments, ,
|
|
1043 Numeric Arguments, emacs, The GNU Emacs Manual}.
|
|
1044
|
|
1045 If you are reading this in Info using GNU Emacs, you can read through
|
|
1046 this whole document just by pressing the space bar, @key{SPC}.
|
|
1047 (To learn about Info, type @kbd{C-h i} and then select Info.)
|
|
1048
|
|
1049 A note on terminology: when I use the word Lisp alone, I often am
|
|
1050 referring to the various dialects of Lisp in general, but when I speak
|
|
1051 of Emacs Lisp, I am referring to GNU Emacs Lisp in particular.
|
|
1052
|
|
1053 @node Thank You, , Note for Novices, Preface
|
|
1054 @comment node-name, next, previous, up
|
|
1055 @unnumberedsec Thank You
|
|
1056
|
|
1057 My thanks to all who helped me with this book. My especial thanks to
|
|
1058 @r{Jim Blandy}, @r{Noah Friedman}, @w{Jim Kingdon}, @r{Roland
|
|
1059 McGrath}, @w{Frank Ritter}, @w{Randy Smith}, @w{Richard M.@:
|
|
1060 Stallman}, and @w{Melissa Weisshaus}. My thanks also go to both
|
|
1061 @w{Philip Johnson} and @w{David Stampe} for their patient
|
|
1062 encouragement. My mistakes are my own.
|
|
1063
|
|
1064 @flushright
|
|
1065 Robert J. Chassell
|
84515
|
1066 @email{bob@@gnu.org}
|
83955
|
1067 @end flushright
|
|
1068
|
|
1069 @c ================ Beginning of main text ================
|
|
1070
|
|
1071 @c Start main text on right-hand (verso) page
|
|
1072
|
|
1073 @tex
|
|
1074 \par\vfill\supereject
|
|
1075 \headings off
|
|
1076 \ifodd\pageno
|
|
1077 \par\vfill\supereject
|
|
1078 \else
|
|
1079 \par\vfill\supereject
|
|
1080 \page\hbox{}\page
|
|
1081 \par\vfill\supereject
|
|
1082 \fi
|
|
1083 @end tex
|
|
1084
|
|
1085 @iftex
|
|
1086 @headings off
|
|
1087 @evenheading @thispage @| @| @thischapter
|
|
1088 @oddheading @thissection @| @| @thispage
|
|
1089 @global@pageno = 1
|
|
1090 @end iftex
|
|
1091
|
|
1092 @node List Processing, Practicing Evaluation, Preface, Top
|
|
1093 @comment node-name, next, previous, up
|
|
1094 @chapter List Processing
|
|
1095
|
|
1096 To the untutored eye, Lisp is a strange programming language. In Lisp
|
|
1097 code there are parentheses everywhere. Some people even claim that
|
|
1098 the name stands for `Lots of Isolated Silly Parentheses'. But the
|
|
1099 claim is unwarranted. Lisp stands for LISt Processing, and the
|
|
1100 programming language handles @emph{lists} (and lists of lists) by
|
|
1101 putting them between parentheses. The parentheses mark the boundaries
|
|
1102 of the list. Sometimes a list is preceded by a single apostrophe or
|
|
1103 quotation mark, @samp{'}@footnote{The single apostrophe or quotation
|
|
1104 mark is an abbreviation for the function @code{quote}; you need not
|
|
1105 think about functions now; functions are defined in @ref{Making
|
|
1106 Errors, , Generate an Error Message}.} Lists are the basis of Lisp.
|
|
1107
|
|
1108 @menu
|
|
1109 * Lisp Lists:: What are lists?
|
|
1110 * Run a Program:: Any list in Lisp is a program ready to run.
|
|
1111 * Making Errors:: Generating an error message.
|
|
1112 * Names & Definitions:: Names of symbols and function definitions.
|
|
1113 * Lisp Interpreter:: What the Lisp interpreter does.
|
|
1114 * Evaluation:: Running a program.
|
|
1115 * Variables:: Returning a value from a variable.
|
|
1116 * Arguments:: Passing information to a function.
|
|
1117 * set & setq:: Setting the value of a variable.
|
|
1118 * Summary:: The major points.
|
|
1119 * Error Message Exercises::
|
|
1120 @end menu
|
|
1121
|
|
1122 @node Lisp Lists, Run a Program, List Processing, List Processing
|
|
1123 @comment node-name, next, previous, up
|
|
1124 @section Lisp Lists
|
|
1125 @cindex Lisp Lists
|
|
1126
|
|
1127 In Lisp, a list looks like this: @code{'(rose violet daisy buttercup)}.
|
|
1128 This list is preceded by a single apostrophe. It could just as well be
|
|
1129 written as follows, which looks more like the kind of list you are likely
|
|
1130 to be familiar with:
|
|
1131
|
|
1132 @smallexample
|
|
1133 @group
|
|
1134 '(rose
|
|
1135 violet
|
|
1136 daisy
|
|
1137 buttercup)
|
|
1138 @end group
|
|
1139 @end smallexample
|
|
1140
|
|
1141 @noindent
|
|
1142 The elements of this list are the names of the four different flowers,
|
|
1143 separated from each other by whitespace and surrounded by parentheses,
|
|
1144 like flowers in a field with a stone wall around them.
|
|
1145 @cindex Flowers in a field
|
|
1146
|
|
1147 @menu
|
|
1148 * Numbers Lists:: List have numbers, other lists, in them.
|
|
1149 * Lisp Atoms:: Elemental entities.
|
|
1150 * Whitespace in Lists:: Formatting lists to be readable.
|
|
1151 * Typing Lists:: How GNU Emacs helps you type lists.
|
|
1152 @end menu
|
|
1153
|
|
1154 @node Numbers Lists, Lisp Atoms, Lisp Lists, Lisp Lists
|
|
1155 @ifnottex
|
|
1156 @unnumberedsubsec Numbers, Lists inside of Lists
|
|
1157 @end ifnottex
|
|
1158
|
|
1159 Lists can also have numbers in them, as in this list: @code{(+ 2 2)}.
|
|
1160 This list has a plus-sign, @samp{+}, followed by two @samp{2}s, each
|
|
1161 separated by whitespace.
|
|
1162
|
|
1163 In Lisp, both data and programs are represented the same way; that is,
|
|
1164 they are both lists of words, numbers, or other lists, separated by
|
|
1165 whitespace and surrounded by parentheses. (Since a program looks like
|
|
1166 data, one program may easily serve as data for another; this is a very
|
|
1167 powerful feature of Lisp.) (Incidentally, these two parenthetical
|
|
1168 remarks are @emph{not} Lisp lists, because they contain @samp{;} and
|
|
1169 @samp{.} as punctuation marks.)
|
|
1170
|
|
1171 @need 1200
|
|
1172 Here is another list, this time with a list inside of it:
|
|
1173
|
|
1174 @smallexample
|
|
1175 '(this list has (a list inside of it))
|
|
1176 @end smallexample
|
|
1177
|
|
1178 The components of this list are the words @samp{this}, @samp{list},
|
|
1179 @samp{has}, and the list @samp{(a list inside of it)}. The interior
|
|
1180 list is made up of the words @samp{a}, @samp{list}, @samp{inside},
|
|
1181 @samp{of}, @samp{it}.
|
|
1182
|
|
1183 @node Lisp Atoms, Whitespace in Lists, Numbers Lists, Lisp Lists
|
|
1184 @comment node-name, next, previous, up
|
|
1185 @subsection Lisp Atoms
|
|
1186 @cindex Lisp Atoms
|
|
1187
|
|
1188 In Lisp, what we have been calling words are called @dfn{atoms}. This
|
|
1189 term comes from the historical meaning of the word atom, which means
|
|
1190 `indivisible'. As far as Lisp is concerned, the words we have been
|
|
1191 using in the lists cannot be divided into any smaller parts and still
|
|
1192 mean the same thing as part of a program; likewise with numbers and
|
|
1193 single character symbols like @samp{+}. On the other hand, unlike an
|
|
1194 ancient atom, a list can be split into parts. (@xref{car cdr & cons,
|
|
1195 , @code{car} @code{cdr} & @code{cons} Fundamental Functions}.)
|
|
1196
|
|
1197 In a list, atoms are separated from each other by whitespace. They can be
|
|
1198 right next to a parenthesis.
|
|
1199
|
|
1200 @cindex @samp{empty list} defined
|
|
1201 Technically speaking, a list in Lisp consists of parentheses surrounding
|
|
1202 atoms separated by whitespace or surrounding other lists or surrounding
|
|
1203 both atoms and other lists. A list can have just one atom in it or
|
|
1204 have nothing in it at all. A list with nothing in it looks like this:
|
|
1205 @code{()}, and is called the @dfn{empty list}. Unlike anything else, an
|
|
1206 empty list is considered both an atom and a list at the same time.
|
|
1207
|
|
1208 @cindex Symbolic expressions, introduced
|
|
1209 @cindex @samp{expression} defined
|
|
1210 @cindex @samp{form} defined
|
|
1211 The printed representation of both atoms and lists are called
|
|
1212 @dfn{symbolic expressions} or, more concisely, @dfn{s-expressions}.
|
|
1213 The word @dfn{expression} by itself can refer to either the printed
|
|
1214 representation, or to the atom or list as it is held internally in the
|
|
1215 computer. Often, people use the term @dfn{expression}
|
|
1216 indiscriminately. (Also, in many texts, the word @dfn{form} is used
|
|
1217 as a synonym for expression.)
|
|
1218
|
|
1219 Incidentally, the atoms that make up our universe were named such when
|
|
1220 they were thought to be indivisible; but it has been found that physical
|
|
1221 atoms are not indivisible. Parts can split off an atom or it can
|
|
1222 fission into two parts of roughly equal size. Physical atoms were named
|
|
1223 prematurely, before their truer nature was found. In Lisp, certain
|
|
1224 kinds of atom, such as an array, can be separated into parts; but the
|
|
1225 mechanism for doing this is different from the mechanism for splitting a
|
|
1226 list. As far as list operations are concerned, the atoms of a list are
|
|
1227 unsplittable.
|
|
1228
|
|
1229 As in English, the meanings of the component letters of a Lisp atom
|
|
1230 are different from the meaning the letters make as a word. For
|
|
1231 example, the word for the South American sloth, the @samp{ai}, is
|
|
1232 completely different from the two words, @samp{a}, and @samp{i}.
|
|
1233
|
|
1234 There are many kinds of atom in nature but only a few in Lisp: for
|
|
1235 example, @dfn{numbers}, such as 37, 511, or 1729, and @dfn{symbols}, such
|
|
1236 as @samp{+}, @samp{foo}, or @samp{forward-line}. The words we have
|
|
1237 listed in the examples above are all symbols. In everyday Lisp
|
|
1238 conversation, the word ``atom'' is not often used, because programmers
|
|
1239 usually try to be more specific about what kind of atom they are dealing
|
|
1240 with. Lisp programming is mostly about symbols (and sometimes numbers)
|
|
1241 within lists. (Incidentally, the preceding three word parenthetical
|
|
1242 remark is a proper list in Lisp, since it consists of atoms, which in
|
|
1243 this case are symbols, separated by whitespace and enclosed by
|
|
1244 parentheses, without any non-Lisp punctuation.)
|
|
1245
|
|
1246 @need 1250
|
94896
3c3a05682534
(Lisp Atoms): Rephrase "in addition" to avoid confusion with addition
Chong Yidong <cyd@stupidchicken.com>
diff
changeset
|
1247 Text between double quotation marks---even sentences or
|
3c3a05682534
(Lisp Atoms): Rephrase "in addition" to avoid confusion with addition
Chong Yidong <cyd@stupidchicken.com>
diff
changeset
|
1248 paragraphs---is also an atom. Here is an example:
|
83955
|
1249 @cindex Text between double quotation marks
|
|
1250
|
|
1251 @smallexample
|
|
1252 '(this list includes "text between quotation marks.")
|
|
1253 @end smallexample
|
|
1254
|
|
1255 @cindex @samp{string} defined
|
|
1256 @noindent
|
|
1257 In Lisp, all of the quoted text including the punctuation mark and the
|
|
1258 blank spaces is a single atom. This kind of atom is called a
|
|
1259 @dfn{string} (for `string of characters') and is the sort of thing that
|
|
1260 is used for messages that a computer can print for a human to read.
|
|
1261 Strings are a different kind of atom than numbers or symbols and are
|
|
1262 used differently.
|
|
1263
|
|
1264 @node Whitespace in Lists, Typing Lists, Lisp Atoms, Lisp Lists
|
|
1265 @comment node-name, next, previous, up
|
|
1266 @subsection Whitespace in Lists
|
|
1267 @cindex Whitespace in lists
|
|
1268
|
|
1269 @need 1200
|
|
1270 The amount of whitespace in a list does not matter. From the point of view
|
|
1271 of the Lisp language,
|
|
1272
|
|
1273 @smallexample
|
|
1274 @group
|
|
1275 '(this list
|
|
1276 looks like this)
|
|
1277 @end group
|
|
1278 @end smallexample
|
|
1279
|
|
1280 @need 800
|
|
1281 @noindent
|
|
1282 is exactly the same as this:
|
|
1283
|
|
1284 @smallexample
|
|
1285 '(this list looks like this)
|
|
1286 @end smallexample
|
|
1287
|
|
1288 Both examples show what to Lisp is the same list, the list made up of
|
|
1289 the symbols @samp{this}, @samp{list}, @samp{looks}, @samp{like}, and
|
|
1290 @samp{this} in that order.
|
|
1291
|
|
1292 Extra whitespace and newlines are designed to make a list more readable
|
|
1293 by humans. When Lisp reads the expression, it gets rid of all the extra
|
|
1294 whitespace (but it needs to have at least one space between atoms in
|
|
1295 order to tell them apart.)
|
|
1296
|
|
1297 Odd as it seems, the examples we have seen cover almost all of what Lisp
|
|
1298 lists look like! Every other list in Lisp looks more or less like one
|
|
1299 of these examples, except that the list may be longer and more complex.
|
|
1300 In brief, a list is between parentheses, a string is between quotation
|
|
1301 marks, a symbol looks like a word, and a number looks like a number.
|
|
1302 (For certain situations, square brackets, dots and a few other special
|
|
1303 characters may be used; however, we will go quite far without them.)
|
|
1304
|
|
1305 @node Typing Lists, , Whitespace in Lists, Lisp Lists
|
|
1306 @comment node-name, next, previous, up
|
|
1307 @subsection GNU Emacs Helps You Type Lists
|
|
1308 @cindex Help typing lists
|
|
1309 @cindex Formatting help
|
|
1310
|
|
1311 When you type a Lisp expression in GNU Emacs using either Lisp
|
|
1312 Interaction mode or Emacs Lisp mode, you have available to you several
|
|
1313 commands to format the Lisp expression so it is easy to read. For
|
|
1314 example, pressing the @key{TAB} key automatically indents the line the
|
|
1315 cursor is on by the right amount. A command to properly indent the
|
|
1316 code in a region is customarily bound to @kbd{M-C-\}. Indentation is
|
|
1317 designed so that you can see which elements of a list belong to which
|
|
1318 list---elements of a sub-list are indented more than the elements of
|
|
1319 the enclosing list.
|
|
1320
|
|
1321 In addition, when you type a closing parenthesis, Emacs momentarily
|
|
1322 jumps the cursor back to the matching opening parenthesis, so you can
|
|
1323 see which one it is. This is very useful, since every list you type
|
|
1324 in Lisp must have its closing parenthesis match its opening
|
|
1325 parenthesis. (@xref{Major Modes, , Major Modes, emacs, The GNU Emacs
|
|
1326 Manual}, for more information about Emacs' modes.)
|
|
1327
|
|
1328 @node Run a Program, Making Errors, Lisp Lists, List Processing
|
|
1329 @comment node-name, next, previous, up
|
|
1330 @section Run a Program
|
|
1331 @cindex Run a program
|
|
1332 @cindex Program, running one
|
|
1333
|
|
1334 @cindex @samp{evaluate} defined
|
|
1335 A list in Lisp---any list---is a program ready to run. If you run it
|
|
1336 (for which the Lisp jargon is @dfn{evaluate}), the computer will do one
|
|
1337 of three things: do nothing except return to you the list itself; send
|
|
1338 you an error message; or, treat the first symbol in the list as a
|
|
1339 command to do something. (Usually, of course, it is the last of these
|
|
1340 three things that you really want!)
|
|
1341
|
|
1342 @c use code for the single apostrophe, not samp.
|
|
1343 The single apostrophe, @code{'}, that I put in front of some of the
|
|
1344 example lists in preceding sections is called a @dfn{quote}; when it
|
|
1345 precedes a list, it tells Lisp to do nothing with the list, other than
|
|
1346 take it as it is written. But if there is no quote preceding a list,
|
|
1347 the first item of the list is special: it is a command for the computer
|
|
1348 to obey. (In Lisp, these commands are called @emph{functions}.) The list
|
|
1349 @code{(+ 2 2)} shown above did not have a quote in front of it, so Lisp
|
|
1350 understands that the @code{+} is an instruction to do something with the
|
|
1351 rest of the list: add the numbers that follow.
|
|
1352
|
|
1353 @need 1250
|
|
1354 If you are reading this inside of GNU Emacs in Info, here is how you can
|
|
1355 evaluate such a list: place your cursor immediately after the right
|
|
1356 hand parenthesis of the following list and then type @kbd{C-x C-e}:
|
|
1357
|
|
1358 @smallexample
|
|
1359 (+ 2 2)
|
|
1360 @end smallexample
|
|
1361
|
|
1362 @c use code for the number four, not samp.
|
|
1363 @noindent
|
|
1364 You will see the number @code{4} appear in the echo area. (In the
|
|
1365 jargon, what you have just done is ``evaluate the list.'' The echo area
|
|
1366 is the line at the bottom of the screen that displays or ``echoes''
|
|
1367 text.) Now try the same thing with a quoted list: place the cursor
|
|
1368 right after the following list and type @kbd{C-x C-e}:
|
|
1369
|
|
1370 @smallexample
|
|
1371 '(this is a quoted list)
|
|
1372 @end smallexample
|
|
1373
|
|
1374 @noindent
|
|
1375 You will see @code{(this is a quoted list)} appear in the echo area.
|
|
1376
|
|
1377 @cindex Lisp interpreter, explained
|
|
1378 @cindex Interpreter, Lisp, explained
|
|
1379 In both cases, what you are doing is giving a command to the program
|
|
1380 inside of GNU Emacs called the @dfn{Lisp interpreter}---giving the
|
|
1381 interpreter a command to evaluate the expression. The name of the Lisp
|
|
1382 interpreter comes from the word for the task done by a human who comes
|
|
1383 up with the meaning of an expression---who ``interprets'' it.
|
|
1384
|
|
1385 You can also evaluate an atom that is not part of a list---one that is
|
|
1386 not surrounded by parentheses; again, the Lisp interpreter translates
|
|
1387 from the humanly readable expression to the language of the computer.
|
|
1388 But before discussing this (@pxref{Variables}), we will discuss what the
|
|
1389 Lisp interpreter does when you make an error.
|
|
1390
|
|
1391 @node Making Errors, Names & Definitions, Run a Program, List Processing
|
|
1392 @comment node-name, next, previous, up
|
|
1393 @section Generate an Error Message
|
|
1394 @cindex Generate an error message
|
|
1395 @cindex Error message generation
|
|
1396
|
|
1397 Partly so you won't worry if you do it accidentally, we will now give
|
|
1398 a command to the Lisp interpreter that generates an error message.
|
|
1399 This is a harmless activity; and indeed, we will often try to generate
|
|
1400 error messages intentionally. Once you understand the jargon, error
|
|
1401 messages can be informative. Instead of being called ``error''
|
|
1402 messages, they should be called ``help'' messages. They are like
|
|
1403 signposts to a traveller in a strange country; deciphering them can be
|
|
1404 hard, but once understood, they can point the way.
|
|
1405
|
|
1406 The error message is generated by a built-in GNU Emacs debugger. We
|
|
1407 will `enter the debugger'. You get out of the debugger by typing @code{q}.
|
|
1408
|
|
1409 What we will do is evaluate a list that is not quoted and does not
|
|
1410 have a meaningful command as its first element. Here is a list almost
|
|
1411 exactly the same as the one we just used, but without the single-quote
|
|
1412 in front of it. Position the cursor right after it and type @kbd{C-x
|
|
1413 C-e}:
|
|
1414
|
|
1415 @smallexample
|
|
1416 (this is an unquoted list)
|
|
1417 @end smallexample
|
|
1418
|
|
1419 @noindent
|
|
1420 What you see depends on which version of Emacs you are running. GNU
|
|
1421 Emacs version 22 provides more information than version 20 and before.
|
|
1422 First, the more recent result of generating an error; then the
|
|
1423 earlier, version 20 result.
|
|
1424
|
|
1425 @need 1250
|
|
1426 @noindent
|
|
1427 In GNU Emacs version 22, a @file{*Backtrace*} window will open up and
|
|
1428 you will see the following in it:
|
|
1429
|
|
1430 @smallexample
|
|
1431 @group
|
|
1432 ---------- Buffer: *Backtrace* ----------
|
|
1433 Debugger entered--Lisp error: (void-function this)
|
|
1434 (this is an unquoted list)
|
|
1435 eval((this is an unquoted list))
|
|
1436 eval-last-sexp-1(nil)
|
|
1437 eval-last-sexp(nil)
|
|
1438 call-interactively(eval-last-sexp)
|
|
1439 ---------- Buffer: *Backtrace* ----------
|
|
1440 @end group
|
|
1441 @end smallexample
|
|
1442
|
|
1443 @need 1200
|
|
1444 @noindent
|
|
1445 Your cursor will be in this window (you may have to wait a few seconds
|
|
1446 before it becomes visible). To quit the debugger and make the
|
|
1447 debugger window go away, type:
|
|
1448
|
|
1449 @smallexample
|
|
1450 q
|
|
1451 @end smallexample
|
|
1452
|
|
1453 @noindent
|
|
1454 Please type @kbd{q} right now, so you become confident that you can
|
|
1455 get out of the debugger. Then, type @kbd{C-x C-e} again to re-enter
|
|
1456 it.
|
|
1457
|
|
1458 @cindex @samp{function} defined
|
|
1459 Based on what we already know, we can almost read this error message.
|
|
1460
|
|
1461 You read the @file{*Backtrace*} buffer from the bottom up; it tells
|
|
1462 you what Emacs did. When you typed @kbd{C-x C-e}, you made an
|
|
1463 interactive call to the command @code{eval-last-sexp}. @code{eval} is
|
|
1464 an abbreviation for `evaluate' and @code{sexp} is an abbreviation for
|
|
1465 `symbolic expression'. The command means `evaluate last symbolic
|
|
1466 expression', which is the expression just before your cursor.
|
|
1467
|
|
1468 Each line above tells you what the Lisp interpreter evaluated next.
|
|
1469 The most recent action is at the top. The buffer is called the
|
|
1470 @file{*Backtrace*} buffer because it enables you to track Emacs
|
|
1471 backwards.
|
|
1472
|
|
1473 @need 800
|
|
1474 At the top of the @file{*Backtrace*} buffer, you see the line:
|
|
1475
|
|
1476 @smallexample
|
|
1477 Debugger entered--Lisp error: (void-function this)
|
|
1478 @end smallexample
|
|
1479
|
|
1480 @noindent
|
|
1481 The Lisp interpreter tried to evaluate the first atom of the list, the
|
|
1482 word @samp{this}. It is this action that generated the error message
|
|
1483 @samp{void-function this}.
|
|
1484
|
|
1485 The message contains the words @samp{void-function} and @samp{this}.
|
|
1486
|
|
1487 @cindex @samp{function} defined
|
|
1488 The word @samp{function} was mentioned once before. It is a very
|
|
1489 important word. For our purposes, we can define it by saying that a
|
|
1490 @dfn{function} is a set of instructions to the computer that tell the
|
|
1491 computer to do something.
|
|
1492
|
|
1493 Now we can begin to understand the error message: @samp{void-function
|
|
1494 this}. The function (that is, the word @samp{this}) does not have a
|
|
1495 definition of any set of instructions for the computer to carry out.
|
|
1496
|
|
1497 The slightly odd word, @samp{void-function}, is designed to cover the
|
|
1498 way Emacs Lisp is implemented, which is that when a symbol does not
|
|
1499 have a function definition attached to it, the place that should
|
|
1500 contain the instructions is `void'.
|
|
1501
|
|
1502 On the other hand, since we were able to add 2 plus 2 successfully, by
|
|
1503 evaluating @code{(+ 2 2)}, we can infer that the symbol @code{+} must
|
|
1504 have a set of instructions for the computer to obey and those
|
|
1505 instructions must be to add the numbers that follow the @code{+}.
|
|
1506
|
|
1507 @need 1250
|
|
1508 In GNU Emacs version 20, and in earlier versions, you will see only
|
|
1509 one line of error message; it will appear in the echo area and look
|
|
1510 like this:
|
|
1511
|
|
1512 @smallexample
|
|
1513 Symbol's function definition is void:@: this
|
|
1514 @end smallexample
|
|
1515
|
|
1516 @noindent
|
|
1517 (Also, your terminal may beep at you---some do, some don't; and others
|
|
1518 blink. This is just a device to get your attention.) The message goes
|
|
1519 away as soon as you type another key, even just to move the cursor.
|
|
1520
|
|
1521 We know the meaning of the word @samp{Symbol}. It refers to the first
|
|
1522 atom of the list, the word @samp{this}. The word @samp{function}
|
|
1523 refers to the instructions that tell the computer what to do.
|
|
1524 (Technically, the symbol tells the computer where to find the
|
|
1525 instructions, but this is a complication we can ignore for the
|
|
1526 moment.)
|
|
1527
|
|
1528 The error message can be understood: @samp{Symbol's function
|
|
1529 definition is void:@: this}. The symbol (that is, the word
|
|
1530 @samp{this}) lacks instructions for the computer to carry out.
|
|
1531
|
|
1532 @node Names & Definitions, Lisp Interpreter, Making Errors, List Processing
|
|
1533 @comment node-name, next, previous, up
|
|
1534 @section Symbol Names and Function Definitions
|
|
1535 @cindex Symbol names
|
|
1536
|
|
1537 We can articulate another characteristic of Lisp based on what we have
|
|
1538 discussed so far---an important characteristic: a symbol, like
|
|
1539 @code{+}, is not itself the set of instructions for the computer to
|
|
1540 carry out. Instead, the symbol is used, perhaps temporarily, as a way
|
|
1541 of locating the definition or set of instructions. What we see is the
|
|
1542 name through which the instructions can be found. Names of people
|
|
1543 work the same way. I can be referred to as @samp{Bob}; however, I am
|
|
1544 not the letters @samp{B}, @samp{o}, @samp{b} but am, or was, the
|
|
1545 consciousness consistently associated with a particular life-form.
|
|
1546 The name is not me, but it can be used to refer to me.
|
|
1547
|
|
1548 In Lisp, one set of instructions can be attached to several names.
|
|
1549 For example, the computer instructions for adding numbers can be
|
|
1550 linked to the symbol @code{plus} as well as to the symbol @code{+}
|
|
1551 (and are in some dialects of Lisp). Among humans, I can be referred
|
|
1552 to as @samp{Robert} as well as @samp{Bob} and by other words as well.
|
|
1553
|
|
1554 On the other hand, a symbol can have only one function definition
|
|
1555 attached to it at a time. Otherwise, the computer would be confused as
|
|
1556 to which definition to use. If this were the case among people, only
|
|
1557 one person in the world could be named @samp{Bob}. However, the function
|
|
1558 definition to which the name refers can be changed readily.
|
|
1559 (@xref{Install, , Install a Function Definition}.)
|
|
1560
|
|
1561 Since Emacs Lisp is large, it is customary to name symbols in a way
|
|
1562 that identifies the part of Emacs to which the function belongs.
|
|
1563 Thus, all the names for functions that deal with Texinfo start with
|
|
1564 @samp{texinfo-} and those for functions that deal with reading mail
|
|
1565 start with @samp{rmail-}.
|
|
1566
|
|
1567 @node Lisp Interpreter, Evaluation, Names & Definitions, List Processing
|
|
1568 @comment node-name, next, previous, up
|
|
1569 @section The Lisp Interpreter
|
|
1570 @cindex Lisp interpreter, what it does
|
|
1571 @cindex Interpreter, what it does
|
|
1572
|
|
1573 Based on what we have seen, we can now start to figure out what the
|
|
1574 Lisp interpreter does when we command it to evaluate a list.
|
|
1575 First, it looks to see whether there is a quote before the list; if
|
|
1576 there is, the interpreter just gives us the list. On the other
|
|
1577 hand, if there is no quote, the interpreter looks at the first element
|
|
1578 in the list and sees whether it has a function definition. If it does,
|
|
1579 the interpreter carries out the instructions in the function definition.
|
|
1580 Otherwise, the interpreter prints an error message.
|
|
1581
|
|
1582 This is how Lisp works. Simple. There are added complications which we
|
|
1583 will get to in a minute, but these are the fundamentals. Of course, to
|
|
1584 write Lisp programs, you need to know how to write function definitions
|
|
1585 and attach them to names, and how to do this without confusing either
|
|
1586 yourself or the computer.
|
|
1587
|
|
1588 @menu
|
|
1589 * Complications:: Variables, Special forms, Lists within.
|
|
1590 * Byte Compiling:: Specially processing code for speed.
|
|
1591 @end menu
|
|
1592
|
|
1593 @node Complications, Byte Compiling, Lisp Interpreter, Lisp Interpreter
|
|
1594 @ifnottex
|
|
1595 @unnumberedsubsec Complications
|
|
1596 @end ifnottex
|
|
1597
|
|
1598 Now, for the first complication. In addition to lists, the Lisp
|
|
1599 interpreter can evaluate a symbol that is not quoted and does not have
|
|
1600 parentheses around it. The Lisp interpreter will attempt to determine
|
|
1601 the symbol's value as a @dfn{variable}. This situation is described
|
|
1602 in the section on variables. (@xref{Variables}.)
|
|
1603
|
|
1604 @cindex Special form
|
|
1605 The second complication occurs because some functions are unusual and do
|
|
1606 not work in the usual manner. Those that don't are called @dfn{special
|
|
1607 forms}. They are used for special jobs, like defining a function, and
|
|
1608 there are not many of them. In the next few chapters, you will be
|
|
1609 introduced to several of the more important special forms.
|
|
1610
|
|
1611 The third and final complication is this: if the function that the
|
|
1612 Lisp interpreter is looking at is not a special form, and if it is part
|
|
1613 of a list, the Lisp interpreter looks to see whether the list has a list
|
|
1614 inside of it. If there is an inner list, the Lisp interpreter first
|
|
1615 figures out what it should do with the inside list, and then it works on
|
|
1616 the outside list. If there is yet another list embedded inside the
|
|
1617 inner list, it works on that one first, and so on. It always works on
|
|
1618 the innermost list first. The interpreter works on the innermost list
|
|
1619 first, to evaluate the result of that list. The result may be
|
|
1620 used by the enclosing expression.
|
|
1621
|
|
1622 Otherwise, the interpreter works left to right, from one expression to
|
|
1623 the next.
|
|
1624
|
|
1625 @node Byte Compiling, , Complications, Lisp Interpreter
|
|
1626 @subsection Byte Compiling
|
|
1627 @cindex Byte compiling
|
|
1628
|
|
1629 One other aspect of interpreting: the Lisp interpreter is able to
|
|
1630 interpret two kinds of entity: humanly readable code, on which we will
|
|
1631 focus exclusively, and specially processed code, called @dfn{byte
|
|
1632 compiled} code, which is not humanly readable. Byte compiled code
|
|
1633 runs faster than humanly readable code.
|
|
1634
|
|
1635 You can transform humanly readable code into byte compiled code by
|
|
1636 running one of the compile commands such as @code{byte-compile-file}.
|
|
1637 Byte compiled code is usually stored in a file that ends with a
|
|
1638 @file{.elc} extension rather than a @file{.el} extension. You will
|
|
1639 see both kinds of file in the @file{emacs/lisp} directory; the files
|
|
1640 to read are those with @file{.el} extensions.
|
|
1641
|
|
1642 As a practical matter, for most things you might do to customize or
|
|
1643 extend Emacs, you do not need to byte compile; and I will not discuss
|
|
1644 the topic here. @xref{Byte Compilation, , Byte Compilation, elisp,
|
|
1645 The GNU Emacs Lisp Reference Manual}, for a full description of byte
|
|
1646 compilation.
|
|
1647
|
|
1648 @node Evaluation, Variables, Lisp Interpreter, List Processing
|
|
1649 @comment node-name, next, previous, up
|
|
1650 @section Evaluation
|
|
1651 @cindex Evaluation
|
|
1652
|
|
1653 When the Lisp interpreter works on an expression, the term for the
|
|
1654 activity is called @dfn{evaluation}. We say that the interpreter
|
|
1655 `evaluates the expression'. I've used this term several times before.
|
|
1656 The word comes from its use in everyday language, `to ascertain the
|
|
1657 value or amount of; to appraise', according to @cite{Webster's New
|
|
1658 Collegiate Dictionary}.
|
|
1659
|
|
1660 @menu
|
|
1661 * How the Interpreter Acts:: Returns and Side Effects...
|
|
1662 * Evaluating Inner Lists:: Lists within lists...
|
|
1663 @end menu
|
|
1664
|
|
1665 @node How the Interpreter Acts, Evaluating Inner Lists, Evaluation, Evaluation
|
|
1666 @ifnottex
|
|
1667 @unnumberedsubsec How the Lisp Interpreter Acts
|
|
1668 @end ifnottex
|
|
1669
|
|
1670 @cindex @samp{returned value} explained
|
|
1671 After evaluating an expression, the Lisp interpreter will most likely
|
|
1672 @dfn{return} the value that the computer produces by carrying out the
|
|
1673 instructions it found in the function definition, or perhaps it will
|
|
1674 give up on that function and produce an error message. (The interpreter
|
|
1675 may also find itself tossed, so to speak, to a different function or it
|
|
1676 may attempt to repeat continually what it is doing for ever and ever in
|
|
1677 what is called an `infinite loop'. These actions are less common; and
|
|
1678 we can ignore them.) Most frequently, the interpreter returns a value.
|
|
1679
|
|
1680 @cindex @samp{side effect} defined
|
|
1681 At the same time the interpreter returns a value, it may do something
|
|
1682 else as well, such as move a cursor or copy a file; this other kind of
|
|
1683 action is called a @dfn{side effect}. Actions that we humans think are
|
|
1684 important, such as printing results, are often ``side effects'' to the
|
|
1685 Lisp interpreter. The jargon can sound peculiar, but it turns out that
|
|
1686 it is fairly easy to learn to use side effects.
|
|
1687
|
|
1688 In summary, evaluating a symbolic expression most commonly causes the
|
|
1689 Lisp interpreter to return a value and perhaps carry out a side effect;
|
|
1690 or else produce an error.
|
|
1691
|
|
1692 @node Evaluating Inner Lists, , How the Interpreter Acts, Evaluation
|
|
1693 @comment node-name, next, previous, up
|
|
1694 @subsection Evaluating Inner Lists
|
|
1695 @cindex Inner list evaluation
|
|
1696 @cindex Evaluating inner lists
|
|
1697
|
|
1698 If evaluation applies to a list that is inside another list, the outer
|
|
1699 list may use the value returned by the first evaluation as information
|
|
1700 when the outer list is evaluated. This explains why inner expressions
|
|
1701 are evaluated first: the values they return are used by the outer
|
|
1702 expressions.
|
|
1703
|
|
1704 @need 1250
|
|
1705 We can investigate this process by evaluating another addition example.
|
|
1706 Place your cursor after the following expression and type @kbd{C-x C-e}:
|
|
1707
|
|
1708 @smallexample
|
|
1709 (+ 2 (+ 3 3))
|
|
1710 @end smallexample
|
|
1711
|
|
1712 @noindent
|
|
1713 The number 8 will appear in the echo area.
|
|
1714
|
|
1715 What happens is that the Lisp interpreter first evaluates the inner
|
|
1716 expression, @code{(+ 3 3)}, for which the value 6 is returned; then it
|
|
1717 evaluates the outer expression as if it were written @code{(+ 2 6)}, which
|
|
1718 returns the value 8. Since there are no more enclosing expressions to
|
|
1719 evaluate, the interpreter prints that value in the echo area.
|
|
1720
|
|
1721 Now it is easy to understand the name of the command invoked by the
|
|
1722 keystrokes @kbd{C-x C-e}: the name is @code{eval-last-sexp}. The
|
|
1723 letters @code{sexp} are an abbreviation for `symbolic expression', and
|
|
1724 @code{eval} is an abbreviation for `evaluate'. The command means
|
|
1725 `evaluate last symbolic expression'.
|
|
1726
|
|
1727 As an experiment, you can try evaluating the expression by putting the
|
|
1728 cursor at the beginning of the next line immediately following the
|
|
1729 expression, or inside the expression.
|
|
1730
|
|
1731 @need 800
|
|
1732 Here is another copy of the expression:
|
|
1733
|
|
1734 @smallexample
|
|
1735 (+ 2 (+ 3 3))
|
|
1736 @end smallexample
|
|
1737
|
|
1738 @noindent
|
|
1739 If you place the cursor at the beginning of the blank line that
|
|
1740 immediately follows the expression and type @kbd{C-x C-e}, you will
|
|
1741 still get the value 8 printed in the echo area. Now try putting the
|
|
1742 cursor inside the expression. If you put it right after the next to
|
|
1743 last parenthesis (so it appears to sit on top of the last parenthesis),
|
|
1744 you will get a 6 printed in the echo area! This is because the command
|
|
1745 evaluates the expression @code{(+ 3 3)}.
|
|
1746
|
|
1747 Now put the cursor immediately after a number. Type @kbd{C-x C-e} and
|
|
1748 you will get the number itself. In Lisp, if you evaluate a number, you
|
|
1749 get the number itself---this is how numbers differ from symbols. If you
|
|
1750 evaluate a list starting with a symbol like @code{+}, you will get a
|
|
1751 value returned that is the result of the computer carrying out the
|
|
1752 instructions in the function definition attached to that name. If a
|
|
1753 symbol by itself is evaluated, something different happens, as we will
|
|
1754 see in the next section.
|
|
1755
|
|
1756 @node Variables, Arguments, Evaluation, List Processing
|
|
1757 @comment node-name, next, previous, up
|
|
1758 @section Variables
|
|
1759 @cindex Variables
|
|
1760
|
|
1761 In Emacs Lisp, a symbol can have a value attached to it just as it can
|
|
1762 have a function definition attached to it. The two are different.
|
|
1763 The function definition is a set of instructions that a computer will
|
|
1764 obey. A value, on the other hand, is something, such as number or a
|
|
1765 name, that can vary (which is why such a symbol is called a variable).
|
|
1766 The value of a symbol can be any expression in Lisp, such as a symbol,
|
|
1767 number, list, or string. A symbol that has a value is often called a
|
|
1768 @dfn{variable}.
|
|
1769
|
|
1770 A symbol can have both a function definition and a value attached to
|
|
1771 it at the same time. Or it can have just one or the other.
|
|
1772 The two are separate. This is somewhat similar
|
|
1773 to the way the name Cambridge can refer to the city in Massachusetts
|
|
1774 and have some information attached to the name as well, such as
|
|
1775 ``great programming center''.
|
|
1776
|
|
1777 @ignore
|
|
1778 (Incidentally, in Emacs Lisp, a symbol can have two
|
|
1779 other things attached to it, too: a property list and a documentation
|
|
1780 string; these are discussed later.)
|
|
1781 @end ignore
|
|
1782
|
|
1783 Another way to think about this is to imagine a symbol as being a chest
|
|
1784 of drawers. The function definition is put in one drawer, the value in
|
|
1785 another, and so on. What is put in the drawer holding the value can be
|
|
1786 changed without affecting the contents of the drawer holding the
|
|
1787 function definition, and vice-verse.
|
|
1788
|
|
1789 @menu
|
|
1790 * fill-column Example::
|
|
1791 * Void Function:: The error message for a symbol
|
|
1792 without a function.
|
|
1793 * Void Variable:: The error message for a symbol without a value.
|
|
1794 @end menu
|
|
1795
|
|
1796 @node fill-column Example, Void Function, Variables, Variables
|
|
1797 @ifnottex
|
|
1798 @unnumberedsubsec @code{fill-column}, an Example Variable
|
|
1799 @end ifnottex
|
|
1800
|
|
1801 @findex fill-column, @r{an example variable}
|
|
1802 @cindex Example variable, @code{fill-column}
|
|
1803 @cindex Variable, example of, @code{fill-column}
|
|
1804 The variable @code{fill-column} illustrates a symbol with a value
|
|
1805 attached to it: in every GNU Emacs buffer, this symbol is set to some
|
|
1806 value, usually 72 or 70, but sometimes to some other value. To find the
|
|
1807 value of this symbol, evaluate it by itself. If you are reading this in
|
|
1808 Info inside of GNU Emacs, you can do this by putting the cursor after
|
|
1809 the symbol and typing @kbd{C-x C-e}:
|
|
1810
|
|
1811 @smallexample
|
|
1812 fill-column
|
|
1813 @end smallexample
|
|
1814
|
|
1815 @noindent
|
|
1816 After I typed @kbd{C-x C-e}, Emacs printed the number 72 in my echo
|
|
1817 area. This is the value for which @code{fill-column} is set for me as I
|
|
1818 write this. It may be different for you in your Info buffer. Notice
|
|
1819 that the value returned as a variable is printed in exactly the same way
|
|
1820 as the value returned by a function carrying out its instructions. From
|
|
1821 the point of view of the Lisp interpreter, a value returned is a value
|
|
1822 returned. What kind of expression it came from ceases to matter once
|
|
1823 the value is known.
|
|
1824
|
|
1825 A symbol can have any value attached to it or, to use the jargon, we can
|
|
1826 @dfn{bind} the variable to a value: to a number, such as 72; to a
|
|
1827 string, @code{"such as this"}; to a list, such as @code{(spruce pine
|
|
1828 oak)}; we can even bind a variable to a function definition.
|
|
1829
|
|
1830 A symbol can be bound to a value in several ways. @xref{set & setq, ,
|
|
1831 Setting the Value of a Variable}, for information about one way to do
|
|
1832 this.
|
|
1833
|
|
1834 @node Void Function, Void Variable, fill-column Example, Variables
|
|
1835 @comment node-name, next, previous, up
|
|
1836 @subsection Error Message for a Symbol Without a Function
|
|
1837 @cindex Symbol without function error
|
|
1838 @cindex Error for symbol without function
|
|
1839
|
|
1840 When we evaluated @code{fill-column} to find its value as a variable,
|
|
1841 we did not place parentheses around the word. This is because we did
|
|
1842 not intend to use it as a function name.
|
|
1843
|
|
1844 If @code{fill-column} were the first or only element of a list, the
|
|
1845 Lisp interpreter would attempt to find the function definition
|
|
1846 attached to it. But @code{fill-column} has no function definition.
|
|
1847 Try evaluating this:
|
|
1848
|
|
1849 @smallexample
|
|
1850 (fill-column)
|
|
1851 @end smallexample
|
|
1852
|
|
1853 @need 1250
|
|
1854 @noindent
|
|
1855 In GNU Emacs version 22, you will create a @file{*Backtrace*} buffer
|
|
1856 that says:
|
|
1857
|
|
1858 @smallexample
|
|
1859 @group
|
|
1860 ---------- Buffer: *Backtrace* ----------
|
|
1861 Debugger entered--Lisp error: (void-function fill-column)
|
|
1862 (fill-column)
|
|
1863 eval((fill-column))
|
|
1864 eval-last-sexp-1(nil)
|
|
1865 eval-last-sexp(nil)
|
|
1866 call-interactively(eval-last-sexp)
|
|
1867 ---------- Buffer: *Backtrace* ----------
|
|
1868 @end group
|
|
1869 @end smallexample
|
|
1870
|
|
1871 @noindent
|
|
1872 (Remember, to quit the debugger and make the debugger window go away,
|
|
1873 type @kbd{q} in the @file{*Backtrace*} buffer.)
|
|
1874
|
|
1875 @ignore
|
|
1876 @need 800
|
|
1877 In GNU Emacs 20 and before, you will produce an error message that says:
|
|
1878
|
|
1879 @smallexample
|
|
1880 Symbol's function definition is void:@: fill-column
|
|
1881 @end smallexample
|
|
1882
|
|
1883 @noindent
|
|
1884 (The message will go away as soon as you move the cursor or type
|
|
1885 another key.)
|
|
1886 @end ignore
|
|
1887
|
|
1888 @node Void Variable, , Void Function, Variables
|
|
1889 @comment node-name, next, previous, up
|
|
1890 @subsection Error Message for a Symbol Without a Value
|
|
1891 @cindex Symbol without value error
|
|
1892 @cindex Error for symbol without value
|
|
1893
|
|
1894 If you attempt to evaluate a symbol that does not have a value bound to
|
|
1895 it, you will receive an error message. You can see this by
|
|
1896 experimenting with our 2 plus 2 addition. In the following expression,
|
|
1897 put your cursor right after the @code{+}, before the first number 2,
|
|
1898 type @kbd{C-x C-e}:
|
|
1899
|
|
1900 @smallexample
|
|
1901 (+ 2 2)
|
|
1902 @end smallexample
|
|
1903
|
|
1904 @need 1500
|
|
1905 @noindent
|
|
1906 In GNU Emacs 22, you will create a @file{*Backtrace*} buffer that
|
|
1907 says:
|
|
1908
|
|
1909 @smallexample
|
|
1910 @group
|
|
1911 ---------- Buffer: *Backtrace* ----------
|
|
1912 Debugger entered--Lisp error: (void-variable +)
|
|
1913 eval(+)
|
|
1914 eval-last-sexp-1(nil)
|
|
1915 eval-last-sexp(nil)
|
|
1916 call-interactively(eval-last-sexp)
|
|
1917 ---------- Buffer: *Backtrace* ----------
|
|
1918 @end group
|
|
1919 @end smallexample
|
|
1920
|
|
1921 @noindent
|
|
1922 (As with the other times we entered the debugger, you can quit by
|
|
1923 typing @kbd{q} in the @file{*Backtrace*} buffer.)
|
|
1924
|
|
1925 This backtrace is different from the very first error message we saw,
|
|
1926 which said, @samp{Debugger entered--Lisp error: (void-function this)}.
|
|
1927 In this case, the function does not have a value as a variable; while
|
|
1928 in the other error message, the function (the word `this') did not
|
|
1929 have a definition.
|
|
1930
|
|
1931 In this experiment with the @code{+}, what we did was cause the Lisp
|
|
1932 interpreter to evaluate the @code{+} and look for the value of the
|
|
1933 variable instead of the function definition. We did this by placing the
|
|
1934 cursor right after the symbol rather than after the parenthesis of the
|
|
1935 enclosing list as we did before. As a consequence, the Lisp interpreter
|
|
1936 evaluated the preceding s-expression, which in this case was the
|
|
1937 @code{+} by itself.
|
|
1938
|
|
1939 Since @code{+} does not have a value bound to it, just the function
|
|
1940 definition, the error message reported that the symbol's value as a
|
|
1941 variable was void.
|
|
1942
|
|
1943 @ignore
|
|
1944 @need 800
|
|
1945 In GNU Emacs version 20 and before, your error message will say:
|
|
1946
|
|
1947 @example
|
|
1948 Symbol's value as variable is void:@: +
|
|
1949 @end example
|
|
1950
|
|
1951 @noindent
|
|
1952 The meaning is the same as in GNU Emacs 22.
|
|
1953 @end ignore
|
|
1954
|
|
1955 @node Arguments, set & setq, Variables, List Processing
|
|
1956 @comment node-name, next, previous, up
|
|
1957 @section Arguments
|
|
1958 @cindex Arguments
|
|
1959 @cindex Passing information to functions
|
|
1960
|
|
1961 To see how information is passed to functions, let's look again at
|
|
1962 our old standby, the addition of two plus two. In Lisp, this is written
|
|
1963 as follows:
|
|
1964
|
|
1965 @smallexample
|
|
1966 (+ 2 2)
|
|
1967 @end smallexample
|
|
1968
|
|
1969 If you evaluate this expression, the number 4 will appear in your echo
|
|
1970 area. What the Lisp interpreter does is add the numbers that follow
|
|
1971 the @code{+}.
|
|
1972
|
|
1973 @cindex @samp{argument} defined
|
|
1974 The numbers added by @code{+} are called the @dfn{arguments} of the
|
|
1975 function @code{+}. These numbers are the information that is given to
|
|
1976 or @dfn{passed} to the function.
|
|
1977
|
|
1978 The word `argument' comes from the way it is used in mathematics and
|
|
1979 does not refer to a disputation between two people; instead it refers to
|
|
1980 the information presented to the function, in this case, to the
|
|
1981 @code{+}. In Lisp, the arguments to a function are the atoms or lists
|
|
1982 that follow the function. The values returned by the evaluation of
|
|
1983 these atoms or lists are passed to the function. Different functions
|
|
1984 require different numbers of arguments; some functions require none at
|
|
1985 all.@footnote{It is curious to track the path by which the word `argument'
|
|
1986 came to have two different meanings, one in mathematics and the other in
|
|
1987 everyday English. According to the @cite{Oxford English Dictionary},
|
|
1988 the word derives from the Latin for @samp{to make clear, prove}; thus it
|
|
1989 came to mean, by one thread of derivation, `the evidence offered as
|
|
1990 proof', which is to say, `the information offered', which led to its
|
|
1991 meaning in Lisp. But in the other thread of derivation, it came to mean
|
|
1992 `to assert in a manner against which others may make counter
|
|
1993 assertions', which led to the meaning of the word as a disputation.
|
|
1994 (Note here that the English word has two different definitions attached
|
|
1995 to it at the same time. By contrast, in Emacs Lisp, a symbol cannot
|
|
1996 have two different function definitions at the same time.)}
|
|
1997
|
|
1998 @menu
|
|
1999 * Data types:: Types of data passed to a function.
|
|
2000 * Args as Variable or List:: An argument can be the value
|
|
2001 of a variable or list.
|
|
2002 * Variable Number of Arguments:: Some functions may take a
|
|
2003 variable number of arguments.
|
|
2004 * Wrong Type of Argument:: Passing an argument of the wrong type
|
|
2005 to a function.
|
|
2006 * message:: A useful function for sending messages.
|
|
2007 @end menu
|
|
2008
|
|
2009 @node Data types, Args as Variable or List, Arguments, Arguments
|
|
2010 @comment node-name, next, previous, up
|
|
2011 @subsection Arguments' Data Types
|
|
2012 @cindex Data types
|
|
2013 @cindex Types of data
|
|
2014 @cindex Arguments' data types
|
|
2015
|
|
2016 The type of data that should be passed to a function depends on what
|
|
2017 kind of information it uses. The arguments to a function such as
|
|
2018 @code{+} must have values that are numbers, since @code{+} adds numbers.
|
|
2019 Other functions use different kinds of data for their arguments.
|
|
2020
|
|
2021 @need 1250
|
|
2022 @findex concat
|
|
2023 For example, the @code{concat} function links together or unites two or
|
|
2024 more strings of text to produce a string. The arguments are strings.
|
|
2025 Concatenating the two character strings @code{abc}, @code{def} produces
|
|
2026 the single string @code{abcdef}. This can be seen by evaluating the
|
|
2027 following:
|
|
2028
|
|
2029 @smallexample
|
|
2030 (concat "abc" "def")
|
|
2031 @end smallexample
|
|
2032
|
|
2033 @noindent
|
|
2034 The value produced by evaluating this expression is @code{"abcdef"}.
|
|
2035
|
|
2036 A function such as @code{substring} uses both a string and numbers as
|
|
2037 arguments. The function returns a part of the string, a substring of
|
|
2038 the first argument. This function takes three arguments. Its first
|
|
2039 argument is the string of characters, the second and third arguments are
|
|
2040 numbers that indicate the beginning and end of the substring. The
|
|
2041 numbers are a count of the number of characters (including spaces and
|
|
2042 punctuations) from the beginning of the string.
|
|
2043
|
|
2044 @need 800
|
|
2045 For example, if you evaluate the following:
|
|
2046
|
|
2047 @smallexample
|
|
2048 (substring "The quick brown fox jumped." 16 19)
|
|
2049 @end smallexample
|
|
2050
|
|
2051 @noindent
|
|
2052 you will see @code{"fox"} appear in the echo area. The arguments are the
|
|
2053 string and the two numbers.
|
|
2054
|
|
2055 Note that the string passed to @code{substring} is a single atom even
|
|
2056 though it is made up of several words separated by spaces. Lisp counts
|
|
2057 everything between the two quotation marks as part of the string,
|
|
2058 including the spaces. You can think of the @code{substring} function as
|
|
2059 a kind of `atom smasher' since it takes an otherwise indivisible atom
|
|
2060 and extracts a part. However, @code{substring} is only able to extract
|
|
2061 a substring from an argument that is a string, not from another type of
|
|
2062 atom such as a number or symbol.
|
|
2063
|
|
2064 @node Args as Variable or List, Variable Number of Arguments, Data types, Arguments
|
|
2065 @comment node-name, next, previous, up
|
|
2066 @subsection An Argument as the Value of a Variable or List
|
|
2067
|
|
2068 An argument can be a symbol that returns a value when it is evaluated.
|
|
2069 For example, when the symbol @code{fill-column} by itself is evaluated,
|
|
2070 it returns a number. This number can be used in an addition.
|
|
2071
|
|
2072 @need 1250
|
|
2073 Position the cursor after the following expression and type @kbd{C-x
|
|
2074 C-e}:
|
|
2075
|
|
2076 @smallexample
|
|
2077 (+ 2 fill-column)
|
|
2078 @end smallexample
|
|
2079
|
|
2080 @noindent
|
|
2081 The value will be a number two more than what you get by evaluating
|
|
2082 @code{fill-column} alone. For me, this is 74, because my value of
|
|
2083 @code{fill-column} is 72.
|
|
2084
|
|
2085 As we have just seen, an argument can be a symbol that returns a value
|
|
2086 when evaluated. In addition, an argument can be a list that returns a
|
|
2087 value when it is evaluated. For example, in the following expression,
|
|
2088 the arguments to the function @code{concat} are the strings
|
|
2089 @w{@code{"The "}} and @w{@code{" red foxes."}} and the list
|
|
2090 @code{(number-to-string (+ 2 fill-column))}.
|
|
2091
|
|
2092 @c For GNU Emacs 22, need number-to-string
|
|
2093 @smallexample
|
|
2094 (concat "The " (number-to-string (+ 2 fill-column)) " red foxes.")
|
|
2095 @end smallexample
|
|
2096
|
|
2097 @noindent
|
|
2098 If you evaluate this expression---and if, as with my Emacs,
|
|
2099 @code{fill-column} evaluates to 72---@code{"The 74 red foxes."} will
|
|
2100 appear in the echo area. (Note that you must put spaces after the
|
|
2101 word @samp{The} and before the word @samp{red} so they will appear in
|
|
2102 the final string. The function @code{number-to-string} converts the
|
|
2103 integer that the addition function returns to a string.
|
|
2104 @code{number-to-string} is also known as @code{int-to-string}.)
|
|
2105
|
|
2106 @node Variable Number of Arguments, Wrong Type of Argument, Args as Variable or List, Arguments
|
|
2107 @comment node-name, next, previous, up
|
|
2108 @subsection Variable Number of Arguments
|
|
2109 @cindex Variable number of arguments
|
|
2110 @cindex Arguments, variable number of
|
|
2111
|
|
2112 Some functions, such as @code{concat}, @code{+} or @code{*}, take any
|
|
2113 number of arguments. (The @code{*} is the symbol for multiplication.)
|
|
2114 This can be seen by evaluating each of the following expressions in
|
|
2115 the usual way. What you will see in the echo area is printed in this
|
|
2116 text after @samp{@result{}}, which you may read as `evaluates to'.
|
|
2117
|
|
2118 @need 1250
|
|
2119 In the first set, the functions have no arguments:
|
|
2120
|
|
2121 @smallexample
|
|
2122 @group
|
|
2123 (+) @result{} 0
|
|
2124
|
|
2125 (*) @result{} 1
|
|
2126 @end group
|
|
2127 @end smallexample
|
|
2128
|
|
2129 @need 1250
|
|
2130 In this set, the functions have one argument each:
|
|
2131
|
|
2132 @smallexample
|
|
2133 @group
|
|
2134 (+ 3) @result{} 3
|
|
2135
|
|
2136 (* 3) @result{} 3
|
|
2137 @end group
|
|
2138 @end smallexample
|
|
2139
|
|
2140 @need 1250
|
|
2141 In this set, the functions have three arguments each:
|
|
2142
|
|
2143 @smallexample
|
|
2144 @group
|
|
2145 (+ 3 4 5) @result{} 12
|
|
2146
|
|
2147 (* 3 4 5) @result{} 60
|
|
2148 @end group
|
|
2149 @end smallexample
|
|
2150
|
|
2151 @node Wrong Type of Argument, message, Variable Number of Arguments, Arguments
|
|
2152 @comment node-name, next, previous, up
|
|
2153 @subsection Using the Wrong Type Object as an Argument
|
|
2154 @cindex Wrong type of argument
|
|
2155 @cindex Argument, wrong type of
|
|
2156
|
|
2157 When a function is passed an argument of the wrong type, the Lisp
|
|
2158 interpreter produces an error message. For example, the @code{+}
|
|
2159 function expects the values of its arguments to be numbers. As an
|
|
2160 experiment we can pass it the quoted symbol @code{hello} instead of a
|
|
2161 number. Position the cursor after the following expression and type
|
|
2162 @kbd{C-x C-e}:
|
|
2163
|
|
2164 @smallexample
|
|
2165 (+ 2 'hello)
|
|
2166 @end smallexample
|
|
2167
|
|
2168 @noindent
|
|
2169 When you do this you will generate an error message. What has happened
|
|
2170 is that @code{+} has tried to add the 2 to the value returned by
|
|
2171 @code{'hello}, but the value returned by @code{'hello} is the symbol
|
|
2172 @code{hello}, not a number. Only numbers can be added. So @code{+}
|
|
2173 could not carry out its addition.
|
|
2174
|
|
2175 @need 1250
|
|
2176 In GNU Emacs version 22, you will create and enter a
|
|
2177 @file{*Backtrace*} buffer that says:
|
|
2178
|
|
2179 @noindent
|
|
2180 @smallexample
|
|
2181 @group
|
|
2182 ---------- Buffer: *Backtrace* ----------
|
|
2183 Debugger entered--Lisp error:
|
|
2184 (wrong-type-argument number-or-marker-p hello)
|
|
2185 +(2 hello)
|
|
2186 eval((+ 2 (quote hello)))
|
|
2187 eval-last-sexp-1(nil)
|
|
2188 eval-last-sexp(nil)
|
|
2189 call-interactively(eval-last-sexp)
|
|
2190 ---------- Buffer: *Backtrace* ----------
|
|
2191 @end group
|
|
2192 @end smallexample
|
|
2193
|
|
2194 @need 1250
|
|
2195 As usual, the error message tries to be helpful and makes sense after you
|
|
2196 learn how to read it.@footnote{@code{(quote hello)} is an expansion of
|
|
2197 the abbreviation @code{'hello}.}
|
|
2198
|
|
2199 The first part of the error message is straightforward; it says
|
|
2200 @samp{wrong type argument}. Next comes the mysterious jargon word
|
|
2201 @w{@samp{number-or-marker-p}}. This word is trying to tell you what
|
|
2202 kind of argument the @code{+} expected.
|
|
2203
|
|
2204 The symbol @code{number-or-marker-p} says that the Lisp interpreter is
|
|
2205 trying to determine whether the information presented it (the value of
|
|
2206 the argument) is a number or a marker (a special object representing a
|
|
2207 buffer position). What it does is test to see whether the @code{+} is
|
|
2208 being given numbers to add. It also tests to see whether the
|
|
2209 argument is something called a marker, which is a specific feature of
|
|
2210 Emacs Lisp. (In Emacs, locations in a buffer are recorded as markers.
|
|
2211 When the mark is set with the @kbd{C-@@} or @kbd{C-@key{SPC}} command,
|
|
2212 its position is kept as a marker. The mark can be considered a
|
|
2213 number---the number of characters the location is from the beginning
|
|
2214 of the buffer.) In Emacs Lisp, @code{+} can be used to add the
|
|
2215 numeric value of marker positions as numbers.
|
|
2216
|
|
2217 The @samp{p} of @code{number-or-marker-p} is the embodiment of a
|
|
2218 practice started in the early days of Lisp programming. The @samp{p}
|
|
2219 stands for `predicate'. In the jargon used by the early Lisp
|
|
2220 researchers, a predicate refers to a function to determine whether some
|
|
2221 property is true or false. So the @samp{p} tells us that
|
|
2222 @code{number-or-marker-p} is the name of a function that determines
|
|
2223 whether it is true or false that the argument supplied is a number or
|
|
2224 a marker. Other Lisp symbols that end in @samp{p} include @code{zerop},
|
|
2225 a function that tests whether its argument has the value of zero, and
|
|
2226 @code{listp}, a function that tests whether its argument is a list.
|
|
2227
|
|
2228 Finally, the last part of the error message is the symbol @code{hello}.
|
|
2229 This is the value of the argument that was passed to @code{+}. If the
|
|
2230 addition had been passed the correct type of object, the value passed
|
|
2231 would have been a number, such as 37, rather than a symbol like
|
|
2232 @code{hello}. But then you would not have got the error message.
|
|
2233
|
|
2234 @ignore
|
|
2235 @need 1250
|
|
2236 In GNU Emacs version 20 and before, the echo area displays an error
|
|
2237 message that says:
|
|
2238
|
|
2239 @smallexample
|
|
2240 Wrong type argument:@: number-or-marker-p, hello
|
|
2241 @end smallexample
|
|
2242
|
|
2243 This says, in different words, the same as the top line of the
|
|
2244 @file{*Backtrace*} buffer.
|
|
2245 @end ignore
|
|
2246
|
|
2247 @node message, , Wrong Type of Argument, Arguments
|
|
2248 @comment node-name, next, previous, up
|
|
2249 @subsection The @code{message} Function
|
|
2250 @findex message
|
|
2251
|
|
2252 Like @code{+}, the @code{message} function takes a variable number of
|
|
2253 arguments. It is used to send messages to the user and is so useful
|
|
2254 that we will describe it here.
|
|
2255
|
|
2256 @need 1250
|
|
2257 A message is printed in the echo area. For example, you can print a
|
|
2258 message in your echo area by evaluating the following list:
|
|
2259
|
|
2260 @smallexample
|
|
2261 (message "This message appears in the echo area!")
|
|
2262 @end smallexample
|
|
2263
|
|
2264 The whole string between double quotation marks is a single argument
|
|
2265 and is printed @i{in toto}. (Note that in this example, the message
|
|
2266 itself will appear in the echo area within double quotes; that is
|
|
2267 because you see the value returned by the @code{message} function. In
|
|
2268 most uses of @code{message} in programs that you write, the text will
|
|
2269 be printed in the echo area as a side-effect, without the quotes.
|
|
2270 @xref{multiply-by-seven in detail, , @code{multiply-by-seven} in
|
|
2271 detail}, for an example of this.)
|
|
2272
|
|
2273 However, if there is a @samp{%s} in the quoted string of characters, the
|
|
2274 @code{message} function does not print the @samp{%s} as such, but looks
|
|
2275 to the argument that follows the string. It evaluates the second
|
|
2276 argument and prints the value at the location in the string where the
|
|
2277 @samp{%s} is.
|
|
2278
|
|
2279 @need 1250
|
|
2280 You can see this by positioning the cursor after the following
|
|
2281 expression and typing @kbd{C-x C-e}:
|
|
2282
|
|
2283 @smallexample
|
|
2284 (message "The name of this buffer is: %s." (buffer-name))
|
|
2285 @end smallexample
|
|
2286
|
|
2287 @noindent
|
|
2288 In Info, @code{"The name of this buffer is: *info*."} will appear in the
|
|
2289 echo area. The function @code{buffer-name} returns the name of the
|
|
2290 buffer as a string, which the @code{message} function inserts in place
|
|
2291 of @code{%s}.
|
|
2292
|
|
2293 To print a value as an integer, use @samp{%d} in the same way as
|
|
2294 @samp{%s}. For example, to print a message in the echo area that
|
|
2295 states the value of the @code{fill-column}, evaluate the following:
|
|
2296
|
|
2297 @smallexample
|
|
2298 (message "The value of fill-column is %d." fill-column)
|
|
2299 @end smallexample
|
|
2300
|
|
2301 @noindent
|
|
2302 On my system, when I evaluate this list, @code{"The value of
|
|
2303 fill-column is 72."} appears in my echo area@footnote{Actually, you
|
|
2304 can use @code{%s} to print a number. It is non-specific. @code{%d}
|
|
2305 prints only the part of a number left of a decimal point, and not
|
|
2306 anything that is not a number.}.
|
|
2307
|
|
2308 If there is more than one @samp{%s} in the quoted string, the value of
|
|
2309 the first argument following the quoted string is printed at the
|
|
2310 location of the first @samp{%s} and the value of the second argument is
|
|
2311 printed at the location of the second @samp{%s}, and so on.
|
|
2312
|
|
2313 @need 1250
|
|
2314 For example, if you evaluate the following,
|
|
2315
|
|
2316 @smallexample
|
|
2317 @group
|
|
2318 (message "There are %d %s in the office!"
|
|
2319 (- fill-column 14) "pink elephants")
|
|
2320 @end group
|
|
2321 @end smallexample
|
|
2322
|
|
2323 @noindent
|
|
2324 a rather whimsical message will appear in your echo area. On my system
|
|
2325 it says, @code{"There are 58 pink elephants in the office!"}.
|
|
2326
|
|
2327 The expression @code{(- fill-column 14)} is evaluated and the resulting
|
|
2328 number is inserted in place of the @samp{%d}; and the string in double
|
|
2329 quotes, @code{"pink elephants"}, is treated as a single argument and
|
|
2330 inserted in place of the @samp{%s}. (That is to say, a string between
|
|
2331 double quotes evaluates to itself, like a number.)
|
|
2332
|
|
2333 Finally, here is a somewhat complex example that not only illustrates
|
|
2334 the computation of a number, but also shows how you can use an
|
|
2335 expression within an expression to generate the text that is substituted
|
|
2336 for @samp{%s}:
|
|
2337
|
|
2338 @smallexample
|
|
2339 @group
|
|
2340 (message "He saw %d %s"
|
|
2341 (- fill-column 32)
|
|
2342 (concat "red "
|
|
2343 (substring
|
|
2344 "The quick brown foxes jumped." 16 21)
|
|
2345 " leaping."))
|
|
2346 @end group
|
|
2347 @end smallexample
|
|
2348
|
|
2349 In this example, @code{message} has three arguments: the string,
|
|
2350 @code{"He saw %d %s"}, the expression, @code{(- fill-column 32)}, and
|
|
2351 the expression beginning with the function @code{concat}. The value
|
|
2352 resulting from the evaluation of @code{(- fill-column 32)} is inserted
|
|
2353 in place of the @samp{%d}; and the value returned by the expression
|
|
2354 beginning with @code{concat} is inserted in place of the @samp{%s}.
|
|
2355
|
|
2356 When your fill column is 70 and you evaluate the expression, the
|
|
2357 message @code{"He saw 38 red foxes leaping."} appears in your echo
|
|
2358 area.
|
|
2359
|
|
2360 @node set & setq, Summary, Arguments, List Processing
|
|
2361 @comment node-name, next, previous, up
|
|
2362 @section Setting the Value of a Variable
|
|
2363 @cindex Variable, setting value
|
|
2364 @cindex Setting value of variable
|
|
2365
|
|
2366 @cindex @samp{bind} defined
|
|
2367 There are several ways by which a variable can be given a value. One of
|
|
2368 the ways is to use either the function @code{set} or the function
|
|
2369 @code{setq}. Another way is to use @code{let} (@pxref{let}). (The
|
|
2370 jargon for this process is to @dfn{bind} a variable to a value.)
|
|
2371
|
|
2372 The following sections not only describe how @code{set} and @code{setq}
|
|
2373 work but also illustrate how arguments are passed.
|
|
2374
|
|
2375 @menu
|
|
2376 * Using set:: Setting values.
|
|
2377 * Using setq:: Setting a quoted value.
|
|
2378 * Counting:: Using @code{setq} to count.
|
|
2379 @end menu
|
|
2380
|
|
2381 @node Using set, Using setq, set & setq, set & setq
|
|
2382 @comment node-name, next, previous, up
|
|
2383 @subsection Using @code{set}
|
|
2384 @findex set
|
|
2385
|
|
2386 To set the value of the symbol @code{flowers} to the list @code{'(rose
|
|
2387 violet daisy buttercup)}, evaluate the following expression by
|
|
2388 positioning the cursor after the expression and typing @kbd{C-x C-e}.
|
|
2389
|
|
2390 @smallexample
|
|
2391 (set 'flowers '(rose violet daisy buttercup))
|
|
2392 @end smallexample
|
|
2393
|
|
2394 @noindent
|
|
2395 The list @code{(rose violet daisy buttercup)} will appear in the echo
|
|
2396 area. This is what is @emph{returned} by the @code{set} function. As a
|
|
2397 side effect, the symbol @code{flowers} is bound to the list; that is,
|
|
2398 the symbol @code{flowers}, which can be viewed as a variable, is given
|
|
2399 the list as its value. (This process, by the way, illustrates how a
|
|
2400 side effect to the Lisp interpreter, setting the value, can be the
|
|
2401 primary effect that we humans are interested in. This is because every
|
|
2402 Lisp function must return a value if it does not get an error, but it
|
|
2403 will only have a side effect if it is designed to have one.)
|
|
2404
|
|
2405 After evaluating the @code{set} expression, you can evaluate the symbol
|
|
2406 @code{flowers} and it will return the value you just set. Here is the
|
|
2407 symbol. Place your cursor after it and type @kbd{C-x C-e}.
|
|
2408
|
|
2409 @smallexample
|
|
2410 flowers
|
|
2411 @end smallexample
|
|
2412
|
|
2413 @noindent
|
|
2414 When you evaluate @code{flowers}, the list
|
|
2415 @code{(rose violet daisy buttercup)} appears in the echo area.
|
|
2416
|
|
2417 Incidentally, if you evaluate @code{'flowers}, the variable with a quote
|
|
2418 in front of it, what you will see in the echo area is the symbol itself,
|
|
2419 @code{flowers}. Here is the quoted symbol, so you can try this:
|
|
2420
|
|
2421 @smallexample
|
|
2422 'flowers
|
|
2423 @end smallexample
|
|
2424
|
|
2425 Note also, that when you use @code{set}, you need to quote both
|
|
2426 arguments to @code{set}, unless you want them evaluated. Since we do
|
|
2427 not want either argument evaluated, neither the variable
|
|
2428 @code{flowers} nor the list @code{(rose violet daisy buttercup)}, both
|
|
2429 are quoted. (When you use @code{set} without quoting its first
|
|
2430 argument, the first argument is evaluated before anything else is
|
|
2431 done. If you did this and @code{flowers} did not have a value
|
|
2432 already, you would get an error message that the @samp{Symbol's value
|
|
2433 as variable is void}; on the other hand, if @code{flowers} did return
|
|
2434 a value after it was evaluated, the @code{set} would attempt to set
|
|
2435 the value that was returned. There are situations where this is the
|
|
2436 right thing for the function to do; but such situations are rare.)
|
|
2437
|
|
2438 @node Using setq, Counting, Using set, set & setq
|
|
2439 @comment node-name, next, previous, up
|
|
2440 @subsection Using @code{setq}
|
|
2441 @findex setq
|
|
2442
|
|
2443 As a practical matter, you almost always quote the first argument to
|
|
2444 @code{set}. The combination of @code{set} and a quoted first argument
|
|
2445 is so common that it has its own name: the special form @code{setq}.
|
|
2446 This special form is just like @code{set} except that the first argument
|
|
2447 is quoted automatically, so you don't need to type the quote mark
|
|
2448 yourself. Also, as an added convenience, @code{setq} permits you to set
|
|
2449 several different variables to different values, all in one expression.
|
|
2450
|
|
2451 To set the value of the variable @code{carnivores} to the list
|
|
2452 @code{'(lion tiger leopard)} using @code{setq}, the following expression
|
|
2453 is used:
|
|
2454
|
|
2455 @smallexample
|
|
2456 (setq carnivores '(lion tiger leopard))
|
|
2457 @end smallexample
|
|
2458
|
|
2459 @noindent
|
|
2460 This is exactly the same as using @code{set} except the first argument
|
|
2461 is automatically quoted by @code{setq}. (The @samp{q} in @code{setq}
|
|
2462 means @code{quote}.)
|
|
2463
|
|
2464 @need 1250
|
|
2465 With @code{set}, the expression would look like this:
|
|
2466
|
|
2467 @smallexample
|
|
2468 (set 'carnivores '(lion tiger leopard))
|
|
2469 @end smallexample
|
|
2470
|
|
2471 Also, @code{setq} can be used to assign different values to
|
|
2472 different variables. The first argument is bound to the value
|
|
2473 of the second argument, the third argument is bound to the value of the
|
|
2474 fourth argument, and so on. For example, you could use the following to
|
|
2475 assign a list of trees to the symbol @code{trees} and a list of herbivores
|
|
2476 to the symbol @code{herbivores}:
|
|
2477
|
|
2478 @smallexample
|
|
2479 @group
|
|
2480 (setq trees '(pine fir oak maple)
|
|
2481 herbivores '(gazelle antelope zebra))
|
|
2482 @end group
|
|
2483 @end smallexample
|
|
2484
|
|
2485 @noindent
|
|
2486 (The expression could just as well have been on one line, but it might
|
|
2487 not have fit on a page; and humans find it easier to read nicely
|
|
2488 formatted lists.)
|
|
2489
|
|
2490 Although I have been using the term `assign', there is another way of
|
|
2491 thinking about the workings of @code{set} and @code{setq}; and that is to
|
|
2492 say that @code{set} and @code{setq} make the symbol @emph{point} to the
|
|
2493 list. This latter way of thinking is very common and in forthcoming
|
|
2494 chapters we shall come upon at least one symbol that has `pointer' as
|
|
2495 part of its name. The name is chosen because the symbol has a value,
|
|
2496 specifically a list, attached to it; or, expressed another way,
|
|
2497 the symbol is set to ``point'' to the list.
|
|
2498
|
|
2499 @node Counting, , Using setq, set & setq
|
|
2500 @comment node-name, next, previous, up
|
|
2501 @subsection Counting
|
|
2502 @cindex Counting
|
|
2503
|
|
2504 Here is an example that shows how to use @code{setq} in a counter. You
|
|
2505 might use this to count how many times a part of your program repeats
|
|
2506 itself. First set a variable to zero; then add one to the number each
|
|
2507 time the program repeats itself. To do this, you need a variable that
|
|
2508 serves as a counter, and two expressions: an initial @code{setq}
|
|
2509 expression that sets the counter variable to zero; and a second
|
|
2510 @code{setq} expression that increments the counter each time it is
|
|
2511 evaluated.
|
|
2512
|
|
2513 @smallexample
|
|
2514 @group
|
|
2515 (setq counter 0) ; @r{Let's call this the initializer.}
|
|
2516
|
|
2517 (setq counter (+ counter 1)) ; @r{This is the incrementer.}
|
|
2518
|
|
2519 counter ; @r{This is the counter.}
|
|
2520 @end group
|
|
2521 @end smallexample
|
|
2522
|
|
2523 @noindent
|
|
2524 (The text following the @samp{;} are comments. @xref{Change a
|
|
2525 defun, , Change a Function Definition}.)
|
|
2526
|
|
2527 If you evaluate the first of these expressions, the initializer,
|
|
2528 @code{(setq counter 0)}, and then evaluate the third expression,
|
|
2529 @code{counter}, the number @code{0} will appear in the echo area. If
|
|
2530 you then evaluate the second expression, the incrementer, @code{(setq
|
|
2531 counter (+ counter 1))}, the counter will get the value 1. So if you
|
|
2532 again evaluate @code{counter}, the number @code{1} will appear in the
|
|
2533 echo area. Each time you evaluate the second expression, the value of
|
|
2534 the counter will be incremented.
|
|
2535
|
|
2536 When you evaluate the incrementer, @code{(setq counter (+ counter 1))},
|
|
2537 the Lisp interpreter first evaluates the innermost list; this is the
|
|
2538 addition. In order to evaluate this list, it must evaluate the variable
|
|
2539 @code{counter} and the number @code{1}. When it evaluates the variable
|
|
2540 @code{counter}, it receives its current value. It passes this value and
|
|
2541 the number @code{1} to the @code{+} which adds them together. The sum
|
|
2542 is then returned as the value of the inner list and passed to the
|
|
2543 @code{setq} which sets the variable @code{counter} to this new value.
|
|
2544 Thus, the value of the variable, @code{counter}, is changed.
|
|
2545
|
|
2546 @node Summary, Error Message Exercises, set & setq, List Processing
|
|
2547 @comment node-name, next, previous, up
|
|
2548 @section Summary
|
|
2549
|
|
2550 Learning Lisp is like climbing a hill in which the first part is the
|
|
2551 steepest. You have now climbed the most difficult part; what remains
|
|
2552 becomes easier as you progress onwards.
|
|
2553
|
|
2554 @need 1000
|
|
2555 In summary,
|
|
2556
|
|
2557 @itemize @bullet
|
|
2558
|
|
2559 @item
|
|
2560 Lisp programs are made up of expressions, which are lists or single atoms.
|
|
2561
|
|
2562 @item
|
|
2563 Lists are made up of zero or more atoms or inner lists, separated by whitespace and
|
|
2564 surrounded by parentheses. A list can be empty.
|
|
2565
|
|
2566 @item
|
|
2567 Atoms are multi-character symbols, like @code{forward-paragraph}, single
|
|
2568 character symbols like @code{+}, strings of characters between double
|
|
2569 quotation marks, or numbers.
|
|
2570
|
|
2571 @item
|
|
2572 A number evaluates to itself.
|
|
2573
|
|
2574 @item
|
|
2575 A string between double quotes also evaluates to itself.
|
|
2576
|
|
2577 @item
|
|
2578 When you evaluate a symbol by itself, its value is returned.
|
|
2579
|
|
2580 @item
|
|
2581 When you evaluate a list, the Lisp interpreter looks at the first symbol
|
|
2582 in the list and then at the function definition bound to that symbol.
|
|
2583 Then the instructions in the function definition are carried out.
|
|
2584
|
|
2585 @item
|
|
2586 A single quotation mark,
|
|
2587 @ifinfo
|
|
2588 '
|
|
2589 @end ifinfo
|
|
2590 @ifnotinfo
|
|
2591 @code{'}
|
|
2592 @end ifnotinfo
|
|
2593 , tells the Lisp interpreter that it should
|
|
2594 return the following expression as written, and not evaluate it as it
|
|
2595 would if the quote were not there.
|
|
2596
|
|
2597 @item
|
|
2598 Arguments are the information passed to a function. The arguments to a
|
|
2599 function are computed by evaluating the rest of the elements of the list
|
|
2600 of which the function is the first element.
|
|
2601
|
|
2602 @item
|
|
2603 A function always returns a value when it is evaluated (unless it gets
|
|
2604 an error); in addition, it may also carry out some action called a
|
|
2605 ``side effect''. In many cases, a function's primary purpose is to
|
|
2606 create a side effect.
|
|
2607 @end itemize
|
|
2608
|
|
2609 @node Error Message Exercises, , Summary, List Processing
|
|
2610 @comment node-name, next, previous, up
|
|
2611 @section Exercises
|
|
2612
|
|
2613 A few simple exercises:
|
|
2614
|
|
2615 @itemize @bullet
|
|
2616 @item
|
|
2617 Generate an error message by evaluating an appropriate symbol that is
|
|
2618 not within parentheses.
|
|
2619
|
|
2620 @item
|
|
2621 Generate an error message by evaluating an appropriate symbol that is
|
|
2622 between parentheses.
|
|
2623
|
|
2624 @item
|
|
2625 Create a counter that increments by two rather than one.
|
|
2626
|
|
2627 @item
|
|
2628 Write an expression that prints a message in the echo area when
|
|
2629 evaluated.
|
|
2630 @end itemize
|
|
2631
|
|
2632 @node Practicing Evaluation, Writing Defuns, List Processing, Top
|
|
2633 @comment node-name, next, previous, up
|
|
2634 @chapter Practicing Evaluation
|
|
2635 @cindex Practicing evaluation
|
|
2636 @cindex Evaluation practice
|
|
2637
|
|
2638 Before learning how to write a function definition in Emacs Lisp, it is
|
|
2639 useful to spend a little time evaluating various expressions that have
|
|
2640 already been written. These expressions will be lists with the
|
|
2641 functions as their first (and often only) element. Since some of the
|
|
2642 functions associated with buffers are both simple and interesting, we
|
|
2643 will start with those. In this section, we will evaluate a few of
|
|
2644 these. In another section, we will study the code of several other
|
|
2645 buffer-related functions, to see how they were written.
|
|
2646
|
|
2647 @menu
|
|
2648 * How to Evaluate:: Typing editing commands or @kbd{C-x C-e}
|
|
2649 causes evaluation.
|
|
2650 * Buffer Names:: Buffers and files are different.
|
|
2651 * Getting Buffers:: Getting a buffer itself, not merely its name.
|
|
2652 * Switching Buffers:: How to change to another buffer.
|
|
2653 * Buffer Size & Locations:: Where point is located and the size of
|
|
2654 the buffer.
|
|
2655 * Evaluation Exercise::
|
|
2656 @end menu
|
|
2657
|
|
2658 @node How to Evaluate, Buffer Names, Practicing Evaluation, Practicing Evaluation
|
|
2659 @ifnottex
|
|
2660 @unnumberedsec How to Evaluate
|
|
2661 @end ifnottex
|
|
2662
|
|
2663 @i{Whenever you give an editing command} to Emacs Lisp, such as the
|
|
2664 command to move the cursor or to scroll the screen, @i{you are evaluating
|
|
2665 an expression,} the first element of which is a function. @i{This is
|
|
2666 how Emacs works.}
|
|
2667
|
|
2668 @cindex @samp{interactive function} defined
|
|
2669 @cindex @samp{command} defined
|
|
2670 When you type keys, you cause the Lisp interpreter to evaluate an
|
|
2671 expression and that is how you get your results. Even typing plain text
|
|
2672 involves evaluating an Emacs Lisp function, in this case, one that uses
|
|
2673 @code{self-insert-command}, which simply inserts the character you
|
|
2674 typed. The functions you evaluate by typing keystrokes are called
|
|
2675 @dfn{interactive} functions, or @dfn{commands}; how you make a function
|
|
2676 interactive will be illustrated in the chapter on how to write function
|
|
2677 definitions. @xref{Interactive, , Making a Function Interactive}.
|
|
2678
|
|
2679 In addition to typing keyboard commands, we have seen a second way to
|
|
2680 evaluate an expression: by positioning the cursor after a list and
|
|
2681 typing @kbd{C-x C-e}. This is what we will do in the rest of this
|
|
2682 section. There are other ways to evaluate an expression as well; these
|
|
2683 will be described as we come to them.
|
|
2684
|
|
2685 Besides being used for practicing evaluation, the functions shown in the
|
|
2686 next few sections are important in their own right. A study of these
|
|
2687 functions makes clear the distinction between buffers and files, how to
|
|
2688 switch to a buffer, and how to determine a location within it.
|
|
2689
|
|
2690 @node Buffer Names, Getting Buffers, How to Evaluate, Practicing Evaluation
|
|
2691 @comment node-name, next, previous, up
|
|
2692 @section Buffer Names
|
|
2693 @findex buffer-name
|
|
2694 @findex buffer-file-name
|
|
2695
|
|
2696 The two functions, @code{buffer-name} and @code{buffer-file-name}, show
|
|
2697 the difference between a file and a buffer. When you evaluate the
|
|
2698 following expression, @code{(buffer-name)}, the name of the buffer
|
|
2699 appears in the echo area. When you evaluate @code{(buffer-file-name)},
|
|
2700 the name of the file to which the buffer refers appears in the echo
|
|
2701 area. Usually, the name returned by @code{(buffer-name)} is the same as
|
|
2702 the name of the file to which it refers, and the name returned by
|
|
2703 @code{(buffer-file-name)} is the full path-name of the file.
|
|
2704
|
|
2705 A file and a buffer are two different entities. A file is information
|
|
2706 recorded permanently in the computer (unless you delete it). A buffer,
|
|
2707 on the other hand, is information inside of Emacs that will vanish at
|
|
2708 the end of the editing session (or when you kill the buffer). Usually,
|
|
2709 a buffer contains information that you have copied from a file; we say
|
|
2710 the buffer is @dfn{visiting} that file. This copy is what you work on
|
|
2711 and modify. Changes to the buffer do not change the file, until you
|
|
2712 save the buffer. When you save the buffer, the buffer is copied to the file
|
|
2713 and is thus saved permanently.
|
|
2714
|
|
2715 @need 1250
|
|
2716 If you are reading this in Info inside of GNU Emacs, you can evaluate
|
|
2717 each of the following expressions by positioning the cursor after it and
|
|
2718 typing @kbd{C-x C-e}.
|
|
2719
|
|
2720 @example
|
|
2721 @group
|
|
2722 (buffer-name)
|
|
2723
|
|
2724 (buffer-file-name)
|
|
2725 @end group
|
|
2726 @end example
|
|
2727
|
|
2728 @noindent
|
|
2729 When I do this in Info, the value returned by evaluating
|
|
2730 @code{(buffer-name)} is @file{"*info*"}, and the value returned by
|
|
2731 evaluating @code{(buffer-file-name)} is @file{nil}.
|
|
2732
|
98525
|
2733 On the other hand, while I am writing this document, the value
|
83955
|
2734 returned by evaluating @code{(buffer-name)} is
|
|
2735 @file{"introduction.texinfo"}, and the value returned by evaluating
|
|
2736 @code{(buffer-file-name)} is
|
|
2737 @file{"/gnu/work/intro/introduction.texinfo"}.
|
|
2738
|
|
2739 @cindex @code{nil}, history of word
|
|
2740 The former is the name of the buffer and the latter is the name of the
|
|
2741 file. In Info, the buffer name is @file{"*info*"}. Info does not
|
|
2742 point to any file, so the result of evaluating
|
|
2743 @code{(buffer-file-name)} is @file{nil}. The symbol @code{nil} is
|
|
2744 from the Latin word for `nothing'; in this case, it means that the
|
|
2745 buffer is not associated with any file. (In Lisp, @code{nil} is also
|
|
2746 used to mean `false' and is a synonym for the empty list, @code{()}.)
|
|
2747
|
|
2748 When I am writing, the name of my buffer is
|
|
2749 @file{"introduction.texinfo"}. The name of the file to which it
|
|
2750 points is @file{"/gnu/work/intro/introduction.texinfo"}.
|
|
2751
|
|
2752 (In the expressions, the parentheses tell the Lisp interpreter to
|
|
2753 treat @w{@code{buffer-name}} and @w{@code{buffer-file-name}} as
|
|
2754 functions; without the parentheses, the interpreter would attempt to
|
|
2755 evaluate the symbols as variables. @xref{Variables}.)
|
|
2756
|
|
2757 In spite of the distinction between files and buffers, you will often
|
|
2758 find that people refer to a file when they mean a buffer and vice-verse.
|
|
2759 Indeed, most people say, ``I am editing a file,'' rather than saying,
|
|
2760 ``I am editing a buffer which I will soon save to a file.'' It is
|
|
2761 almost always clear from context what people mean. When dealing with
|
|
2762 computer programs, however, it is important to keep the distinction in mind,
|
|
2763 since the computer is not as smart as a person.
|
|
2764
|
|
2765 @cindex Buffer, history of word
|
|
2766 The word `buffer', by the way, comes from the meaning of the word as a
|
|
2767 cushion that deadens the force of a collision. In early computers, a
|
|
2768 buffer cushioned the interaction between files and the computer's
|
|
2769 central processing unit. The drums or tapes that held a file and the
|
|
2770 central processing unit were pieces of equipment that were very
|
|
2771 different from each other, working at their own speeds, in spurts. The
|
|
2772 buffer made it possible for them to work together effectively.
|
|
2773 Eventually, the buffer grew from being an intermediary, a temporary
|
|
2774 holding place, to being the place where work is done. This
|
|
2775 transformation is rather like that of a small seaport that grew into a
|
|
2776 great city: once it was merely the place where cargo was warehoused
|
|
2777 temporarily before being loaded onto ships; then it became a business
|
|
2778 and cultural center in its own right.
|
|
2779
|
|
2780 Not all buffers are associated with files. For example, a
|
|
2781 @file{*scratch*} buffer does not visit any file. Similarly, a
|
|
2782 @file{*Help*} buffer is not associated with any file.
|
|
2783
|
|
2784 In the old days, when you lacked a @file{~/.emacs} file and started an
|
|
2785 Emacs session by typing the command @code{emacs} alone, without naming
|
|
2786 any files, Emacs started with the @file{*scratch*} buffer visible.
|
|
2787 Nowadays, you will see a splash screen. You can follow one of the
|
|
2788 commands suggested on the splash screen, visit a file, or press the
|
|
2789 spacebar to reach the @file{*scratch*} buffer.
|
|
2790
|
|
2791 If you switch to the @file{*scratch*} buffer, type
|
|
2792 @code{(buffer-name)}, position the cursor after it, and then type
|
|
2793 @kbd{C-x C-e} to evaluate the expression. The name @code{"*scratch*"}
|
|
2794 will be returned and will appear in the echo area. @code{"*scratch*"}
|
|
2795 is the name of the buffer. When you type @code{(buffer-file-name)} in
|
|
2796 the @file{*scratch*} buffer and evaluate that, @code{nil} will appear
|
|
2797 in the echo area, just as it does when you evaluate
|
|
2798 @code{(buffer-file-name)} in Info.
|
|
2799
|
|
2800 Incidentally, if you are in the @file{*scratch*} buffer and want the
|
|
2801 value returned by an expression to appear in the @file{*scratch*}
|
|
2802 buffer itself rather than in the echo area, type @kbd{C-u C-x C-e}
|
|
2803 instead of @kbd{C-x C-e}. This causes the value returned to appear
|
|
2804 after the expression. The buffer will look like this:
|
|
2805
|
|
2806 @smallexample
|
|
2807 (buffer-name)"*scratch*"
|
|
2808 @end smallexample
|
|
2809
|
|
2810 @noindent
|
|
2811 You cannot do this in Info since Info is read-only and it will not allow
|
|
2812 you to change the contents of the buffer. But you can do this in any
|
|
2813 buffer you can edit; and when you write code or documentation (such as
|
|
2814 this book), this feature is very useful.
|
|
2815
|
|
2816 @node Getting Buffers, Switching Buffers, Buffer Names, Practicing Evaluation
|
|
2817 @comment node-name, next, previous, up
|
|
2818 @section Getting Buffers
|
|
2819 @findex current-buffer
|
|
2820 @findex other-buffer
|
|
2821 @cindex Getting a buffer
|
|
2822
|
|
2823 The @code{buffer-name} function returns the @emph{name} of the buffer;
|
|
2824 to get the buffer @emph{itself}, a different function is needed: the
|
|
2825 @code{current-buffer} function. If you use this function in code, what
|
|
2826 you get is the buffer itself.
|
|
2827
|
|
2828 A name and the object or entity to which the name refers are different
|
|
2829 from each other. You are not your name. You are a person to whom
|
|
2830 others refer by name. If you ask to speak to George and someone hands you
|
|
2831 a card with the letters @samp{G}, @samp{e}, @samp{o}, @samp{r},
|
|
2832 @samp{g}, and @samp{e} written on it, you might be amused, but you would
|
|
2833 not be satisfied. You do not want to speak to the name, but to the
|
|
2834 person to whom the name refers. A buffer is similar: the name of the
|
|
2835 scratch buffer is @file{*scratch*}, but the name is not the buffer. To
|
|
2836 get a buffer itself, you need to use a function such as
|
|
2837 @code{current-buffer}.
|
|
2838
|
|
2839 However, there is a slight complication: if you evaluate
|
|
2840 @code{current-buffer} in an expression on its own, as we will do here,
|
|
2841 what you see is a printed representation of the name of the buffer
|
|
2842 without the contents of the buffer. Emacs works this way for two
|
|
2843 reasons: the buffer may be thousands of lines long---too long to be
|
|
2844 conveniently displayed; and, another buffer may have the same contents
|
|
2845 but a different name, and it is important to distinguish between them.
|
|
2846
|
|
2847 @need 800
|
|
2848 Here is an expression containing the function:
|
|
2849
|
|
2850 @smallexample
|
|
2851 (current-buffer)
|
|
2852 @end smallexample
|
|
2853
|
|
2854 @noindent
|
|
2855 If you evaluate this expression in Info in Emacs in the usual way,
|
|
2856 @file{#<buffer *info*>} will appear in the echo area. The special
|
|
2857 format indicates that the buffer itself is being returned, rather than
|
|
2858 just its name.
|
|
2859
|
|
2860 Incidentally, while you can type a number or symbol into a program, you
|
|
2861 cannot do that with the printed representation of a buffer: the only way
|
|
2862 to get a buffer itself is with a function such as @code{current-buffer}.
|
|
2863
|
|
2864 A related function is @code{other-buffer}. This returns the most
|
|
2865 recently selected buffer other than the one you are in currently, not
|
|
2866 a printed representation of its name. If you have recently switched
|
|
2867 back and forth from the @file{*scratch*} buffer, @code{other-buffer}
|
|
2868 will return that buffer.
|
|
2869
|
|
2870 @need 800
|
|
2871 You can see this by evaluating the expression:
|
|
2872
|
|
2873 @smallexample
|
|
2874 (other-buffer)
|
|
2875 @end smallexample
|
|
2876
|
|
2877 @noindent
|
|
2878 You should see @file{#<buffer *scratch*>} appear in the echo area, or
|
|
2879 the name of whatever other buffer you switched back from most
|
|
2880 recently@footnote{Actually, by default, if the buffer from which you
|
|
2881 just switched is visible to you in another window, @code{other-buffer}
|
|
2882 will choose the most recent buffer that you cannot see; this is a
|
|
2883 subtlety that I often forget.}.
|
|
2884
|
|
2885 @node Switching Buffers, Buffer Size & Locations, Getting Buffers, Practicing Evaluation
|
|
2886 @comment node-name, next, previous, up
|
|
2887 @section Switching Buffers
|
|
2888 @findex switch-to-buffer
|
|
2889 @findex set-buffer
|
|
2890 @cindex Switching to a buffer
|
|
2891
|
|
2892 The @code{other-buffer} function actually provides a buffer when it is
|
|
2893 used as an argument to a function that requires one. We can see this
|
|
2894 by using @code{other-buffer} and @code{switch-to-buffer} to switch to a
|
|
2895 different buffer.
|
|
2896
|
|
2897 But first, a brief introduction to the @code{switch-to-buffer}
|
|
2898 function. When you switched back and forth from Info to the
|
|
2899 @file{*scratch*} buffer to evaluate @code{(buffer-name)}, you most
|
|
2900 likely typed @kbd{C-x b} and then typed @file{*scratch*}@footnote{Or
|
|
2901 rather, to save typing, you probably only typed @kbd{RET} if the
|
|
2902 default buffer was @file{*scratch*}, or if it was different, then you
|
|
2903 typed just part of the name, such as @code{*sc}, pressed your
|
|
2904 @kbd{TAB} key to cause it to expand to the full name, and then typed
|
|
2905 your @kbd{RET} key.} when prompted in the minibuffer for the name of
|
|
2906 the buffer to which you wanted to switch. The keystrokes, @kbd{C-x
|
|
2907 b}, cause the Lisp interpreter to evaluate the interactive function
|
|
2908 @code{switch-to-buffer}. As we said before, this is how Emacs works:
|
|
2909 different keystrokes call or run different functions. For example,
|
|
2910 @kbd{C-f} calls @code{forward-char}, @kbd{M-e} calls
|
|
2911 @code{forward-sentence}, and so on.
|
|
2912
|
|
2913 By writing @code{switch-to-buffer} in an expression, and giving it a
|
|
2914 buffer to switch to, we can switch buffers just the way @kbd{C-x b}
|
|
2915 does.
|
|
2916
|
|
2917 @need 1000
|
|
2918 Here is the Lisp expression:
|
|
2919
|
|
2920 @smallexample
|
|
2921 (switch-to-buffer (other-buffer))
|
|
2922 @end smallexample
|
|
2923
|
|
2924 @noindent
|
|
2925 The symbol @code{switch-to-buffer} is the first element of the list,
|
|
2926 so the Lisp interpreter will treat it as a function and carry out the
|
|
2927 instructions that are attached to it. But before doing that, the
|
|
2928 interpreter will note that @code{other-buffer} is inside parentheses
|
|
2929 and work on that symbol first. @code{other-buffer} is the first (and
|
|
2930 in this case, the only) element of this list, so the Lisp interpreter
|
|
2931 calls or runs the function. It returns another buffer. Next, the
|
|
2932 interpreter runs @code{switch-to-buffer}, passing to it, as an
|
|
2933 argument, the other buffer, which is what Emacs will switch to. If
|
|
2934 you are reading this in Info, try this now. Evaluate the expression.
|
|
2935 (To get back, type @kbd{C-x b @key{RET}}.)@footnote{Remember, this
|
|
2936 expression will move you to your most recent other buffer that you
|
|
2937 cannot see. If you really want to go to your most recently selected
|
|
2938 buffer, even if you can still see it, you need to evaluate the
|
|
2939 following more complex expression:
|
|
2940
|
|
2941 @smallexample
|
|
2942 (switch-to-buffer (other-buffer (current-buffer) t))
|
|
2943 @end smallexample
|
|
2944
|
|
2945 @c noindent
|
|
2946 In this case, the first argument to @code{other-buffer} tells it which
|
|
2947 buffer to skip---the current one---and the second argument tells
|
|
2948 @code{other-buffer} it is OK to switch to a visible buffer.
|
|
2949 In regular use, @code{switch-to-buffer} takes you to an invisible
|
|
2950 window since you would most likely use @kbd{C-x o} (@code{other-window})
|
|
2951 to go to another visible buffer.}
|
|
2952
|
|
2953 In the programming examples in later sections of this document, you will
|
|
2954 see the function @code{set-buffer} more often than
|
|
2955 @code{switch-to-buffer}. This is because of a difference between
|
|
2956 computer programs and humans: humans have eyes and expect to see the
|
|
2957 buffer on which they are working on their computer terminals. This is
|
|
2958 so obvious, it almost goes without saying. However, programs do not
|
|
2959 have eyes. When a computer program works on a buffer, that buffer does
|
|
2960 not need to be visible on the screen.
|
|
2961
|
|
2962 @code{switch-to-buffer} is designed for humans and does two different
|
|
2963 things: it switches the buffer to which Emacs' attention is directed; and
|
|
2964 it switches the buffer displayed in the window to the new buffer.
|
|
2965 @code{set-buffer}, on the other hand, does only one thing: it switches
|
|
2966 the attention of the computer program to a different buffer. The buffer
|
|
2967 on the screen remains unchanged (of course, normally nothing happens
|
|
2968 there until the command finishes running).
|
|
2969
|
|
2970 @cindex @samp{call} defined
|
|
2971 Also, we have just introduced another jargon term, the word @dfn{call}.
|
|
2972 When you evaluate a list in which the first symbol is a function, you
|
|
2973 are calling that function. The use of the term comes from the notion of
|
|
2974 the function as an entity that can do something for you if you `call'
|
|
2975 it---just as a plumber is an entity who can fix a leak if you call him
|
|
2976 or her.
|
|
2977
|
|
2978 @node Buffer Size & Locations, Evaluation Exercise, Switching Buffers, Practicing Evaluation
|
|
2979 @comment node-name, next, previous, up
|
|
2980 @section Buffer Size and the Location of Point
|
|
2981 @cindex Size of buffer
|
|
2982 @cindex Buffer size
|
|
2983 @cindex Point location
|
|
2984 @cindex Location of point
|
|
2985
|
|
2986 Finally, let's look at several rather simple functions,
|
|
2987 @code{buffer-size}, @code{point}, @code{point-min}, and
|
|
2988 @code{point-max}. These give information about the size of a buffer and
|
|
2989 the location of point within it.
|
|
2990
|
|
2991 The function @code{buffer-size} tells you the size of the current
|
|
2992 buffer; that is, the function returns a count of the number of
|
|
2993 characters in the buffer.
|
|
2994
|
|
2995 @smallexample
|
|
2996 (buffer-size)
|
|
2997 @end smallexample
|
|
2998
|
|
2999 @noindent
|
|
3000 You can evaluate this in the usual way, by positioning the
|
|
3001 cursor after the expression and typing @kbd{C-x C-e}.
|
|
3002
|
|
3003 @cindex @samp{point} defined
|
|
3004 In Emacs, the current position of the cursor is called @dfn{point}.
|
|
3005 The expression @code{(point)} returns a number that tells you where the
|
|
3006 cursor is located as a count of the number of characters from the
|
|
3007 beginning of the buffer up to point.
|
|
3008
|
|
3009 @need 1250
|
|
3010 You can see the character count for point in this buffer by evaluating
|
|
3011 the following expression in the usual way:
|
|
3012
|
|
3013 @smallexample
|
|
3014 (point)
|
|
3015 @end smallexample
|
|
3016
|
|
3017 @noindent
|
|
3018 As I write this, the value of @code{point} is 65724. The @code{point}
|
|
3019 function is frequently used in some of the examples later in this
|
|
3020 book.
|
|
3021
|
|
3022 @need 1250
|
|
3023 The value of point depends, of course, on its location within the
|
|
3024 buffer. If you evaluate point in this spot, the number will be larger:
|
|
3025
|
|
3026 @smallexample
|
|
3027 (point)
|
|
3028 @end smallexample
|
|
3029
|
|
3030 @noindent
|
|
3031 For me, the value of point in this location is 66043, which means that
|
|
3032 there are 319 characters (including spaces) between the two
|
|
3033 expressions. (Doubtless, you will see different numbers, since I will
|
|
3034 have edited this since I first evaluated point.)
|
|
3035
|
|
3036 @cindex @samp{narrowing} defined
|
|
3037 The function @code{point-min} is somewhat similar to @code{point}, but
|
|
3038 it returns the value of the minimum permissible value of point in the
|
|
3039 current buffer. This is the number 1 unless @dfn{narrowing} is in
|
|
3040 effect. (Narrowing is a mechanism whereby you can restrict yourself,
|
|
3041 or a program, to operations on just a part of a buffer.
|
|
3042 @xref{Narrowing & Widening, , Narrowing and Widening}.) Likewise, the
|
|
3043 function @code{point-max} returns the value of the maximum permissible
|
|
3044 value of point in the current buffer.
|
|
3045
|
|
3046 @node Evaluation Exercise, , Buffer Size & Locations, Practicing Evaluation
|
|
3047 @section Exercise
|
|
3048
|
|
3049 Find a file with which you are working and move towards its middle.
|
|
3050 Find its buffer name, file name, length, and your position in the file.
|
|
3051
|
|
3052 @node Writing Defuns, Buffer Walk Through, Practicing Evaluation, Top
|
|
3053 @comment node-name, next, previous, up
|
|
3054 @chapter How To Write Function Definitions
|
|
3055 @cindex Definition writing
|
|
3056 @cindex Function definition writing
|
|
3057 @cindex Writing a function definition
|
|
3058
|
|
3059 When the Lisp interpreter evaluates a list, it looks to see whether the
|
|
3060 first symbol on the list has a function definition attached to it; or,
|
|
3061 put another way, whether the symbol points to a function definition. If
|
|
3062 it does, the computer carries out the instructions in the definition. A
|
|
3063 symbol that has a function definition is called, simply, a function
|
|
3064 (although, properly speaking, the definition is the function and the
|
|
3065 symbol refers to it.)
|
|
3066
|
|
3067 @menu
|
|
3068 * Primitive Functions::
|
|
3069 * defun:: The @code{defun} special form.
|
|
3070 * Install:: Install a function definition.
|
|
3071 * Interactive:: Making a function interactive.
|
|
3072 * Interactive Options:: Different options for @code{interactive}.
|
|
3073 * Permanent Installation:: Installing code permanently.
|
|
3074 * let:: Creating and initializing local variables.
|
|
3075 * if:: What if?
|
|
3076 * else:: If--then--else expressions.
|
|
3077 * Truth & Falsehood:: What Lisp considers false and true.
|
|
3078 * save-excursion:: Keeping track of point, mark, and buffer.
|
|
3079 * Review::
|
|
3080 * defun Exercises::
|
|
3081 @end menu
|
|
3082
|
|
3083 @node Primitive Functions, defun, Writing Defuns, Writing Defuns
|
|
3084 @ifnottex
|
|
3085 @unnumberedsec An Aside about Primitive Functions
|
|
3086 @end ifnottex
|
|
3087 @cindex Primitive functions
|
|
3088 @cindex Functions, primitive
|
|
3089
|
|
3090 @cindex C language primitives
|
|
3091 @cindex Primitives written in C
|
|
3092 All functions are defined in terms of other functions, except for a few
|
|
3093 @dfn{primitive} functions that are written in the C programming
|
|
3094 language. When you write functions' definitions, you will write them in
|
|
3095 Emacs Lisp and use other functions as your building blocks. Some of the
|
|
3096 functions you will use will themselves be written in Emacs Lisp (perhaps
|
|
3097 by you) and some will be primitives written in C. The primitive
|
|
3098 functions are used exactly like those written in Emacs Lisp and behave
|
|
3099 like them. They are written in C so we can easily run GNU Emacs on any
|
|
3100 computer that has sufficient power and can run C.
|
|
3101
|
|
3102 Let me re-emphasize this: when you write code in Emacs Lisp, you do not
|
|
3103 distinguish between the use of functions written in C and the use of
|
|
3104 functions written in Emacs Lisp. The difference is irrelevant. I
|
|
3105 mention the distinction only because it is interesting to know. Indeed,
|
|
3106 unless you investigate, you won't know whether an already-written
|
|
3107 function is written in Emacs Lisp or C.
|
|
3108
|
|
3109 @node defun, Install, Primitive Functions, Writing Defuns
|
|
3110 @comment node-name, next, previous, up
|
|
3111 @section The @code{defun} Special Form
|
|
3112 @findex defun
|
|
3113 @cindex Special form of @code{defun}
|
|
3114
|
|
3115 @cindex @samp{function definition} defined
|
|
3116 In Lisp, a symbol such as @code{mark-whole-buffer} has code attached to
|
|
3117 it that tells the computer what to do when the function is called.
|
|
3118 This code is called the @dfn{function definition} and is created by
|
|
3119 evaluating a Lisp expression that starts with the symbol @code{defun}
|
|
3120 (which is an abbreviation for @emph{define function}). Because
|
|
3121 @code{defun} does not evaluate its arguments in the usual way, it is
|
|
3122 called a @dfn{special form}.
|
|
3123
|
|
3124 In subsequent sections, we will look at function definitions from the
|
|
3125 Emacs source code, such as @code{mark-whole-buffer}. In this section,
|
|
3126 we will describe a simple function definition so you can see how it
|
|
3127 looks. This function definition uses arithmetic because it makes for a
|
|
3128 simple example. Some people dislike examples using arithmetic; however,
|
|
3129 if you are such a person, do not despair. Hardly any of the code we
|
|
3130 will study in the remainder of this introduction involves arithmetic or
|
|
3131 mathematics. The examples mostly involve text in one way or another.
|
|
3132
|
|
3133 A function definition has up to five parts following the word
|
|
3134 @code{defun}:
|
|
3135
|
|
3136 @enumerate
|
|
3137 @item
|
|
3138 The name of the symbol to which the function definition should be
|
|
3139 attached.
|
|
3140
|
|
3141 @item
|
|
3142 A list of the arguments that will be passed to the function. If no
|
|
3143 arguments will be passed to the function, this is an empty list,
|
|
3144 @code{()}.
|
|
3145
|
|
3146 @item
|
|
3147 Documentation describing the function. (Technically optional, but
|
|
3148 strongly recommended.)
|
|
3149
|
|
3150 @item
|
|
3151 Optionally, an expression to make the function interactive so you can
|
|
3152 use it by typing @kbd{M-x} and then the name of the function; or by
|
|
3153 typing an appropriate key or keychord.
|
|
3154
|
|
3155 @cindex @samp{body} defined
|
|
3156 @item
|
|
3157 The code that instructs the computer what to do: the @dfn{body} of the
|
|
3158 function definition.
|
|
3159 @end enumerate
|
|
3160
|
|
3161 It is helpful to think of the five parts of a function definition as
|
|
3162 being organized in a template, with slots for each part:
|
|
3163
|
|
3164 @smallexample
|
|
3165 @group
|
|
3166 (defun @var{function-name} (@var{arguments}@dots{})
|
|
3167 "@var{optional-documentation}@dots{}"
|
|
3168 (interactive @var{argument-passing-info}) ; @r{optional}
|
|
3169 @var{body}@dots{})
|
|
3170 @end group
|
|
3171 @end smallexample
|
|
3172
|
|
3173 As an example, here is the code for a function that multiplies its
|
|
3174 argument by 7. (This example is not interactive. @xref{Interactive,
|
|
3175 , Making a Function Interactive}, for that information.)
|
|
3176
|
|
3177 @smallexample
|
|
3178 @group
|
|
3179 (defun multiply-by-seven (number)
|
|
3180 "Multiply NUMBER by seven."
|
|
3181 (* 7 number))
|
|
3182 @end group
|
|
3183 @end smallexample
|
|
3184
|
|
3185 This definition begins with a parenthesis and the symbol @code{defun},
|
|
3186 followed by the name of the function.
|
|
3187
|
|
3188 @cindex @samp{argument list} defined
|
|
3189 The name of the function is followed by a list that contains the
|
|
3190 arguments that will be passed to the function. This list is called
|
|
3191 the @dfn{argument list}. In this example, the list has only one
|
|
3192 element, the symbol, @code{number}. When the function is used, the
|
|
3193 symbol will be bound to the value that is used as the argument to the
|
|
3194 function.
|
|
3195
|
|
3196 Instead of choosing the word @code{number} for the name of the argument,
|
|
3197 I could have picked any other name. For example, I could have chosen
|
|
3198 the word @code{multiplicand}. I picked the word `number' because it
|
|
3199 tells what kind of value is intended for this slot; but I could just as
|
|
3200 well have chosen the word `multiplicand' to indicate the role that the
|
|
3201 value placed in this slot will play in the workings of the function. I
|
|
3202 could have called it @code{foogle}, but that would have been a bad
|
|
3203 choice because it would not tell humans what it means. The choice of
|
|
3204 name is up to the programmer and should be chosen to make the meaning of
|
|
3205 the function clear.
|
|
3206
|
|
3207 Indeed, you can choose any name you wish for a symbol in an argument
|
|
3208 list, even the name of a symbol used in some other function: the name
|
|
3209 you use in an argument list is private to that particular definition.
|
|
3210 In that definition, the name refers to a different entity than any use
|
|
3211 of the same name outside the function definition. Suppose you have a
|
|
3212 nick-name `Shorty' in your family; when your family members refer to
|
|
3213 `Shorty', they mean you. But outside your family, in a movie, for
|
|
3214 example, the name `Shorty' refers to someone else. Because a name in an
|
|
3215 argument list is private to the function definition, you can change the
|
|
3216 value of such a symbol inside the body of a function without changing
|
|
3217 its value outside the function. The effect is similar to that produced
|
|
3218 by a @code{let} expression. (@xref{let, , @code{let}}.)
|
|
3219
|
|
3220 @ignore
|
|
3221 Note also that we discuss the word `number' in two different ways: as a
|
|
3222 symbol that appears in the code, and as the name of something that will
|
|
3223 be replaced by a something else during the evaluation of the function.
|
|
3224 In the first case, @code{number} is a symbol, not a number; it happens
|
|
3225 that within the function, it is a variable who value is the number in
|
|
3226 question, but our primary interest in it is as a symbol. On the other
|
|
3227 hand, when we are talking about the function, our interest is that we
|
|
3228 will substitute a number for the word @var{number}. To keep this
|
|
3229 distinction clear, we use different typography for the two
|
|
3230 circumstances. When we talk about this function, or about how it works,
|
|
3231 we refer to this number by writing @var{number}. In the function
|
|
3232 itself, we refer to it by writing @code{number}.
|
|
3233 @end ignore
|
|
3234
|
|
3235 The argument list is followed by the documentation string that
|
|
3236 describes the function. This is what you see when you type
|
|
3237 @w{@kbd{C-h f}} and the name of a function. Incidentally, when you
|
|
3238 write a documentation string like this, you should make the first line
|
|
3239 a complete sentence since some commands, such as @code{apropos}, print
|
|
3240 only the first line of a multi-line documentation string. Also, you
|
|
3241 should not indent the second line of a documentation string, if you
|
|
3242 have one, because that looks odd when you use @kbd{C-h f}
|
|
3243 (@code{describe-function}). The documentation string is optional, but
|
|
3244 it is so useful, it should be included in almost every function you
|
|
3245 write.
|
|
3246
|
|
3247 @findex * @r{(multiplication)}
|
|
3248 The third line of the example consists of the body of the function
|
|
3249 definition. (Most functions' definitions, of course, are longer than
|
|
3250 this.) In this function, the body is the list, @code{(* 7 number)}, which
|
|
3251 says to multiply the value of @var{number} by 7. (In Emacs Lisp,
|
|
3252 @code{*} is the function for multiplication, just as @code{+} is the
|
|
3253 function for addition.)
|
|
3254
|
|
3255 When you use the @code{multiply-by-seven} function, the argument
|
|
3256 @code{number} evaluates to the actual number you want used. Here is an
|
|
3257 example that shows how @code{multiply-by-seven} is used; but don't try
|
|
3258 to evaluate this yet!
|
|
3259
|
|
3260 @smallexample
|
|
3261 (multiply-by-seven 3)
|
|
3262 @end smallexample
|
|
3263
|
|
3264 @noindent
|
|
3265 The symbol @code{number}, specified in the function definition in the
|
|
3266 next section, is given or ``bound to'' the value 3 in the actual use of
|
|
3267 the function. Note that although @code{number} was inside parentheses
|
|
3268 in the function definition, the argument passed to the
|
|
3269 @code{multiply-by-seven} function is not in parentheses. The
|
|
3270 parentheses are written in the function definition so the computer can
|
|
3271 figure out where the argument list ends and the rest of the function
|
|
3272 definition begins.
|
|
3273
|
|
3274 If you evaluate this example, you are likely to get an error message.
|
|
3275 (Go ahead, try it!) This is because we have written the function
|
|
3276 definition, but not yet told the computer about the definition---we have
|
|
3277 not yet installed (or `loaded') the function definition in Emacs.
|
|
3278 Installing a function is the process that tells the Lisp interpreter the
|
|
3279 definition of the function. Installation is described in the next
|
|
3280 section.
|
|
3281
|
|
3282 @node Install, Interactive, defun, Writing Defuns
|
|
3283 @comment node-name, next, previous, up
|
|
3284 @section Install a Function Definition
|
|
3285 @cindex Install a Function Definition
|
|
3286 @cindex Definition installation
|
|
3287 @cindex Function definition installation
|
|
3288
|
|
3289 If you are reading this inside of Info in Emacs, you can try out the
|
|
3290 @code{multiply-by-seven} function by first evaluating the function
|
|
3291 definition and then evaluating @code{(multiply-by-seven 3)}. A copy of
|
|
3292 the function definition follows. Place the cursor after the last
|
|
3293 parenthesis of the function definition and type @kbd{C-x C-e}. When you
|
|
3294 do this, @code{multiply-by-seven} will appear in the echo area. (What
|
|
3295 this means is that when a function definition is evaluated, the value it
|
|
3296 returns is the name of the defined function.) At the same time, this
|
|
3297 action installs the function definition.
|
|
3298
|
|
3299 @smallexample
|
|
3300 @group
|
|
3301 (defun multiply-by-seven (number)
|
|
3302 "Multiply NUMBER by seven."
|
|
3303 (* 7 number))
|
|
3304 @end group
|
|
3305 @end smallexample
|
|
3306
|
|
3307 @noindent
|
|
3308 By evaluating this @code{defun}, you have just installed
|
|
3309 @code{multiply-by-seven} in Emacs. The function is now just as much a
|
|
3310 part of Emacs as @code{forward-word} or any other editing function you
|
|
3311 use. (@code{multiply-by-seven} will stay installed until you quit
|
|
3312 Emacs. To reload code automatically whenever you start Emacs, see
|
|
3313 @ref{Permanent Installation, , Installing Code Permanently}.)
|
|
3314
|
|
3315 @menu
|
|
3316 * Effect of installation::
|
|
3317 * Change a defun:: How to change a function definition.
|
|
3318 @end menu
|
|
3319
|
|
3320 @node Effect of installation, Change a defun, Install, Install
|
|
3321 @ifnottex
|
|
3322 @unnumberedsubsec The effect of installation
|
|
3323 @end ifnottex
|
|
3324
|
|
3325 You can see the effect of installing @code{multiply-by-seven} by
|
|
3326 evaluating the following sample. Place the cursor after the following
|
|
3327 expression and type @kbd{C-x C-e}. The number 21 will appear in the
|
|
3328 echo area.
|
|
3329
|
|
3330 @smallexample
|
|
3331 (multiply-by-seven 3)
|
|
3332 @end smallexample
|
|
3333
|
|
3334 If you wish, you can read the documentation for the function by typing
|
|
3335 @kbd{C-h f} (@code{describe-function}) and then the name of the
|
|
3336 function, @code{multiply-by-seven}. When you do this, a
|
|
3337 @file{*Help*} window will appear on your screen that says:
|
|
3338
|
|
3339 @smallexample
|
|
3340 @group
|
|
3341 multiply-by-seven is a Lisp function.
|
|
3342 (multiply-by-seven NUMBER)
|
|
3343
|
|
3344 Multiply NUMBER by seven.
|
|
3345 @end group
|
|
3346 @end smallexample
|
|
3347
|
|
3348 @noindent
|
|
3349 (To return to a single window on your screen, type @kbd{C-x 1}.)
|
|
3350
|
|
3351 @node Change a defun, , Effect of installation, Install
|
|
3352 @comment node-name, next, previous, up
|
|
3353 @subsection Change a Function Definition
|
|
3354 @cindex Changing a function definition
|
|
3355 @cindex Function definition, how to change
|
|
3356 @cindex Definition, how to change
|
|
3357
|
|
3358 If you want to change the code in @code{multiply-by-seven}, just rewrite
|
|
3359 it. To install the new version in place of the old one, evaluate the
|
|
3360 function definition again. This is how you modify code in Emacs. It is
|
|
3361 very simple.
|
|
3362
|
|
3363 As an example, you can change the @code{multiply-by-seven} function to
|
|
3364 add the number to itself seven times instead of multiplying the number
|
|
3365 by seven. It produces the same answer, but by a different path. At
|
|
3366 the same time, we will add a comment to the code; a comment is text
|
|
3367 that the Lisp interpreter ignores, but that a human reader may find
|
|
3368 useful or enlightening. The comment is that this is the ``second
|
|
3369 version''.
|
|
3370
|
|
3371 @smallexample
|
|
3372 @group
|
|
3373 (defun multiply-by-seven (number) ; @r{Second version.}
|
|
3374 "Multiply NUMBER by seven."
|
|
3375 (+ number number number number number number number))
|
|
3376 @end group
|
|
3377 @end smallexample
|
|
3378
|
|
3379 @cindex Comments in Lisp code
|
|
3380 The comment follows a semicolon, @samp{;}. In Lisp, everything on a
|
|
3381 line that follows a semicolon is a comment. The end of the line is the
|
|
3382 end of the comment. To stretch a comment over two or more lines, begin
|
|
3383 each line with a semicolon.
|
|
3384
|
|
3385 @xref{Beginning a .emacs File, , Beginning a @file{.emacs}
|
|
3386 File}, and @ref{Comments, , Comments, elisp, The GNU Emacs Lisp
|
|
3387 Reference Manual}, for more about comments.
|
|
3388
|
|
3389 You can install this version of the @code{multiply-by-seven} function by
|
|
3390 evaluating it in the same way you evaluated the first function: place
|
|
3391 the cursor after the last parenthesis and type @kbd{C-x C-e}.
|
|
3392
|
|
3393 In summary, this is how you write code in Emacs Lisp: you write a
|
|
3394 function; install it; test it; and then make fixes or enhancements and
|
|
3395 install it again.
|
|
3396
|
|
3397 @node Interactive, Interactive Options, Install, Writing Defuns
|
|
3398 @comment node-name, next, previous, up
|
|
3399 @section Make a Function Interactive
|
|
3400 @cindex Interactive functions
|
|
3401 @findex interactive
|
|
3402
|
|
3403 You make a function interactive by placing a list that begins with
|
|
3404 the special form @code{interactive} immediately after the
|
|
3405 documentation. A user can invoke an interactive function by typing
|
|
3406 @kbd{M-x} and then the name of the function; or by typing the keys to
|
|
3407 which it is bound, for example, by typing @kbd{C-n} for
|
|
3408 @code{next-line} or @kbd{C-x h} for @code{mark-whole-buffer}.
|
|
3409
|
|
3410 Interestingly, when you call an interactive function interactively,
|
|
3411 the value returned is not automatically displayed in the echo area.
|
|
3412 This is because you often call an interactive function for its side
|
|
3413 effects, such as moving forward by a word or line, and not for the
|
|
3414 value returned. If the returned value were displayed in the echo area
|
|
3415 each time you typed a key, it would be very distracting.
|
|
3416
|
|
3417 @menu
|
|
3418 * Interactive multiply-by-seven:: An overview.
|
|
3419 * multiply-by-seven in detail:: The interactive version.
|
|
3420 @end menu
|
|
3421
|
|
3422 @node Interactive multiply-by-seven, multiply-by-seven in detail, Interactive, Interactive
|
|
3423 @ifnottex
|
|
3424 @unnumberedsubsec An Interactive @code{multiply-by-seven}, An Overview
|
|
3425 @end ifnottex
|
|
3426
|
|
3427 Both the use of the special form @code{interactive} and one way to
|
|
3428 display a value in the echo area can be illustrated by creating an
|
|
3429 interactive version of @code{multiply-by-seven}.
|
|
3430
|
|
3431 @need 1250
|
|
3432 Here is the code:
|
|
3433
|
|
3434 @smallexample
|
|
3435 @group
|
|
3436 (defun multiply-by-seven (number) ; @r{Interactive version.}
|
|
3437 "Multiply NUMBER by seven."
|
|
3438 (interactive "p")
|
|
3439 (message "The result is %d" (* 7 number)))
|
|
3440 @end group
|
|
3441 @end smallexample
|
|
3442
|
|
3443 @noindent
|
|
3444 You can install this code by placing your cursor after it and typing
|
|
3445 @kbd{C-x C-e}. The name of the function will appear in your echo area.
|
|
3446 Then, you can use this code by typing @kbd{C-u} and a number and then
|
|
3447 typing @kbd{M-x multiply-by-seven} and pressing @key{RET}. The phrase
|
|
3448 @samp{The result is @dots{}} followed by the product will appear in the
|
|
3449 echo area.
|
|
3450
|
|
3451 Speaking more generally, you invoke a function like this in either of two
|
|
3452 ways:
|
|
3453
|
|
3454 @enumerate
|
|
3455 @item
|
|
3456 By typing a prefix argument that contains the number to be passed, and
|
|
3457 then typing @kbd{M-x} and the name of the function, as with
|
|
3458 @kbd{C-u 3 M-x forward-sentence}; or,
|
|
3459
|
|
3460 @item
|
|
3461 By typing whatever key or keychord the function is bound to, as with
|
|
3462 @kbd{C-u 3 M-e}.
|
|
3463 @end enumerate
|
|
3464
|
|
3465 @noindent
|
|
3466 Both the examples just mentioned work identically to move point forward
|
|
3467 three sentences. (Since @code{multiply-by-seven} is not bound to a key,
|
|
3468 it could not be used as an example of key binding.)
|
|
3469
|
|
3470 (@xref{Keybindings, , Some Keybindings}, to learn how to bind a command
|
|
3471 to a key.)
|
|
3472
|
|
3473 A prefix argument is passed to an interactive function by typing the
|
|
3474 @key{META} key followed by a number, for example, @kbd{M-3 M-e}, or by
|
|
3475 typing @kbd{C-u} and then a number, for example, @kbd{C-u 3 M-e} (if you
|
|
3476 type @kbd{C-u} without a number, it defaults to 4).
|
|
3477
|
|
3478 @node multiply-by-seven in detail, , Interactive multiply-by-seven, Interactive
|
|
3479 @comment node-name, next, previous, up
|
|
3480 @subsection An Interactive @code{multiply-by-seven}
|
|
3481
|
|
3482 Let's look at the use of the special form @code{interactive} and then at
|
|
3483 the function @code{message} in the interactive version of
|
|
3484 @code{multiply-by-seven}. You will recall that the function definition
|
|
3485 looks like this:
|
|
3486
|
|
3487 @smallexample
|
|
3488 @group
|
|
3489 (defun multiply-by-seven (number) ; @r{Interactive version.}
|
|
3490 "Multiply NUMBER by seven."
|
|
3491 (interactive "p")
|
|
3492 (message "The result is %d" (* 7 number)))
|
|
3493 @end group
|
|
3494 @end smallexample
|
|
3495
|
|
3496 In this function, the expression, @code{(interactive "p")}, is a list of
|
|
3497 two elements. The @code{"p"} tells Emacs to pass the prefix argument to
|
|
3498 the function and use its value for the argument of the function.
|
|
3499
|
|
3500 @need 1000
|
|
3501 The argument will be a number. This means that the symbol
|
|
3502 @code{number} will be bound to a number in the line:
|
|
3503
|
|
3504 @smallexample
|
|
3505 (message "The result is %d" (* 7 number))
|
|
3506 @end smallexample
|
|
3507
|
|
3508 @need 1250
|
|
3509 @noindent
|
|
3510 For example, if your prefix argument is 5, the Lisp interpreter will
|
|
3511 evaluate the line as if it were:
|
|
3512
|
|
3513 @smallexample
|
|
3514 (message "The result is %d" (* 7 5))
|
|
3515 @end smallexample
|
|
3516
|
|
3517 @noindent
|
|
3518 (If you are reading this in GNU Emacs, you can evaluate this expression
|
|
3519 yourself.) First, the interpreter will evaluate the inner list, which
|
|
3520 is @code{(* 7 5)}. This returns a value of 35. Next, it
|
|
3521 will evaluate the outer list, passing the values of the second and
|
|
3522 subsequent elements of the list to the function @code{message}.
|
|
3523
|
|
3524 As we have seen, @code{message} is an Emacs Lisp function especially
|
|
3525 designed for sending a one line message to a user. (@xref{message, ,
|
|
3526 The @code{message} function}.) In summary, the @code{message}
|
|
3527 function prints its first argument in the echo area as is, except for
|
|
3528 occurrences of @samp{%d} or @samp{%s} (and various other %-sequences
|
|
3529 which we have not mentioned). When it sees a control sequence, the
|
|
3530 function looks to the second or subsequent arguments and prints the
|
|
3531 value of the argument in the location in the string where the control
|
|
3532 sequence is located.
|
|
3533
|
|
3534 In the interactive @code{multiply-by-seven} function, the control string
|
|
3535 is @samp{%d}, which requires a number, and the value returned by
|
|
3536 evaluating @code{(* 7 5)} is the number 35. Consequently, the number 35
|
|
3537 is printed in place of the @samp{%d} and the message is @samp{The result
|
|
3538 is 35}.
|
|
3539
|
|
3540 (Note that when you call the function @code{multiply-by-seven}, the
|
|
3541 message is printed without quotes, but when you call @code{message}, the
|
|
3542 text is printed in double quotes. This is because the value returned by
|
|
3543 @code{message} is what appears in the echo area when you evaluate an
|
|
3544 expression whose first element is @code{message}; but when embedded in a
|
|
3545 function, @code{message} prints the text as a side effect without
|
|
3546 quotes.)
|
|
3547
|
|
3548 @node Interactive Options, Permanent Installation, Interactive, Writing Defuns
|
|
3549 @comment node-name, next, previous, up
|
|
3550 @section Different Options for @code{interactive}
|
|
3551 @cindex Options for @code{interactive}
|
|
3552 @cindex Interactive options
|
|
3553
|
|
3554 In the example, @code{multiply-by-seven} used @code{"p"} as the
|
|
3555 argument to @code{interactive}. This argument told Emacs to interpret
|
|
3556 your typing either @kbd{C-u} followed by a number or @key{META}
|
|
3557 followed by a number as a command to pass that number to the function
|
|
3558 as its argument. Emacs has more than twenty characters predefined for
|
|
3559 use with @code{interactive}. In almost every case, one of these
|
|
3560 options will enable you to pass the right information interactively to
|
|
3561 a function. (@xref{Interactive Codes, , Code Characters for
|
|
3562 @code{interactive}, elisp, The GNU Emacs Lisp Reference Manual}.)
|
|
3563
|
|
3564 @need 1250
|
|
3565 Consider the function @code{zap-to-char}. Its interactive expression
|
|
3566 is
|
|
3567
|
|
3568 @smallexample
|
|
3569 (interactive "p\ncZap to char: ")
|
|
3570 @end smallexample
|
|
3571
|
|
3572 The first part of the argument to @code{interactive} is @samp{p}, with
|
|
3573 which you are already familiar. This argument tells Emacs to
|
|
3574 interpret a `prefix', as a number to be passed to the function. You
|
|
3575 can specify a prefix either by typing @kbd{C-u} followed by a number
|
|
3576 or by typing @key{META} followed by a number. The prefix is the
|
|
3577 number of specified characters. Thus, if your prefix is three and the
|
|
3578 specified character is @samp{x}, then you will delete all the text up
|
|
3579 to and including the third next @samp{x}. If you do not set a prefix,
|
|
3580 then you delete all the text up to and including the specified
|
|
3581 character, but no more.
|
|
3582
|
|
3583 The @samp{c} tells the function the name of the character to which to delete.
|
|
3584
|
|
3585 More formally, a function with two or more arguments can have
|
|
3586 information passed to each argument by adding parts to the string that
|
|
3587 follows @code{interactive}. When you do this, the information is
|
|
3588 passed to each argument in the same order it is specified in the
|
|
3589 @code{interactive} list. In the string, each part is separated from
|
|
3590 the next part by a @samp{\n}, which is a newline. For example, you
|
|
3591 can follow @samp{p} with a @samp{\n} and an @samp{cZap to char:@: }.
|
|
3592 This causes Emacs to pass the value of the prefix argument (if there
|
|
3593 is one) and the character.
|
|
3594
|
|
3595 In this case, the function definition looks like the following, where
|
|
3596 @code{arg} and @code{char} are the symbols to which @code{interactive}
|
|
3597 binds the prefix argument and the specified character:
|
|
3598
|
|
3599 @smallexample
|
|
3600 @group
|
|
3601 (defun @var{name-of-function} (arg char)
|
|
3602 "@var{documentation}@dots{}"
|
|
3603 (interactive "p\ncZap to char: ")
|
|
3604 @var{body-of-function}@dots{})
|
|
3605 @end group
|
|
3606 @end smallexample
|
|
3607
|
|
3608 @noindent
|
|
3609 (The space after the colon in the prompt makes it look better when you
|
|
3610 are prompted. @xref{copy-to-buffer, , The Definition of
|
|
3611 @code{copy-to-buffer}}, for an example.)
|
|
3612
|
|
3613 When a function does not take arguments, @code{interactive} does not
|
|
3614 require any. Such a function contains the simple expression
|
|
3615 @code{(interactive)}. The @code{mark-whole-buffer} function is like
|
|
3616 this.
|
|
3617
|
|
3618 Alternatively, if the special letter-codes are not right for your
|
|
3619 application, you can pass your own arguments to @code{interactive} as
|
|
3620 a list.
|
|
3621
|
|
3622 @xref{append-to-buffer, , The Definition of @code{append-to-buffer}},
|
|
3623 for an example. @xref{Using Interactive, , Using @code{Interactive},
|
|
3624 elisp, The GNU Emacs Lisp Reference Manual}, for a more complete
|
|
3625 explanation about this technique.
|
|
3626
|
|
3627 @node Permanent Installation, let, Interactive Options, Writing Defuns
|
|
3628 @comment node-name, next, previous, up
|
|
3629 @section Install Code Permanently
|
|
3630 @cindex Install code permanently
|
|
3631 @cindex Permanent code installation
|
|
3632 @cindex Code installation
|
|
3633
|
|
3634 When you install a function definition by evaluating it, it will stay
|
|
3635 installed until you quit Emacs. The next time you start a new session
|
|
3636 of Emacs, the function will not be installed unless you evaluate the
|
|
3637 function definition again.
|
|
3638
|
|
3639 At some point, you may want to have code installed automatically
|
|
3640 whenever you start a new session of Emacs. There are several ways of
|
|
3641 doing this:
|
|
3642
|
|
3643 @itemize @bullet
|
|
3644 @item
|
|
3645 If you have code that is just for yourself, you can put the code for the
|
|
3646 function definition in your @file{.emacs} initialization file. When you
|
|
3647 start Emacs, your @file{.emacs} file is automatically evaluated and all
|
|
3648 the function definitions within it are installed.
|
|
3649 @xref{Emacs Initialization, , Your @file{.emacs} File}.
|
|
3650
|
|
3651 @item
|
|
3652 Alternatively, you can put the function definitions that you want
|
|
3653 installed in one or more files of their own and use the @code{load}
|
|
3654 function to cause Emacs to evaluate and thereby install each of the
|
|
3655 functions in the files.
|
|
3656 @xref{Loading Files, , Loading Files}.
|
|
3657
|
|
3658 @item
|
|
3659 Thirdly, if you have code that your whole site will use, it is usual
|
|
3660 to put it in a file called @file{site-init.el} that is loaded when
|
|
3661 Emacs is built. This makes the code available to everyone who uses
|
|
3662 your machine. (See the @file{INSTALL} file that is part of the Emacs
|
|
3663 distribution.)
|
|
3664 @end itemize
|
|
3665
|
|
3666 Finally, if you have code that everyone who uses Emacs may want, you
|
|
3667 can post it on a computer network or send a copy to the Free Software
|
|
3668 Foundation. (When you do this, please license the code and its
|
|
3669 documentation under a license that permits other people to run, copy,
|
|
3670 study, modify, and redistribute the code and which protects you from
|
|
3671 having your work taken from you.) If you send a copy of your code to
|
|
3672 the Free Software Foundation, and properly protect yourself and
|
|
3673 others, it may be included in the next release of Emacs. In large
|
|
3674 part, this is how Emacs has grown over the past years, by donations.
|
|
3675
|
|
3676 @node let, if, Permanent Installation, Writing Defuns
|
|
3677 @comment node-name, next, previous, up
|
|
3678 @section @code{let}
|
|
3679 @findex let
|
|
3680
|
|
3681 The @code{let} expression is a special form in Lisp that you will need
|
|
3682 to use in most function definitions.
|
|
3683
|
|
3684 @code{let} is used to attach or bind a symbol to a value in such a way
|
|
3685 that the Lisp interpreter will not confuse the variable with a
|
|
3686 variable of the same name that is not part of the function.
|
|
3687
|
|
3688 To understand why the @code{let} special form is necessary, consider
|
|
3689 the situation in which you own a home that you generally refer to as
|
|
3690 `the house', as in the sentence, ``The house needs painting.'' If you
|
|
3691 are visiting a friend and your host refers to `the house', he is
|
|
3692 likely to be referring to @emph{his} house, not yours, that is, to a
|
|
3693 different house.
|
|
3694
|
|
3695 If your friend is referring to his house and you think he is referring
|
|
3696 to your house, you may be in for some confusion. The same thing could
|
|
3697 happen in Lisp if a variable that is used inside of one function has
|
|
3698 the same name as a variable that is used inside of another function,
|
|
3699 and the two are not intended to refer to the same value. The
|
|
3700 @code{let} special form prevents this kind of confusion.
|
|
3701
|
|
3702 @menu
|
|
3703 * Prevent confusion::
|
|
3704 * Parts of let Expression::
|
|
3705 * Sample let Expression::
|
|
3706 * Uninitialized let Variables::
|
|
3707 @end menu
|
|
3708
|
|
3709 @node Prevent confusion, Parts of let Expression, let, let
|
|
3710 @ifnottex
|
|
3711 @unnumberedsubsec @code{let} Prevents Confusion
|
|
3712 @end ifnottex
|
|
3713
|
|
3714 @cindex @samp{local variable} defined
|
|
3715 @cindex @samp{variable, local}, defined
|
|
3716 The @code{let} special form prevents confusion. @code{let} creates a
|
|
3717 name for a @dfn{local variable} that overshadows any use of the same
|
|
3718 name outside the @code{let} expression. This is like understanding
|
|
3719 that whenever your host refers to `the house', he means his house, not
|
|
3720 yours. (Symbols used in argument lists work the same way.
|
|
3721 @xref{defun, , The @code{defun} Special Form}.)
|
|
3722
|
|
3723 Local variables created by a @code{let} expression retain their value
|
|
3724 @emph{only} within the @code{let} expression itself (and within
|
|
3725 expressions called within the @code{let} expression); the local
|
|
3726 variables have no effect outside the @code{let} expression.
|
|
3727
|
|
3728 Another way to think about @code{let} is that it is like a @code{setq}
|
|
3729 that is temporary and local. The values set by @code{let} are
|
|
3730 automatically undone when the @code{let} is finished. The setting
|
|
3731 only affects expressions that are inside the bounds of the @code{let}
|
|
3732 expression. In computer science jargon, we would say ``the binding of
|
|
3733 a symbol is visible only in functions called in the @code{let} form;
|
|
3734 in Emacs Lisp, scoping is dynamic, not lexical.''
|
|
3735
|
|
3736 @code{let} can create more than one variable at once. Also,
|
|
3737 @code{let} gives each variable it creates an initial value, either a
|
|
3738 value specified by you, or @code{nil}. (In the jargon, this is called
|
|
3739 `binding the variable to the value'.) After @code{let} has created
|
|
3740 and bound the variables, it executes the code in the body of the
|
|
3741 @code{let}, and returns the value of the last expression in the body,
|
|
3742 as the value of the whole @code{let} expression. (`Execute' is a jargon
|
|
3743 term that means to evaluate a list; it comes from the use of the word
|
|
3744 meaning `to give practical effect to' (@cite{Oxford English
|
|
3745 Dictionary}). Since you evaluate an expression to perform an action,
|
|
3746 `execute' has evolved as a synonym to `evaluate'.)
|
|
3747
|
|
3748 @node Parts of let Expression, Sample let Expression, Prevent confusion, let
|
|
3749 @comment node-name, next, previous, up
|
|
3750 @subsection The Parts of a @code{let} Expression
|
|
3751 @cindex @code{let} expression, parts of
|
|
3752 @cindex Parts of @code{let} expression
|
|
3753
|
|
3754 @cindex @samp{varlist} defined
|
|
3755 A @code{let} expression is a list of three parts. The first part is
|
|
3756 the symbol @code{let}. The second part is a list, called a
|
|
3757 @dfn{varlist}, each element of which is either a symbol by itself or a
|
|
3758 two-element list, the first element of which is a symbol. The third
|
|
3759 part of the @code{let} expression is the body of the @code{let}. The
|
|
3760 body usually consists of one or more lists.
|
|
3761
|
|
3762 @need 800
|
|
3763 A template for a @code{let} expression looks like this:
|
|
3764
|
|
3765 @smallexample
|
|
3766 (let @var{varlist} @var{body}@dots{})
|
|
3767 @end smallexample
|
|
3768
|
|
3769 @noindent
|
|
3770 The symbols in the varlist are the variables that are given initial
|
|
3771 values by the @code{let} special form. Symbols by themselves are given
|
|
3772 the initial value of @code{nil}; and each symbol that is the first
|
|
3773 element of a two-element list is bound to the value that is returned
|
|
3774 when the Lisp interpreter evaluates the second element.
|
|
3775
|
|
3776 Thus, a varlist might look like this: @code{(thread (needles 3))}. In
|
|
3777 this case, in a @code{let} expression, Emacs binds the symbol
|
|
3778 @code{thread} to an initial value of @code{nil}, and binds the symbol
|
|
3779 @code{needles} to an initial value of 3.
|
|
3780
|
|
3781 When you write a @code{let} expression, what you do is put the
|
|
3782 appropriate expressions in the slots of the @code{let} expression
|
|
3783 template.
|
|
3784
|
|
3785 If the varlist is composed of two-element lists, as is often the case,
|
|
3786 the template for the @code{let} expression looks like this:
|
|
3787
|
|
3788 @smallexample
|
|
3789 @group
|
|
3790 (let ((@var{variable} @var{value})
|
|
3791 (@var{variable} @var{value})
|
|
3792 @dots{})
|
|
3793 @var{body}@dots{})
|
|
3794 @end group
|
|
3795 @end smallexample
|
|
3796
|
|
3797 @node Sample let Expression, Uninitialized let Variables, Parts of let Expression, let
|
|
3798 @comment node-name, next, previous, up
|
|
3799 @subsection Sample @code{let} Expression
|
|
3800 @cindex Sample @code{let} expression
|
|
3801 @cindex @code{let} expression sample
|
|
3802
|
|
3803 The following expression creates and gives initial values
|
|
3804 to the two variables @code{zebra} and @code{tiger}. The body of the
|
|
3805 @code{let} expression is a list which calls the @code{message} function.
|
|
3806
|
|
3807 @smallexample
|
|
3808 @group
|
|
3809 (let ((zebra 'stripes)
|
|
3810 (tiger 'fierce))
|
|
3811 (message "One kind of animal has %s and another is %s."
|
|
3812 zebra tiger))
|
|
3813 @end group
|
|
3814 @end smallexample
|
|
3815
|
|
3816 Here, the varlist is @code{((zebra 'stripes) (tiger 'fierce))}.
|
|
3817
|
|
3818 The two variables are @code{zebra} and @code{tiger}. Each variable is
|
|
3819 the first element of a two-element list and each value is the second
|
|
3820 element of its two-element list. In the varlist, Emacs binds the
|
|
3821 variable @code{zebra} to the value @code{stripes}@footnote{According
|
|
3822 to Jared Diamond in @cite{Guns, Germs, and Steel}, ``@dots{} zebras
|
|
3823 become impossibly dangerous as they grow older'' but the claim here is
|
|
3824 that they do not become fierce like a tiger. (1997, W. W. Norton and
|
|
3825 Co., ISBN 0-393-03894-2, page 171)}, and binds the
|
|
3826 variable @code{tiger} to the value @code{fierce}. In this example,
|
|
3827 both values are symbols preceded by a quote. The values could just as
|
|
3828 well have been another list or a string. The body of the @code{let}
|
|
3829 follows after the list holding the variables. In this example, the
|
|
3830 body is a list that uses the @code{message} function to print a string
|
|
3831 in the echo area.
|
|
3832
|
|
3833 @need 1500
|
|
3834 You may evaluate the example in the usual fashion, by placing the
|
|
3835 cursor after the last parenthesis and typing @kbd{C-x C-e}. When you do
|
|
3836 this, the following will appear in the echo area:
|
|
3837
|
|
3838 @smallexample
|
|
3839 "One kind of animal has stripes and another is fierce."
|
|
3840 @end smallexample
|
|
3841
|
|
3842 As we have seen before, the @code{message} function prints its first
|
|
3843 argument, except for @samp{%s}. In this example, the value of the variable
|
|
3844 @code{zebra} is printed at the location of the first @samp{%s} and the
|
|
3845 value of the variable @code{tiger} is printed at the location of the
|
|
3846 second @samp{%s}.
|
|
3847
|
|
3848 @node Uninitialized let Variables, , Sample let Expression, let
|
|
3849 @comment node-name, next, previous, up
|
|
3850 @subsection Uninitialized Variables in a @code{let} Statement
|
|
3851 @cindex Uninitialized @code{let} variables
|
|
3852 @cindex @code{let} variables uninitialized
|
|
3853
|
|
3854 If you do not bind the variables in a @code{let} statement to specific
|
|
3855 initial values, they will automatically be bound to an initial value of
|
|
3856 @code{nil}, as in the following expression:
|
|
3857
|
|
3858 @smallexample
|
|
3859 @group
|
|
3860 (let ((birch 3)
|
|
3861 pine
|
|
3862 fir
|
|
3863 (oak 'some))
|
|
3864 (message
|
|
3865 "Here are %d variables with %s, %s, and %s value."
|
|
3866 birch pine fir oak))
|
|
3867 @end group
|
|
3868 @end smallexample
|
|
3869
|
|
3870 @noindent
|
|
3871 Here, the varlist is @code{((birch 3) pine fir (oak 'some))}.
|
|
3872
|
|
3873 @need 1250
|
|
3874 If you evaluate this expression in the usual way, the following will
|
|
3875 appear in your echo area:
|
|
3876
|
|
3877 @smallexample
|
|
3878 "Here are 3 variables with nil, nil, and some value."
|
|
3879 @end smallexample
|
|
3880
|
|
3881 @noindent
|
|
3882 In this example, Emacs binds the symbol @code{birch} to the number 3,
|
|
3883 binds the symbols @code{pine} and @code{fir} to @code{nil}, and binds
|
|
3884 the symbol @code{oak} to the value @code{some}.
|
|
3885
|
|
3886 Note that in the first part of the @code{let}, the variables @code{pine}
|
|
3887 and @code{fir} stand alone as atoms that are not surrounded by
|
|
3888 parentheses; this is because they are being bound to @code{nil}, the
|
|
3889 empty list. But @code{oak} is bound to @code{some} and so is a part of
|
|
3890 the list @code{(oak 'some)}. Similarly, @code{birch} is bound to the
|
|
3891 number 3 and so is in a list with that number. (Since a number
|
|
3892 evaluates to itself, the number does not need to be quoted. Also, the
|
|
3893 number is printed in the message using a @samp{%d} rather than a
|
|
3894 @samp{%s}.) The four variables as a group are put into a list to
|
|
3895 delimit them from the body of the @code{let}.
|
|
3896
|
|
3897 @node if, else, let, Writing Defuns
|
|
3898 @comment node-name, next, previous, up
|
|
3899 @section The @code{if} Special Form
|
|
3900 @findex if
|
|
3901 @cindex Conditional with @code{if}
|
|
3902
|
|
3903 A third special form, in addition to @code{defun} and @code{let}, is the
|
|
3904 conditional @code{if}. This form is used to instruct the computer to
|
|
3905 make decisions. You can write function definitions without using
|
|
3906 @code{if}, but it is used often enough, and is important enough, to be
|
|
3907 included here. It is used, for example, in the code for the
|
|
3908 function @code{beginning-of-buffer}.
|
|
3909
|
|
3910 The basic idea behind an @code{if}, is that ``@emph{if} a test is true,
|
|
3911 @emph{then} an expression is evaluated.'' If the test is not true, the
|
|
3912 expression is not evaluated. For example, you might make a decision
|
|
3913 such as, ``if it is warm and sunny, then go to the beach!''
|
|
3914
|
|
3915 @menu
|
|
3916 * if in more detail::
|
|
3917 * type-of-animal in detail:: An example of an @code{if} expression.
|
|
3918 @end menu
|
|
3919
|
|
3920 @node if in more detail, type-of-animal in detail, if, if
|
|
3921 @ifnottex
|
|
3922 @unnumberedsubsec @code{if} in more detail
|
|
3923 @end ifnottex
|
|
3924
|
|
3925 @cindex @samp{if-part} defined
|
|
3926 @cindex @samp{then-part} defined
|
|
3927 An @code{if} expression written in Lisp does not use the word `then';
|
|
3928 the test and the action are the second and third elements of the list
|
|
3929 whose first element is @code{if}. Nonetheless, the test part of an
|
|
3930 @code{if} expression is often called the @dfn{if-part} and the second
|
|
3931 argument is often called the @dfn{then-part}.
|
|
3932
|
|
3933 Also, when an @code{if} expression is written, the true-or-false-test
|
|
3934 is usually written on the same line as the symbol @code{if}, but the
|
|
3935 action to carry out if the test is true, the ``then-part'', is written
|
|
3936 on the second and subsequent lines. This makes the @code{if}
|
|
3937 expression easier to read.
|
|
3938
|
|
3939 @smallexample
|
|
3940 @group
|
|
3941 (if @var{true-or-false-test}
|
|
3942 @var{action-to-carry-out-if-test-is-true})
|
|
3943 @end group
|
|
3944 @end smallexample
|
|
3945
|
|
3946 @noindent
|
|
3947 The true-or-false-test will be an expression that
|
|
3948 is evaluated by the Lisp interpreter.
|
|
3949
|
|
3950 Here is an example that you can evaluate in the usual manner. The test
|
|
3951 is whether the number 5 is greater than the number 4. Since it is, the
|
|
3952 message @samp{5 is greater than 4!} will be printed.
|
|
3953
|
|
3954 @smallexample
|
|
3955 @group
|
|
3956 (if (> 5 4) ; @r{if-part}
|
|
3957 (message "5 is greater than 4!")) ; @r{then-part}
|
|
3958 @end group
|
|
3959 @end smallexample
|
|
3960
|
|
3961 @noindent
|
|
3962 (The function @code{>} tests whether its first argument is greater than
|
|
3963 its second argument and returns true if it is.)
|
|
3964 @findex > (greater than)
|
|
3965
|
|
3966 Of course, in actual use, the test in an @code{if} expression will not
|
|
3967 be fixed for all time as it is by the expression @code{(> 5 4)}.
|
|
3968 Instead, at least one of the variables used in the test will be bound to
|
|
3969 a value that is not known ahead of time. (If the value were known ahead
|
|
3970 of time, we would not need to run the test!)
|
|
3971
|
|
3972 For example, the value may be bound to an argument of a function
|
|
3973 definition. In the following function definition, the character of the
|
|
3974 animal is a value that is passed to the function. If the value bound to
|
|
3975 @code{characteristic} is @code{fierce}, then the message, @samp{It's a
|
|
3976 tiger!} will be printed; otherwise, @code{nil} will be returned.
|
|
3977
|
|
3978 @smallexample
|
|
3979 @group
|
|
3980 (defun type-of-animal (characteristic)
|
|
3981 "Print message in echo area depending on CHARACTERISTIC.
|
|
3982 If the CHARACTERISTIC is the symbol `fierce',
|
|
3983 then warn of a tiger."
|
|
3984 (if (equal characteristic 'fierce)
|
|
3985 (message "It's a tiger!")))
|
|
3986 @end group
|
|
3987 @end smallexample
|
|
3988
|
|
3989 @need 1500
|
|
3990 @noindent
|
|
3991 If you are reading this inside of GNU Emacs, you can evaluate the
|
|
3992 function definition in the usual way to install it in Emacs, and then you
|
|
3993 can evaluate the following two expressions to see the results:
|
|
3994
|
|
3995 @smallexample
|
|
3996 @group
|
|
3997 (type-of-animal 'fierce)
|
|
3998
|
|
3999 (type-of-animal 'zebra)
|
|
4000
|
|
4001 @end group
|
|
4002 @end smallexample
|
|
4003
|
|
4004 @c Following sentences rewritten to prevent overfull hbox.
|
|
4005 @noindent
|
|
4006 When you evaluate @code{(type-of-animal 'fierce)}, you will see the
|
|
4007 following message printed in the echo area: @code{"It's a tiger!"}; and
|
|
4008 when you evaluate @code{(type-of-animal 'zebra)} you will see @code{nil}
|
|
4009 printed in the echo area.
|
|
4010
|
|
4011 @node type-of-animal in detail, , if in more detail, if
|
|
4012 @comment node-name, next, previous, up
|
|
4013 @subsection The @code{type-of-animal} Function in Detail
|
|
4014
|
|
4015 Let's look at the @code{type-of-animal} function in detail.
|
|
4016
|
|
4017 The function definition for @code{type-of-animal} was written by filling
|
|
4018 the slots of two templates, one for a function definition as a whole, and
|
|
4019 a second for an @code{if} expression.
|
|
4020
|
|
4021 @need 1250
|
|
4022 The template for every function that is not interactive is:
|
|
4023
|
|
4024 @smallexample
|
|
4025 @group
|
|
4026 (defun @var{name-of-function} (@var{argument-list})
|
|
4027 "@var{documentation}@dots{}"
|
|
4028 @var{body}@dots{})
|
|
4029 @end group
|
|
4030 @end smallexample
|
|
4031
|
|
4032 @need 800
|
|
4033 The parts of the function that match this template look like this:
|
|
4034
|
|
4035 @smallexample
|
|
4036 @group
|
|
4037 (defun type-of-animal (characteristic)
|
|
4038 "Print message in echo area depending on CHARACTERISTIC.
|
|
4039 If the CHARACTERISTIC is the symbol `fierce',
|
|
4040 then warn of a tiger."
|
|
4041 @var{body: the} @code{if} @var{expression})
|
|
4042 @end group
|
|
4043 @end smallexample
|
|
4044
|
|
4045 The name of function is @code{type-of-animal}; it is passed the value
|
|
4046 of one argument. The argument list is followed by a multi-line
|
|
4047 documentation string. The documentation string is included in the
|
|
4048 example because it is a good habit to write documentation string for
|
|
4049 every function definition. The body of the function definition
|
|
4050 consists of the @code{if} expression.
|
|
4051
|
|
4052 @need 800
|
|
4053 The template for an @code{if} expression looks like this:
|
|
4054
|
|
4055 @smallexample
|
|
4056 @group
|
|
4057 (if @var{true-or-false-test}
|
|
4058 @var{action-to-carry-out-if-the-test-returns-true})
|
|
4059 @end group
|
|
4060 @end smallexample
|
|
4061
|
|
4062 @need 1250
|
|
4063 In the @code{type-of-animal} function, the code for the @code{if}
|
|
4064 looks like this:
|
|
4065
|
|
4066 @smallexample
|
|
4067 @group
|
|
4068 (if (equal characteristic 'fierce)
|
|
4069 (message "It's a tiger!")))
|
|
4070 @end group
|
|
4071 @end smallexample
|
|
4072
|
|
4073 @need 800
|
|
4074 Here, the true-or-false-test is the expression:
|
|
4075
|
|
4076 @smallexample
|
|
4077 (equal characteristic 'fierce)
|
|
4078 @end smallexample
|
|
4079
|
|
4080 @noindent
|
|
4081 In Lisp, @code{equal} is a function that determines whether its first
|
|
4082 argument is equal to its second argument. The second argument is the
|
|
4083 quoted symbol @code{'fierce} and the first argument is the value of the
|
|
4084 symbol @code{characteristic}---in other words, the argument passed to
|
|
4085 this function.
|
|
4086
|
|
4087 In the first exercise of @code{type-of-animal}, the argument
|
|
4088 @code{fierce} is passed to @code{type-of-animal}. Since @code{fierce}
|
|
4089 is equal to @code{fierce}, the expression, @code{(equal characteristic
|
|
4090 'fierce)}, returns a value of true. When this happens, the @code{if}
|
|
4091 evaluates the second argument or then-part of the @code{if}:
|
|
4092 @code{(message "It's tiger!")}.
|
|
4093
|
|
4094 On the other hand, in the second exercise of @code{type-of-animal}, the
|
|
4095 argument @code{zebra} is passed to @code{type-of-animal}. @code{zebra}
|
|
4096 is not equal to @code{fierce}, so the then-part is not evaluated and
|
|
4097 @code{nil} is returned by the @code{if} expression.
|
|
4098
|
|
4099 @node else, Truth & Falsehood, if, Writing Defuns
|
|
4100 @comment node-name, next, previous, up
|
|
4101 @section If--then--else Expressions
|
|
4102 @cindex Else
|
|
4103
|
|
4104 An @code{if} expression may have an optional third argument, called
|
|
4105 the @dfn{else-part}, for the case when the true-or-false-test returns
|
|
4106 false. When this happens, the second argument or then-part of the
|
|
4107 overall @code{if} expression is @emph{not} evaluated, but the third or
|
|
4108 else-part @emph{is} evaluated. You might think of this as the cloudy
|
|
4109 day alternative for the decision ``if it is warm and sunny, then go to
|
|
4110 the beach, else read a book!''.
|
|
4111
|
|
4112 The word ``else'' is not written in the Lisp code; the else-part of an
|
|
4113 @code{if} expression comes after the then-part. In the written Lisp, the
|
|
4114 else-part is usually written to start on a line of its own and is
|
|
4115 indented less than the then-part:
|
|
4116
|
|
4117 @smallexample
|
|
4118 @group
|
|
4119 (if @var{true-or-false-test}
|
|
4120 @var{action-to-carry-out-if-the-test-returns-true}
|
|
4121 @var{action-to-carry-out-if-the-test-returns-false})
|
|
4122 @end group
|
|
4123 @end smallexample
|
|
4124
|
|
4125 For example, the following @code{if} expression prints the message @samp{4
|
|
4126 is not greater than 5!} when you evaluate it in the usual way:
|
|
4127
|
|
4128 @smallexample
|
|
4129 @group
|
|
4130 (if (> 4 5) ; @r{if-part}
|
|
4131 (message "4 falsely greater than 5!") ; @r{then-part}
|
|
4132 (message "4 is not greater than 5!")) ; @r{else-part}
|
|
4133 @end group
|
|
4134 @end smallexample
|
|
4135
|
|
4136 @noindent
|
|
4137 Note that the different levels of indentation make it easy to
|
|
4138 distinguish the then-part from the else-part. (GNU Emacs has several
|
|
4139 commands that automatically indent @code{if} expressions correctly.
|
|
4140 @xref{Typing Lists, , GNU Emacs Helps You Type Lists}.)
|
|
4141
|
|
4142 We can extend the @code{type-of-animal} function to include an
|
|
4143 else-part by simply incorporating an additional part to the @code{if}
|
|
4144 expression.
|
|
4145
|
|
4146 @need 1500
|
|
4147 You can see the consequences of doing this if you evaluate the following
|
|
4148 version of the @code{type-of-animal} function definition to install it
|
|
4149 and then evaluate the two subsequent expressions to pass different
|
|
4150 arguments to the function.
|
|
4151
|
|
4152 @smallexample
|
|
4153 @group
|
|
4154 (defun type-of-animal (characteristic) ; @r{Second version.}
|
|
4155 "Print message in echo area depending on CHARACTERISTIC.
|
|
4156 If the CHARACTERISTIC is the symbol `fierce',
|
|
4157 then warn of a tiger;
|
|
4158 else say it's not fierce."
|
|
4159 (if (equal characteristic 'fierce)
|
|
4160 (message "It's a tiger!")
|
|
4161 (message "It's not fierce!")))
|
|
4162 @end group
|
|
4163 @end smallexample
|
|
4164 @sp 1
|
|
4165
|
|
4166 @smallexample
|
|
4167 @group
|
|
4168 (type-of-animal 'fierce)
|
|
4169
|
|
4170 (type-of-animal 'zebra)
|
|
4171
|
|
4172 @end group
|
|
4173 @end smallexample
|
|
4174
|
|
4175 @c Following sentence rewritten to prevent overfull hbox.
|
|
4176 @noindent
|
|
4177 When you evaluate @code{(type-of-animal 'fierce)}, you will see the
|
|
4178 following message printed in the echo area: @code{"It's a tiger!"}; but
|
|
4179 when you evaluate @code{(type-of-animal 'zebra)}, you will see
|
|
4180 @code{"It's not fierce!"}.
|
|
4181
|
|
4182 (Of course, if the @var{characteristic} were @code{ferocious}, the
|
|
4183 message @code{"It's not fierce!"} would be printed; and it would be
|
|
4184 misleading! When you write code, you need to take into account the
|
|
4185 possibility that some such argument will be tested by the @code{if}
|
|
4186 and write your program accordingly.)
|
|
4187
|
|
4188 @node Truth & Falsehood, save-excursion, else, Writing Defuns
|
|
4189 @comment node-name, next, previous, up
|
|
4190 @section Truth and Falsehood in Emacs Lisp
|
|
4191 @cindex Truth and falsehood in Emacs Lisp
|
|
4192 @cindex Falsehood and truth in Emacs Lisp
|
|
4193 @findex nil
|
|
4194
|
|
4195 There is an important aspect to the truth test in an @code{if}
|
|
4196 expression. So far, we have spoken of `true' and `false' as values of
|
|
4197 predicates as if they were new kinds of Emacs Lisp objects. In fact,
|
|
4198 `false' is just our old friend @code{nil}. Anything else---anything
|
|
4199 at all---is `true'.
|
|
4200
|
|
4201 The expression that tests for truth is interpreted as @dfn{true}
|
|
4202 if the result of evaluating it is a value that is not @code{nil}. In
|
|
4203 other words, the result of the test is considered true if the value
|
|
4204 returned is a number such as 47, a string such as @code{"hello"}, or a
|
|
4205 symbol (other than @code{nil}) such as @code{flowers}, or a list (so
|
|
4206 long as it is not empty), or even a buffer!
|
|
4207
|
|
4208 @menu
|
|
4209 * nil explained:: @code{nil} has two meanings.
|
|
4210 @end menu
|
|
4211
|
|
4212 @node nil explained, , Truth & Falsehood, Truth & Falsehood
|
|
4213 @ifnottex
|
|
4214 @unnumberedsubsec An explanation of @code{nil}
|
|
4215 @end ifnottex
|
|
4216
|
|
4217 Before illustrating a test for truth, we need an explanation of @code{nil}.
|
|
4218
|
|
4219 In Emacs Lisp, the symbol @code{nil} has two meanings. First, it means the
|
|
4220 empty list. Second, it means false and is the value returned when a
|
|
4221 true-or-false-test tests false. @code{nil} can be written as an empty
|
|
4222 list, @code{()}, or as @code{nil}. As far as the Lisp interpreter is
|
|
4223 concerned, @code{()} and @code{nil} are the same. Humans, however, tend
|
|
4224 to use @code{nil} for false and @code{()} for the empty list.
|
|
4225
|
|
4226 In Emacs Lisp, any value that is not @code{nil}---is not the empty
|
|
4227 list---is considered true. This means that if an evaluation returns
|
|
4228 something that is not an empty list, an @code{if} expression will test
|
|
4229 true. For example, if a number is put in the slot for the test, it
|
|
4230 will be evaluated and will return itself, since that is what numbers
|
|
4231 do when evaluated. In this conditional, the @code{if} expression will
|
|
4232 test true. The expression tests false only when @code{nil}, an empty
|
|
4233 list, is returned by evaluating the expression.
|
|
4234
|
|
4235 You can see this by evaluating the two expressions in the following examples.
|
|
4236
|
|
4237 In the first example, the number 4 is evaluated as the test in the
|
|
4238 @code{if} expression and returns itself; consequently, the then-part
|
|
4239 of the expression is evaluated and returned: @samp{true} appears in
|
|
4240 the echo area. In the second example, the @code{nil} indicates false;
|
|
4241 consequently, the else-part of the expression is evaluated and
|
|
4242 returned: @samp{false} appears in the echo area.
|
|
4243
|
|
4244 @smallexample
|
|
4245 @group
|
|
4246 (if 4
|
|
4247 'true
|
|
4248 'false)
|
|
4249 @end group
|
|
4250
|
|
4251 @group
|
|
4252 (if nil
|
|
4253 'true
|
|
4254 'false)
|
|
4255 @end group
|
|
4256 @end smallexample
|
|
4257
|
|
4258 @need 1250
|
|
4259 Incidentally, if some other useful value is not available for a test that
|
|
4260 returns true, then the Lisp interpreter will return the symbol @code{t}
|
|
4261 for true. For example, the expression @code{(> 5 4)} returns @code{t}
|
|
4262 when evaluated, as you can see by evaluating it in the usual way:
|
|
4263
|
|
4264 @smallexample
|
|
4265 (> 5 4)
|
|
4266 @end smallexample
|
|
4267
|
|
4268 @need 1250
|
|
4269 @noindent
|
|
4270 On the other hand, this function returns @code{nil} if the test is false.
|
|
4271
|
|
4272 @smallexample
|
|
4273 (> 4 5)
|
|
4274 @end smallexample
|
|
4275
|
|
4276 @node save-excursion, Review, Truth & Falsehood, Writing Defuns
|
|
4277 @comment node-name, next, previous, up
|
|
4278 @section @code{save-excursion}
|
|
4279 @findex save-excursion
|
|
4280 @cindex Region, what it is
|
|
4281 @cindex Preserving point, mark, and buffer
|
|
4282 @cindex Point, mark, buffer preservation
|
|
4283 @findex point
|
|
4284 @findex mark
|
|
4285
|
|
4286 The @code{save-excursion} function is the fourth and final special form
|
|
4287 that we will discuss in this chapter.
|
|
4288
|
|
4289 In Emacs Lisp programs used for editing, the @code{save-excursion}
|
|
4290 function is very common. It saves the location of point and mark,
|
|
4291 executes the body of the function, and then restores point and mark to
|
|
4292 their previous positions if their locations were changed. Its primary
|
|
4293 purpose is to keep the user from being surprised and disturbed by
|
|
4294 unexpected movement of point or mark.
|
|
4295
|
|
4296 @menu
|
|
4297 * Point and mark:: A review of various locations.
|
|
4298 * Template for save-excursion::
|
|
4299 @end menu
|
|
4300
|
|
4301 @node Point and mark, Template for save-excursion, save-excursion, save-excursion
|
|
4302 @ifnottex
|
|
4303 @unnumberedsubsec Point and Mark
|
|
4304 @end ifnottex
|
|
4305
|
|
4306 Before discussing @code{save-excursion}, however, it may be useful
|
|
4307 first to review what point and mark are in GNU Emacs. @dfn{Point} is
|
|
4308 the current location of the cursor. Wherever the cursor
|
|
4309 is, that is point. More precisely, on terminals where the cursor
|
|
4310 appears to be on top of a character, point is immediately before the
|
|
4311 character. In Emacs Lisp, point is an integer. The first character in
|
|
4312 a buffer is number one, the second is number two, and so on. The
|
|
4313 function @code{point} returns the current position of the cursor as a
|
|
4314 number. Each buffer has its own value for point.
|
|
4315
|
|
4316 The @dfn{mark} is another position in the buffer; its value can be set
|
|
4317 with a command such as @kbd{C-@key{SPC}} (@code{set-mark-command}). If
|
|
4318 a mark has been set, you can use the command @kbd{C-x C-x}
|
|
4319 (@code{exchange-point-and-mark}) to cause the cursor to jump to the mark
|
|
4320 and set the mark to be the previous position of point. In addition, if
|
|
4321 you set another mark, the position of the previous mark is saved in the
|
|
4322 mark ring. Many mark positions can be saved this way. You can jump the
|
|
4323 cursor to a saved mark by typing @kbd{C-u C-@key{SPC}} one or more
|
|
4324 times.
|
|
4325
|
|
4326 The part of the buffer between point and mark is called @dfn{the
|
|
4327 region}. Numerous commands work on the region, including
|
|
4328 @code{center-region}, @code{count-lines-region}, @code{kill-region}, and
|
|
4329 @code{print-region}.
|
|
4330
|
|
4331 The @code{save-excursion} special form saves the locations of point and
|
|
4332 mark and restores those positions after the code within the body of the
|
|
4333 special form is evaluated by the Lisp interpreter. Thus, if point were
|
|
4334 in the beginning of a piece of text and some code moved point to the end
|
|
4335 of the buffer, the @code{save-excursion} would put point back to where
|
|
4336 it was before, after the expressions in the body of the function were
|
|
4337 evaluated.
|
|
4338
|
|
4339 In Emacs, a function frequently moves point as part of its internal
|
|
4340 workings even though a user would not expect this. For example,
|
|
4341 @code{count-lines-region} moves point. To prevent the user from being
|
|
4342 bothered by jumps that are both unexpected and (from the user's point of
|
|
4343 view) unnecessary, @code{save-excursion} is often used to keep point and
|
|
4344 mark in the location expected by the user. The use of
|
|
4345 @code{save-excursion} is good housekeeping.
|
|
4346
|
|
4347 To make sure the house stays clean, @code{save-excursion} restores the
|
|
4348 values of point and mark even if something goes wrong in the code inside
|
|
4349 of it (or, to be more precise and to use the proper jargon, ``in case of
|
|
4350 abnormal exit''). This feature is very helpful.
|
|
4351
|
|
4352 In addition to recording the values of point and mark,
|
|
4353 @code{save-excursion} keeps track of the current buffer, and restores
|
|
4354 it, too. This means you can write code that will change the buffer and
|
|
4355 have @code{save-excursion} switch you back to the original buffer.
|
|
4356 This is how @code{save-excursion} is used in @code{append-to-buffer}.
|
|
4357 (@xref{append-to-buffer, , The Definition of @code{append-to-buffer}}.)
|
|
4358
|
|
4359 @node Template for save-excursion, , Point and mark, save-excursion
|
|
4360 @comment node-name, next, previous, up
|
|
4361 @subsection Template for a @code{save-excursion} Expression
|
|
4362
|
|
4363 @need 800
|
|
4364 The template for code using @code{save-excursion} is simple:
|
|
4365
|
|
4366 @smallexample
|
|
4367 @group
|
|
4368 (save-excursion
|
|
4369 @var{body}@dots{})
|
|
4370 @end group
|
|
4371 @end smallexample
|
|
4372
|
|
4373 @noindent
|
|
4374 The body of the function is one or more expressions that will be
|
|
4375 evaluated in sequence by the Lisp interpreter. If there is more than
|
|
4376 one expression in the body, the value of the last one will be returned
|
|
4377 as the value of the @code{save-excursion} function. The other
|
|
4378 expressions in the body are evaluated only for their side effects; and
|
|
4379 @code{save-excursion} itself is used only for its side effect (which
|
|
4380 is restoring the positions of point and mark).
|
|
4381
|
|
4382 @need 1250
|
|
4383 In more detail, the template for a @code{save-excursion} expression
|
|
4384 looks like this:
|
|
4385
|
|
4386 @smallexample
|
|
4387 @group
|
|
4388 (save-excursion
|
|
4389 @var{first-expression-in-body}
|
|
4390 @var{second-expression-in-body}
|
|
4391 @var{third-expression-in-body}
|
|
4392 @dots{}
|
|
4393 @var{last-expression-in-body})
|
|
4394 @end group
|
|
4395 @end smallexample
|
|
4396
|
|
4397 @noindent
|
|
4398 An expression, of course, may be a symbol on its own or a list.
|
|
4399
|
|
4400 In Emacs Lisp code, a @code{save-excursion} expression often occurs
|
|
4401 within the body of a @code{let} expression. It looks like this:
|
|
4402
|
|
4403 @smallexample
|
|
4404 @group
|
|
4405 (let @var{varlist}
|
|
4406 (save-excursion
|
|
4407 @var{body}@dots{}))
|
|
4408 @end group
|
|
4409 @end smallexample
|
|
4410
|
|
4411 @node Review, defun Exercises, save-excursion, Writing Defuns
|
|
4412 @comment node-name, next, previous, up
|
|
4413 @section Review
|
|
4414
|
|
4415 In the last few chapters we have introduced a fair number of functions
|
|
4416 and special forms. Here they are described in brief, along with a few
|
|
4417 similar functions that have not been mentioned yet.
|
|
4418
|
|
4419 @table @code
|
|
4420 @item eval-last-sexp
|
|
4421 Evaluate the last symbolic expression before the current location of
|
|
4422 point. The value is printed in the echo area unless the function is
|
|
4423 invoked with an argument; in that case, the output is printed in the
|
|
4424 current buffer. This command is normally bound to @kbd{C-x C-e}.
|
|
4425
|
|
4426 @item defun
|
|
4427 Define function. This special form has up to five parts: the name,
|
|
4428 a template for the arguments that will be passed to the function,
|
|
4429 documentation, an optional interactive declaration, and the body of the
|
|
4430 definition.
|
|
4431
|
|
4432 @need 1250
|
|
4433 For example, in an early version of Emacs, the function definition was
|
|
4434 as follows. (It is slightly more complex now that it seeks the first
|
|
4435 non-whitespace character rather than the first visible character.)
|
|
4436
|
|
4437 @smallexample
|
|
4438 @group
|
|
4439 (defun back-to-indentation ()
|
|
4440 "Move point to first visible character on line."
|
|
4441 (interactive)
|
|
4442 (beginning-of-line 1)
|
|
4443 (skip-chars-forward " \t"))
|
|
4444 @end group
|
|
4445 @end smallexample
|
|
4446
|
|
4447 @ignore
|
|
4448 In GNU Emacs 22,
|
|
4449
|
|
4450 (defun backward-to-indentation (&optional arg)
|
|
4451 "Move backward ARG lines and position at first nonblank character."
|
|
4452 (interactive "p")
|
|
4453 (forward-line (- (or arg 1)))
|
|
4454 (skip-chars-forward " \t"))
|
|
4455
|
|
4456 (defun back-to-indentation ()
|
|
4457 "Move point to the first non-whitespace character on this line."
|
|
4458 (interactive)
|
|
4459 (beginning-of-line 1)
|
|
4460 (skip-syntax-forward " " (line-end-position))
|
|
4461 ;; Move back over chars that have whitespace syntax but have the p flag.
|
|
4462 (backward-prefix-chars))
|
|
4463 @end ignore
|
|
4464
|
|
4465 @item interactive
|
|
4466 Declare to the interpreter that the function can be used
|
|
4467 interactively. This special form may be followed by a string with one
|
|
4468 or more parts that pass the information to the arguments of the
|
|
4469 function, in sequence. These parts may also tell the interpreter to
|
|
4470 prompt for information. Parts of the string are separated by
|
|
4471 newlines, @samp{\n}.
|
|
4472
|
|
4473 @need 1000
|
|
4474 Common code characters are:
|
|
4475
|
|
4476 @table @code
|
|
4477 @item b
|
|
4478 The name of an existing buffer.
|
|
4479
|
|
4480 @item f
|
|
4481 The name of an existing file.
|
|
4482
|
|
4483 @item p
|
|
4484 The numeric prefix argument. (Note that this `p' is lower case.)
|
|
4485
|
|
4486 @item r
|
|
4487 Point and the mark, as two numeric arguments, smallest first. This
|
|
4488 is the only code letter that specifies two successive arguments
|
|
4489 rather than one.
|
|
4490 @end table
|
|
4491
|
|
4492 @xref{Interactive Codes, , Code Characters for @samp{interactive},
|
|
4493 elisp, The GNU Emacs Lisp Reference Manual}, for a complete list of
|
|
4494 code characters.
|
|
4495
|
|
4496 @item let
|
|
4497 Declare that a list of variables is for use within the body of the
|
|
4498 @code{let} and give them an initial value, either @code{nil} or a
|
|
4499 specified value; then evaluate the rest of the expressions in the body
|
|
4500 of the @code{let} and return the value of the last one. Inside the
|
|
4501 body of the @code{let}, the Lisp interpreter does not see the values of
|
|
4502 the variables of the same names that are bound outside of the
|
|
4503 @code{let}.
|
|
4504
|
|
4505 @need 1250
|
|
4506 For example,
|
|
4507
|
|
4508 @smallexample
|
|
4509 @group
|
|
4510 (let ((foo (buffer-name))
|
|
4511 (bar (buffer-size)))
|
|
4512 (message
|
|
4513 "This buffer is %s and has %d characters."
|
|
4514 foo bar))
|
|
4515 @end group
|
|
4516 @end smallexample
|
|
4517
|
|
4518 @item save-excursion
|
|
4519 Record the values of point and mark and the current buffer before
|
|
4520 evaluating the body of this special form. Restore the values of point
|
|
4521 and mark and buffer afterward.
|
|
4522
|
|
4523 @need 1250
|
|
4524 For example,
|
|
4525
|
|
4526 @smallexample
|
|
4527 @group
|
|
4528 (message "We are %d characters into this buffer."
|
|
4529 (- (point)
|
|
4530 (save-excursion
|
|
4531 (goto-char (point-min)) (point))))
|
|
4532 @end group
|
|
4533 @end smallexample
|
|
4534
|
|
4535 @item if
|
|
4536 Evaluate the first argument to the function; if it is true, evaluate
|
|
4537 the second argument; else evaluate the third argument, if there is one.
|
|
4538
|
|
4539 The @code{if} special form is called a @dfn{conditional}. There are
|
|
4540 other conditionals in Emacs Lisp, but @code{if} is perhaps the most
|
|
4541 commonly used.
|
|
4542
|
|
4543 @need 1250
|
|
4544 For example,
|
|
4545
|
|
4546 @smallexample
|
|
4547 @group
|
|
4548 (if (= 22 emacs-major-version)
|
|
4549 (message "This is version 22 Emacs")
|
|
4550 (message "This is not version 22 Emacs"))
|
|
4551 @end group
|
|
4552 @end smallexample
|
|
4553
|
|
4554 @need 1250
|
|
4555 @item <
|
|
4556 @itemx >
|
|
4557 @itemx <=
|
|
4558 @itemx >=
|
|
4559 The @code{<} function tests whether its first argument is smaller than
|
|
4560 its second argument. A corresponding function, @code{>}, tests whether
|
|
4561 the first argument is greater than the second. Likewise, @code{<=}
|
|
4562 tests whether the first argument is less than or equal to the second and
|
|
4563 @code{>=} tests whether the first argument is greater than or equal to
|
|
4564 the second. In all cases, both arguments must be numbers or markers
|
|
4565 (markers indicate positions in buffers).
|
|
4566
|
|
4567 @need 800
|
|
4568 @item =
|
|
4569 The @code{=} function tests whether two arguments, both numbers or
|
|
4570 markers, are equal.
|
|
4571
|
|
4572 @need 1250
|
|
4573 @item equal
|
|
4574 @itemx eq
|
|
4575 Test whether two objects are the same. @code{equal} uses one meaning
|
|
4576 of the word `same' and @code{eq} uses another: @code{equal} returns
|
|
4577 true if the two objects have a similar structure and contents, such as
|
|
4578 two copies of the same book. On the other hand, @code{eq}, returns
|
|
4579 true if both arguments are actually the same object.
|
|
4580 @findex equal
|
|
4581 @findex eq
|
|
4582
|
|
4583 @need 1250
|
|
4584 @item string<
|
|
4585 @itemx string-lessp
|
|
4586 @itemx string=
|
|
4587 @itemx string-equal
|
|
4588 The @code{string-lessp} function tests whether its first argument is
|
|
4589 smaller than the second argument. A shorter, alternative name for the
|
|
4590 same function (a @code{defalias}) is @code{string<}.
|
|
4591
|
|
4592 The arguments to @code{string-lessp} must be strings or symbols; the
|
|
4593 ordering is lexicographic, so case is significant. The print names of
|
|
4594 symbols are used instead of the symbols themselves.
|
|
4595
|
|
4596 @cindex @samp{empty string} defined
|
|
4597 An empty string, @samp{""}, a string with no characters in it, is
|
|
4598 smaller than any string of characters.
|
|
4599
|
|
4600 @code{string-equal} provides the corresponding test for equality. Its
|
|
4601 shorter, alternative name is @code{string=}. There are no string test
|
|
4602 functions that correspond to @var{>}, @code{>=}, or @code{<=}.
|
|
4603
|
|
4604 @item message
|
|
4605 Print a message in the echo area. The first argument is a string that
|
|
4606 can contain @samp{%s}, @samp{%d}, or @samp{%c} to print the value of
|
|
4607 arguments that follow the string. The argument used by @samp{%s} must
|
|
4608 be a string or a symbol; the argument used by @samp{%d} must be a
|
|
4609 number. The argument used by @samp{%c} must be an @sc{ascii} code
|
|
4610 number; it will be printed as the character with that @sc{ascii} code.
|
|
4611 (Various other %-sequences have not been mentioned.)
|
|
4612
|
|
4613 @item setq
|
|
4614 @itemx set
|
|
4615 The @code{setq} function sets the value of its first argument to the
|
|
4616 value of the second argument. The first argument is automatically
|
|
4617 quoted by @code{setq}. It does the same for succeeding pairs of
|
|
4618 arguments. Another function, @code{set}, takes only two arguments and
|
|
4619 evaluates both of them before setting the value returned by its first
|
|
4620 argument to the value returned by its second argument.
|
|
4621
|
|
4622 @item buffer-name
|
|
4623 Without an argument, return the name of the buffer, as a string.
|
|
4624
|
|
4625 @itemx buffer-file-name
|
|
4626 Without an argument, return the name of the file the buffer is
|
|
4627 visiting.
|
|
4628
|
|
4629 @item current-buffer
|
|
4630 Return the buffer in which Emacs is active; it may not be
|
|
4631 the buffer that is visible on the screen.
|
|
4632
|
|
4633 @item other-buffer
|
|
4634 Return the most recently selected buffer (other than the buffer passed
|
|
4635 to @code{other-buffer} as an argument and other than the current
|
|
4636 buffer).
|
|
4637
|
|
4638 @item switch-to-buffer
|
|
4639 Select a buffer for Emacs to be active in and display it in the current
|
|
4640 window so users can look at it. Usually bound to @kbd{C-x b}.
|
|
4641
|
|
4642 @item set-buffer
|
|
4643 Switch Emacs' attention to a buffer on which programs will run. Don't
|
|
4644 alter what the window is showing.
|
|
4645
|
|
4646 @item buffer-size
|
|
4647 Return the number of characters in the current buffer.
|
|
4648
|
|
4649 @item point
|
|
4650 Return the value of the current position of the cursor, as an
|
|
4651 integer counting the number of characters from the beginning of the
|
|
4652 buffer.
|
|
4653
|
|
4654 @item point-min
|
|
4655 Return the minimum permissible value of point in
|
|
4656 the current buffer. This is 1, unless narrowing is in effect.
|
|
4657
|
|
4658 @item point-max
|
|
4659 Return the value of the maximum permissible value of point in the
|
|
4660 current buffer. This is the end of the buffer, unless narrowing is in
|
|
4661 effect.
|
|
4662 @end table
|
|
4663
|
|
4664 @need 1500
|
|
4665 @node defun Exercises, , Review, Writing Defuns
|
|
4666 @section Exercises
|
|
4667
|
|
4668 @itemize @bullet
|
|
4669 @item
|
|
4670 Write a non-interactive function that doubles the value of its
|
|
4671 argument, a number. Make that function interactive.
|
|
4672
|
|
4673 @item
|
|
4674 Write a function that tests whether the current value of
|
|
4675 @code{fill-column} is greater than the argument passed to the function,
|
|
4676 and if so, prints an appropriate message.
|
|
4677 @end itemize
|
|
4678
|
|
4679 @node Buffer Walk Through, More Complex, Writing Defuns, Top
|
|
4680 @comment node-name, next, previous, up
|
|
4681 @chapter A Few Buffer--Related Functions
|
|
4682
|
|
4683 In this chapter we study in detail several of the functions used in GNU
|
|
4684 Emacs. This is called a ``walk-through''. These functions are used as
|
|
4685 examples of Lisp code, but are not imaginary examples; with the
|
|
4686 exception of the first, simplified function definition, these functions
|
|
4687 show the actual code used in GNU Emacs. You can learn a great deal from
|
|
4688 these definitions. The functions described here are all related to
|
|
4689 buffers. Later, we will study other functions.
|
|
4690
|
|
4691 @menu
|
|
4692 * Finding More:: How to find more information.
|
|
4693 * simplified-beginning-of-buffer:: Shows @code{goto-char},
|
|
4694 @code{point-min}, and @code{push-mark}.
|
|
4695 * mark-whole-buffer:: Almost the same as @code{beginning-of-buffer}.
|
|
4696 * append-to-buffer:: Uses @code{save-excursion} and
|
|
4697 @code{insert-buffer-substring}.
|
|
4698 * Buffer Related Review:: Review.
|
|
4699 * Buffer Exercises::
|
|
4700 @end menu
|
|
4701
|
|
4702 @node Finding More, simplified-beginning-of-buffer, Buffer Walk Through, Buffer Walk Through
|
|
4703 @section Finding More Information
|
|
4704
|
|
4705 @findex describe-function, @r{introduced}
|
|
4706 @cindex Find function documentation
|
|
4707 In this walk-through, I will describe each new function as we come to
|
|
4708 it, sometimes in detail and sometimes briefly. If you are interested,
|
|
4709 you can get the full documentation of any Emacs Lisp function at any
|
|
4710 time by typing @kbd{C-h f} and then the name of the function (and then
|
|
4711 @key{RET}). Similarly, you can get the full documentation for a
|
|
4712 variable by typing @kbd{C-h v} and then the name of the variable (and
|
|
4713 then @key{RET}).
|
|
4714
|
|
4715 @cindex Find source of function
|
|
4716 @c In version 22, tells location both of C and of Emacs Lisp
|
|
4717 Also, @code{describe-function} will tell you the location of the
|
|
4718 function definition.
|
|
4719
|
|
4720 Put point into the name of the file that contains the function and
|
|
4721 press the @key{RET} key. In this case, @key{RET} means
|
|
4722 @code{push-button} rather than `return' or `enter'. Emacs will take
|
|
4723 you directly to the function definition.
|
|
4724
|
|
4725 @ignore
|
|
4726 Not In version 22
|
|
4727
|
|
4728 If you move point over the file name and press
|
|
4729 the @key{RET} key, which in this case means @code{help-follow} rather
|
|
4730 than `return' or `enter', Emacs will take you directly to the function
|
|
4731 definition.
|
|
4732 @end ignore
|
|
4733
|
|
4734 More generally, if you want to see a function in its original source
|
|
4735 file, you can use the @code{find-tags} function to jump to it.
|
|
4736 @code{find-tags} works with a wide variety of languages, not just
|
|
4737 Lisp, and C, and it works with non-programming text as well. For
|
|
4738 example, @code{find-tags} will jump to the various nodes in the
|
|
4739 Texinfo source file of this document.
|
|
4740 The @code{find-tags} function depends on `tags tables' that record
|
|
4741 the locations of the functions, variables, and other items to which
|
|
4742 @code{find-tags} jumps.
|
|
4743
|
|
4744 To use the @code{find-tags} command, type @kbd{M-.} (i.e., press the
|
|
4745 period key while holding down the @key{META} key, or else type the
|
|
4746 @key{ESC} key and then type the period key), and then, at the prompt,
|
|
4747 type in the name of the function whose source code you want to see,
|
|
4748 such as @code{mark-whole-buffer}, and then type @key{RET}. Emacs will
|
|
4749 switch buffers and display the source code for the function on your
|
|
4750 screen. To switch back to your current buffer, type @kbd{C-x b
|
|
4751 @key{RET}}. (On some keyboards, the @key{META} key is labelled
|
|
4752 @key{ALT}.)
|
|
4753
|
|
4754 @c !!! 22.1.1 tags table location in this paragraph
|
|
4755 @cindex TAGS table, specifying
|
|
4756 @findex find-tags
|
|
4757 Depending on how the initial default values of your copy of Emacs are
|
|
4758 set, you may also need to specify the location of your `tags table',
|
|
4759 which is a file called @file{TAGS}. For example, if you are
|
|
4760 interested in Emacs sources, the tags table you will most likely want,
|
|
4761 if it has already been created for you, will be in a subdirectory of
|
|
4762 the @file{/usr/local/share/emacs/} directory; thus you would use the
|
|
4763 @code{M-x visit-tags-table} command and specify a pathname such as
|
|
4764 @file{/usr/local/share/emacs/22.1.1/lisp/TAGS}. If the tags table
|
|
4765 has not already been created, you will have to create it yourself. It
|
|
4766 will in a file such as @file{/usr/local/src/emacs/src/TAGS}.
|
|
4767
|
|
4768 @need 1250
|
|
4769 To create a @file{TAGS} file in a specific directory, switch to that
|
|
4770 directory in Emacs using @kbd{M-x cd} command, or list the directory
|
|
4771 with @kbd{C-x d} (@code{dired}). Then run the compile command, with
|
|
4772 @w{@code{etags *.el}} as the command to execute:
|
|
4773
|
|
4774 @smallexample
|
|
4775 M-x compile RET etags *.el RET
|
|
4776 @end smallexample
|
|
4777
|
|
4778 For more information, see @ref{etags, , Create Your Own @file{TAGS} File}.
|
|
4779
|
|
4780 After you become more familiar with Emacs Lisp, you will find that you will
|
|
4781 frequently use @code{find-tags} to navigate your way around source code;
|
|
4782 and you will create your own @file{TAGS} tables.
|
|
4783
|
|
4784 @cindex Library, as term for `file'
|
|
4785 Incidentally, the files that contain Lisp code are conventionally
|
|
4786 called @dfn{libraries}. The metaphor is derived from that of a
|
|
4787 specialized library, such as a law library or an engineering library,
|
|
4788 rather than a general library. Each library, or file, contains
|
|
4789 functions that relate to a particular topic or activity, such as
|
|
4790 @file{abbrev.el} for handling abbreviations and other typing
|
|
4791 shortcuts, and @file{help.el} for on-line help. (Sometimes several
|
|
4792 libraries provide code for a single activity, as the various
|
|
4793 @file{rmail@dots{}} files provide code for reading electronic mail.)
|
|
4794 In @cite{The GNU Emacs Manual}, you will see sentences such as ``The
|
|
4795 @kbd{C-h p} command lets you search the standard Emacs Lisp libraries
|
|
4796 by topic keywords.''
|
|
4797
|
|
4798 @node simplified-beginning-of-buffer, mark-whole-buffer, Finding More, Buffer Walk Through
|
|
4799 @comment node-name, next, previous, up
|
|
4800 @section A Simplified @code{beginning-of-buffer} Definition
|
|
4801 @findex simplified-beginning-of-buffer
|
|
4802
|
|
4803 The @code{beginning-of-buffer} command is a good function to start with
|
|
4804 since you are likely to be familiar with it and it is easy to
|
|
4805 understand. Used as an interactive command, @code{beginning-of-buffer}
|
|
4806 moves the cursor to the beginning of the buffer, leaving the mark at the
|
|
4807 previous position. It is generally bound to @kbd{M-<}.
|
|
4808
|
|
4809 In this section, we will discuss a shortened version of the function
|
|
4810 that shows how it is most frequently used. This shortened function
|
|
4811 works as written, but it does not contain the code for a complex option.
|
|
4812 In another section, we will describe the entire function.
|
|
4813 (@xref{beginning-of-buffer, , Complete Definition of
|
|
4814 @code{beginning-of-buffer}}.)
|
|
4815
|
|
4816 Before looking at the code, let's consider what the function
|
|
4817 definition has to contain: it must include an expression that makes
|
|
4818 the function interactive so it can be called by typing @kbd{M-x
|
|
4819 beginning-of-buffer} or by typing a keychord such as @kbd{M-<}; it
|
|
4820 must include code to leave a mark at the original position in the
|
|
4821 buffer; and it must include code to move the cursor to the beginning
|
|
4822 of the buffer.
|
|
4823
|
|
4824 @need 1250
|
|
4825 Here is the complete text of the shortened version of the function:
|
|
4826
|
|
4827 @smallexample
|
|
4828 @group
|
|
4829 (defun simplified-beginning-of-buffer ()
|
|
4830 "Move point to the beginning of the buffer;
|
|
4831 leave mark at previous position."
|
|
4832 (interactive)
|
|
4833 (push-mark)
|
|
4834 (goto-char (point-min)))
|
|
4835 @end group
|
|
4836 @end smallexample
|
|
4837
|
|
4838 Like all function definitions, this definition has five parts following
|
|
4839 the special form @code{defun}:
|
|
4840
|
|
4841 @enumerate
|
|
4842 @item
|
|
4843 The name: in this example, @code{simplified-beginning-of-buffer}.
|
|
4844
|
|
4845 @item
|
|
4846 A list of the arguments: in this example, an empty list, @code{()},
|
|
4847
|
|
4848 @item
|
|
4849 The documentation string.
|
|
4850
|
|
4851 @item
|
|
4852 The interactive expression.
|
|
4853
|
|
4854 @item
|
|
4855 The body.
|
|
4856 @end enumerate
|
|
4857
|
|
4858 @noindent
|
|
4859 In this function definition, the argument list is empty; this means that
|
|
4860 this function does not require any arguments. (When we look at the
|
|
4861 definition for the complete function, we will see that it may be passed
|
|
4862 an optional argument.)
|
|
4863
|
|
4864 The interactive expression tells Emacs that the function is intended to
|
|
4865 be used interactively. In this example, @code{interactive} does not have
|
|
4866 an argument because @code{simplified-beginning-of-buffer} does not
|
|
4867 require one.
|
|
4868
|
|
4869 @need 800
|
|
4870 The body of the function consists of the two lines:
|
|
4871
|
|
4872 @smallexample
|
|
4873 @group
|
|
4874 (push-mark)
|
|
4875 (goto-char (point-min))
|
|
4876 @end group
|
|
4877 @end smallexample
|
|
4878
|
|
4879 The first of these lines is the expression, @code{(push-mark)}. When
|
|
4880 this expression is evaluated by the Lisp interpreter, it sets a mark at
|
|
4881 the current position of the cursor, wherever that may be. The position
|
|
4882 of this mark is saved in the mark ring.
|
|
4883
|
|
4884 The next line is @code{(goto-char (point-min))}. This expression
|
|
4885 jumps the cursor to the minimum point in the buffer, that is, to the
|
|
4886 beginning of the buffer (or to the beginning of the accessible portion
|
|
4887 of the buffer if it is narrowed. @xref{Narrowing & Widening, ,
|
|
4888 Narrowing and Widening}.)
|
|
4889
|
|
4890 The @code{push-mark} command sets a mark at the place where the cursor
|
|
4891 was located before it was moved to the beginning of the buffer by the
|
|
4892 @code{(goto-char (point-min))} expression. Consequently, you can, if
|
|
4893 you wish, go back to where you were originally by typing @kbd{C-x C-x}.
|
|
4894
|
|
4895 That is all there is to the function definition!
|
|
4896
|
|
4897 @findex describe-function
|
|
4898 When you are reading code such as this and come upon an unfamiliar
|
|
4899 function, such as @code{goto-char}, you can find out what it does by
|
|
4900 using the @code{describe-function} command. To use this command, type
|
|
4901 @kbd{C-h f} and then type in the name of the function and press
|
|
4902 @key{RET}. The @code{describe-function} command will print the
|
|
4903 function's documentation string in a @file{*Help*} window. For
|
|
4904 example, the documentation for @code{goto-char} is:
|
|
4905
|
|
4906 @smallexample
|
|
4907 @group
|
|
4908 Set point to POSITION, a number or marker.
|
|
4909 Beginning of buffer is position (point-min), end is (point-max).
|
|
4910 @end group
|
|
4911 @end smallexample
|
|
4912
|
|
4913 @noindent
|
|
4914 The function's one argument is the desired position.
|
|
4915
|
|
4916 @noindent
|
|
4917 (The prompt for @code{describe-function} will offer you the symbol
|
|
4918 under or preceding the cursor, so you can save typing by positioning
|
|
4919 the cursor right over or after the function and then typing @kbd{C-h f
|
|
4920 @key{RET}}.)
|
|
4921
|
|
4922 The @code{end-of-buffer} function definition is written in the same way as
|
|
4923 the @code{beginning-of-buffer} definition except that the body of the
|
|
4924 function contains the expression @code{(goto-char (point-max))} in place
|
|
4925 of @code{(goto-char (point-min))}.
|
|
4926
|
|
4927 @node mark-whole-buffer, append-to-buffer, simplified-beginning-of-buffer, Buffer Walk Through
|
|
4928 @comment node-name, next, previous, up
|
|
4929 @section The Definition of @code{mark-whole-buffer}
|
|
4930 @findex mark-whole-buffer
|
|
4931
|
|
4932 The @code{mark-whole-buffer} function is no harder to understand than the
|
|
4933 @code{simplified-beginning-of-buffer} function. In this case, however,
|
|
4934 we will look at the complete function, not a shortened version.
|
|
4935
|
|
4936 The @code{mark-whole-buffer} function is not as commonly used as the
|
|
4937 @code{beginning-of-buffer} function, but is useful nonetheless: it
|
|
4938 marks a whole buffer as a region by putting point at the beginning and
|
|
4939 a mark at the end of the buffer. It is generally bound to @kbd{C-x
|
|
4940 h}.
|
|
4941
|
|
4942 @menu
|
|
4943 * mark-whole-buffer overview::
|
|
4944 * Body of mark-whole-buffer:: Only three lines of code.
|
|
4945 @end menu
|
|
4946
|
|
4947 @node mark-whole-buffer overview, Body of mark-whole-buffer, mark-whole-buffer, mark-whole-buffer
|
|
4948 @ifnottex
|
|
4949 @unnumberedsubsec An overview of @code{mark-whole-buffer}
|
|
4950 @end ifnottex
|
|
4951
|
|
4952 @need 1250
|
|
4953 In GNU Emacs 22, the code for the complete function looks like this:
|
|
4954
|
|
4955 @smallexample
|
|
4956 @group
|
|
4957 (defun mark-whole-buffer ()
|
|
4958 "Put point at beginning and mark at end of buffer.
|
|
4959 You probably should not use this function in Lisp programs;
|
|
4960 it is usually a mistake for a Lisp function to use any subroutine
|
|
4961 that uses or sets the mark."
|
|
4962 (interactive)
|
|
4963 (push-mark (point))
|
|
4964 (push-mark (point-max) nil t)
|
|
4965 (goto-char (point-min)))
|
|
4966 @end group
|
|
4967 @end smallexample
|
|
4968
|
|
4969 @need 1250
|
|
4970 Like all other functions, the @code{mark-whole-buffer} function fits
|
|
4971 into the template for a function definition. The template looks like
|
|
4972 this:
|
|
4973
|
|
4974 @smallexample
|
|
4975 @group
|
|
4976 (defun @var{name-of-function} (@var{argument-list})
|
|
4977 "@var{documentation}@dots{}"
|
|
4978 (@var{interactive-expression}@dots{})
|
|
4979 @var{body}@dots{})
|
|
4980 @end group
|
|
4981 @end smallexample
|
|
4982
|
|
4983 Here is how the function works: the name of the function is
|
|
4984 @code{mark-whole-buffer}; it is followed by an empty argument list,
|
|
4985 @samp{()}, which means that the function does not require arguments.
|
|
4986 The documentation comes next.
|
|
4987
|
|
4988 The next line is an @code{(interactive)} expression that tells Emacs
|
|
4989 that the function will be used interactively. These details are similar
|
|
4990 to the @code{simplified-beginning-of-buffer} function described in the
|
|
4991 previous section.
|
|
4992
|
|
4993 @need 1250
|
|
4994 @node Body of mark-whole-buffer, , mark-whole-buffer overview, mark-whole-buffer
|
|
4995 @comment node-name, next, previous, up
|
|
4996 @subsection Body of @code{mark-whole-buffer}
|
|
4997
|
|
4998 The body of the @code{mark-whole-buffer} function consists of three
|
|
4999 lines of code:
|
|
5000
|
|
5001 @c GNU Emacs 22
|
|
5002 @smallexample
|
|
5003 @group
|
|
5004 (push-mark (point))
|
|
5005 (push-mark (point-max) nil t)
|
|
5006 (goto-char (point-min))
|
|
5007 @end group
|
|
5008 @end smallexample
|
|
5009
|
|
5010 The first of these lines is the expression, @code{(push-mark (point))}.
|
|
5011
|
|
5012 This line does exactly the same job as the first line of the body of
|
|
5013 the @code{simplified-beginning-of-buffer} function, which is written
|
|
5014 @code{(push-mark)}. In both cases, the Lisp interpreter sets a mark
|
|
5015 at the current position of the cursor.
|
|
5016
|
|
5017 I don't know why the expression in @code{mark-whole-buffer} is written
|
|
5018 @code{(push-mark (point))} and the expression in
|
|
5019 @code{beginning-of-buffer} is written @code{(push-mark)}. Perhaps
|
|
5020 whoever wrote the code did not know that the arguments for
|
|
5021 @code{push-mark} are optional and that if @code{push-mark} is not
|
|
5022 passed an argument, the function automatically sets mark at the
|
|
5023 location of point by default. Or perhaps the expression was written
|
|
5024 so as to parallel the structure of the next line. In any case, the
|
|
5025 line causes Emacs to determine the position of point and set a mark
|
|
5026 there.
|
|
5027
|
|
5028 In earlier versions of GNU Emacs, the next line of
|
|
5029 @code{mark-whole-buffer} was @code{(push-mark (point-max))}. This
|
|
5030 expression sets a mark at the point in the buffer that has the highest
|
|
5031 number. This will be the end of the buffer (or, if the buffer is
|
|
5032 narrowed, the end of the accessible portion of the buffer.
|
|
5033 @xref{Narrowing & Widening, , Narrowing and Widening}, for more about
|
|
5034 narrowing.) After this mark has been set, the previous mark, the one
|
|
5035 set at point, is no longer set, but Emacs remembers its position, just
|
|
5036 as all other recent marks are always remembered. This means that you
|
|
5037 can, if you wish, go back to that position by typing @kbd{C-u
|
|
5038 C-@key{SPC}} twice.
|
|
5039
|
|
5040 @need 1250
|
|
5041 In GNU Emacs 22, the @code{(point-max)} is slightly more complicated.
|
|
5042 The line reads
|
|
5043
|
|
5044 @smallexample
|
|
5045 (push-mark (point-max) nil t)
|
|
5046 @end smallexample
|
|
5047
|
|
5048 @noindent
|
|
5049 The expression works nearly the same as before. It sets a mark at the
|
|
5050 highest numbered place in the buffer that it can. However, in this
|
|
5051 version, @code{push-mark} has two additional arguments. The second
|
|
5052 argument to @code{push-mark} is @code{nil}. This tells the function
|
|
5053 it @emph{should} display a message that says `Mark set' when it pushes
|
|
5054 the mark. The third argument is @code{t}. This tells
|
|
5055 @code{push-mark} to activate the mark when Transient Mark mode is
|
|
5056 turned on. Transient Mark mode highlights the currently active
|
|
5057 region. It is often turned off.
|
|
5058
|
|
5059 Finally, the last line of the function is @code{(goto-char
|
|
5060 (point-min)))}. This is written exactly the same way as it is written
|
|
5061 in @code{beginning-of-buffer}. The expression moves the cursor to
|
|
5062 the minimum point in the buffer, that is, to the beginning of the buffer
|
|
5063 (or to the beginning of the accessible portion of the buffer). As a
|
|
5064 result of this, point is placed at the beginning of the buffer and mark
|
|
5065 is set at the end of the buffer. The whole buffer is, therefore, the
|
|
5066 region.
|
|
5067
|
|
5068 @node append-to-buffer, Buffer Related Review, mark-whole-buffer, Buffer Walk Through
|
|
5069 @comment node-name, next, previous, up
|
|
5070 @section The Definition of @code{append-to-buffer}
|
|
5071 @findex append-to-buffer
|
|
5072
|
|
5073 The @code{append-to-buffer} command is more complex than the
|
|
5074 @code{mark-whole-buffer} command. What it does is copy the region
|
|
5075 (that is, the part of the buffer between point and mark) from the
|
|
5076 current buffer to a specified buffer.
|
|
5077
|
|
5078 @menu
|
|
5079 * append-to-buffer overview::
|
|
5080 * append interactive:: A two part interactive expression.
|
|
5081 * append-to-buffer body:: Incorporates a @code{let} expression.
|
|
5082 * append save-excursion:: How the @code{save-excursion} works.
|
|
5083 @end menu
|
|
5084
|
|
5085 @node append-to-buffer overview, append interactive, append-to-buffer, append-to-buffer
|
|
5086 @ifnottex
|
|
5087 @unnumberedsubsec An Overview of @code{append-to-buffer}
|
|
5088 @end ifnottex
|
|
5089
|
|
5090 @findex insert-buffer-substring
|
|
5091 The @code{append-to-buffer} command uses the
|
|
5092 @code{insert-buffer-substring} function to copy the region.
|
|
5093 @code{insert-buffer-substring} is described by its name: it takes a
|
|
5094 string of characters from part of a buffer, a ``substring'', and
|
|
5095 inserts them into another buffer.
|
|
5096
|
|
5097 Most of @code{append-to-buffer} is
|
|
5098 concerned with setting up the conditions for
|
|
5099 @code{insert-buffer-substring} to work: the code must specify both the
|
|
5100 buffer to which the text will go, the window it comes from and goes
|
|
5101 to, and the region that will be copied.
|
|
5102
|
|
5103 @need 1250
|
|
5104 Here is the complete text of the function:
|
|
5105
|
|
5106 @smallexample
|
|
5107 @group
|
|
5108 (defun append-to-buffer (buffer start end)
|
|
5109 "Append to specified buffer the text of the region.
|
|
5110 It is inserted into that buffer before its point.
|
|
5111 @end group
|
|
5112
|
|
5113 @group
|
|
5114 When calling from a program, give three arguments:
|
|
5115 BUFFER (or buffer name), START and END.
|
|
5116 START and END specify the portion of the current buffer to be copied."
|
|
5117 (interactive
|
|
5118 (list (read-buffer "Append to buffer: " (other-buffer
|
|
5119 (current-buffer) t))
|
|
5120 (region-beginning) (region-end)))
|
|
5121 @end group
|
|
5122 @group
|
|
5123 (let ((oldbuf (current-buffer)))
|
|
5124 (save-excursion
|
|
5125 (let* ((append-to (get-buffer-create buffer))
|
|
5126 (windows (get-buffer-window-list append-to t t))
|
|
5127 point)
|
|
5128 (set-buffer append-to)
|
|
5129 (setq point (point))
|
|
5130 (barf-if-buffer-read-only)
|
|
5131 (insert-buffer-substring oldbuf start end)
|
|
5132 (dolist (window windows)
|
|
5133 (when (= (window-point window) point)
|
|
5134 (set-window-point window (point))))))))
|
|
5135 @end group
|
|
5136 @end smallexample
|
|
5137
|
|
5138 The function can be understood by looking at it as a series of
|
|
5139 filled-in templates.
|
|
5140
|
|
5141 The outermost template is for the function definition. In this
|
|
5142 function, it looks like this (with several slots filled in):
|
|
5143
|
|
5144 @smallexample
|
|
5145 @group
|
|
5146 (defun append-to-buffer (buffer start end)
|
|
5147 "@var{documentation}@dots{}"
|
|
5148 (interactive @dots{})
|
|
5149 @var{body}@dots{})
|
|
5150 @end group
|
|
5151 @end smallexample
|
|
5152
|
|
5153 The first line of the function includes its name and three arguments.
|
|
5154 The arguments are the @code{buffer} to which the text will be copied, and
|
|
5155 the @code{start} and @code{end} of the region in the current buffer that
|
|
5156 will be copied.
|
|
5157
|
|
5158 The next part of the function is the documentation, which is clear and
|
|
5159 complete. As is conventional, the three arguments are written in
|
|
5160 upper case so you will notice them easily. Even better, they are
|
|
5161 described in the same order as in the argument list.
|
|
5162
|
|
5163 Note that the documentation distinguishes between a buffer and its
|
|
5164 name. (The function can handle either.)
|
|
5165
|
|
5166 @node append interactive, append-to-buffer body, append-to-buffer overview, append-to-buffer
|
|
5167 @comment node-name, next, previous, up
|
|
5168 @subsection The @code{append-to-buffer} Interactive Expression
|
|
5169
|
|
5170 Since the @code{append-to-buffer} function will be used interactively,
|
|
5171 the function must have an @code{interactive} expression. (For a
|
|
5172 review of @code{interactive}, see @ref{Interactive, , Making a
|
|
5173 Function Interactive}.) The expression reads as follows:
|
|
5174
|
|
5175 @smallexample
|
|
5176 @group
|
|
5177 (interactive
|
|
5178 (list (read-buffer
|
|
5179 "Append to buffer: "
|
|
5180 (other-buffer (current-buffer) t))
|
|
5181 (region-beginning)
|
|
5182 (region-end)))
|
|
5183 @end group
|
|
5184 @end smallexample
|
|
5185
|
|
5186 @noindent
|
|
5187 This expression is not one with letters standing for parts, as
|
|
5188 described earlier. Instead, it starts a list with these parts:
|
|
5189
|
|
5190 The first part of the list is an expression to read the name of a
|
|
5191 buffer and return it as a string. That is @code{read-buffer}. The
|
|
5192 function requires a prompt as its first argument, @samp{"Append to
|
|
5193 buffer: "}. Its second argument tells the command what value to
|
|
5194 provide if you don't specify anything.
|
|
5195
|
|
5196 In this case that second argument is an expression containing the
|
|
5197 function @code{other-buffer}, an exception, and a @samp{t}, standing
|
|
5198 for true.
|
|
5199
|
|
5200 The first argument to @code{other-buffer}, the exception, is yet
|
|
5201 another function, @code{current-buffer}. That is not going to be
|
|
5202 returned. The second argument is the symbol for true, @code{t}. that
|
|
5203 tells @code{other-buffer} that it may show visible buffers (except in
|
|
5204 this case, it will not show the current buffer, which makes sense).
|
|
5205
|
|
5206 @need 1250
|
|
5207 The expression looks like this:
|
|
5208
|
|
5209 @smallexample
|
|
5210 (other-buffer (current-buffer) t)
|
|
5211 @end smallexample
|
|
5212
|
|
5213 The second and third arguments to the @code{list} expression are
|
|
5214 @code{(region-beginning)} and @code{(region-end)}. These two
|
|
5215 functions specify the beginning and end of the text to be appended.
|
|
5216
|
|
5217 @need 1250
|
|
5218 Originally, the command used the letters @samp{B} and @samp{r}.
|
|
5219 The whole @code{interactive} expression looked like this:
|
|
5220
|
|
5221 @smallexample
|
|
5222 (interactive "BAppend to buffer:@: \nr")
|
|
5223 @end smallexample
|
|
5224
|
|
5225 @noindent
|
|
5226 But when that was done, the default value of the buffer switched to
|
|
5227 was invisible. That was not wanted.
|
|
5228
|
|
5229 (The prompt was separated from the second argument with a newline,
|
|
5230 @samp{\n}. It was followed by an @samp{r} that told Emacs to bind the
|
|
5231 two arguments that follow the symbol @code{buffer} in the function's
|
|
5232 argument list (that is, @code{start} and @code{end}) to the values of
|
|
5233 point and mark. That argument worked fine.)
|
|
5234
|
|
5235 @node append-to-buffer body, append save-excursion, append interactive, append-to-buffer
|
|
5236 @comment node-name, next, previous, up
|
|
5237 @subsection The Body of @code{append-to-buffer}
|
|
5238
|
|
5239 @ignore
|
|
5240 in GNU Emacs 22 in /usr/local/src/emacs/lisp/simple.el
|
|
5241
|
|
5242 (defun append-to-buffer (buffer start end)
|
|
5243 "Append to specified buffer the text of the region.
|
|
5244 It is inserted into that buffer before its point.
|
|
5245
|
|
5246 When calling from a program, give three arguments:
|
|
5247 BUFFER (or buffer name), START and END.
|
|
5248 START and END specify the portion of the current buffer to be copied."
|
|
5249 (interactive
|
|
5250 (list (read-buffer "Append to buffer: " (other-buffer (current-buffer) t))
|
|
5251 (region-beginning) (region-end)))
|
|
5252 (let ((oldbuf (current-buffer)))
|
|
5253 (save-excursion
|
|
5254 (let* ((append-to (get-buffer-create buffer))
|
|
5255 (windows (get-buffer-window-list append-to t t))
|
|
5256 point)
|
|
5257 (set-buffer append-to)
|
|
5258 (setq point (point))
|
|
5259 (barf-if-buffer-read-only)
|
|
5260 (insert-buffer-substring oldbuf start end)
|
|
5261 (dolist (window windows)
|
|
5262 (when (= (window-point window) point)
|
|
5263 (set-window-point window (point))))))))
|
|
5264 @end ignore
|
|
5265
|
|
5266 The body of the @code{append-to-buffer} function begins with @code{let}.
|
|
5267
|
|
5268 As we have seen before (@pxref{let, , @code{let}}), the purpose of a
|
|
5269 @code{let} expression is to create and give initial values to one or
|
|
5270 more variables that will only be used within the body of the
|
|
5271 @code{let}. This means that such a variable will not be confused with
|
|
5272 any variable of the same name outside the @code{let} expression.
|
|
5273
|
|
5274 We can see how the @code{let} expression fits into the function as a
|
|
5275 whole by showing a template for @code{append-to-buffer} with the
|
|
5276 @code{let} expression in outline:
|
|
5277
|
|
5278 @smallexample
|
|
5279 @group
|
|
5280 (defun append-to-buffer (buffer start end)
|
|
5281 "@var{documentation}@dots{}"
|
|
5282 (interactive @dots{})
|
|
5283 (let ((@var{variable} @var{value}))
|
|
5284 @var{body}@dots{})
|
|
5285 @end group
|
|
5286 @end smallexample
|
|
5287
|
|
5288 The @code{let} expression has three elements:
|
|
5289
|
|
5290 @enumerate
|
|
5291 @item
|
|
5292 The symbol @code{let};
|
|
5293
|
|
5294 @item
|
|
5295 A varlist containing, in this case, a single two-element list,
|
|
5296 @code{(@var{variable} @var{value})};
|
|
5297
|
|
5298 @item
|
|
5299 The body of the @code{let} expression.
|
|
5300 @end enumerate
|
|
5301
|
|
5302 @need 800
|
|
5303 In the @code{append-to-buffer} function, the varlist looks like this:
|
|
5304
|
|
5305 @smallexample
|
|
5306 (oldbuf (current-buffer))
|
|
5307 @end smallexample
|
|
5308
|
|
5309 @noindent
|
|
5310 In this part of the @code{let} expression, the one variable,
|
|
5311 @code{oldbuf}, is bound to the value returned by the
|
|
5312 @code{(current-buffer)} expression. The variable, @code{oldbuf}, is
|
|
5313 used to keep track of the buffer in which you are working and from
|
|
5314 which you will copy.
|
|
5315
|
|
5316 The element or elements of a varlist are surrounded by a set of
|
|
5317 parentheses so the Lisp interpreter can distinguish the varlist from
|
|
5318 the body of the @code{let}. As a consequence, the two-element list
|
|
5319 within the varlist is surrounded by a circumscribing set of parentheses.
|
|
5320 The line looks like this:
|
|
5321
|
|
5322 @smallexample
|
|
5323 @group
|
|
5324 (let ((oldbuf (current-buffer)))
|
|
5325 @dots{} )
|
|
5326 @end group
|
|
5327 @end smallexample
|
|
5328
|
|
5329 @noindent
|
|
5330 The two parentheses before @code{oldbuf} might surprise you if you did
|
|
5331 not realize that the first parenthesis before @code{oldbuf} marks the
|
|
5332 boundary of the varlist and the second parenthesis marks the beginning
|
|
5333 of the two-element list, @code{(oldbuf (current-buffer))}.
|
|
5334
|
|
5335 @node append save-excursion, , append-to-buffer body, append-to-buffer
|
|
5336 @comment node-name, next, previous, up
|
|
5337 @subsection @code{save-excursion} in @code{append-to-buffer}
|
|
5338
|
|
5339 The body of the @code{let} expression in @code{append-to-buffer}
|
|
5340 consists of a @code{save-excursion} expression.
|
|
5341
|
|
5342 The @code{save-excursion} function saves the locations of point and
|
|
5343 mark, and restores them to those positions after the expressions in the
|
|
5344 body of the @code{save-excursion} complete execution. In addition,
|
|
5345 @code{save-excursion} keeps track of the original buffer, and
|
|
5346 restores it. This is how @code{save-excursion} is used in
|
|
5347 @code{append-to-buffer}.
|
|
5348
|
|
5349 @need 1500
|
|
5350 @cindex Indentation for formatting
|
|
5351 @cindex Formatting convention
|
|
5352 Incidentally, it is worth noting here that a Lisp function is normally
|
|
5353 formatted so that everything that is enclosed in a multi-line spread is
|
|
5354 indented more to the right than the first symbol. In this function
|
|
5355 definition, the @code{let} is indented more than the @code{defun}, and
|
|
5356 the @code{save-excursion} is indented more than the @code{let}, like
|
|
5357 this:
|
|
5358
|
|
5359 @smallexample
|
|
5360 @group
|
|
5361 (defun @dots{}
|
|
5362 @dots{}
|
|
5363 @dots{}
|
|
5364 (let@dots{}
|
|
5365 (save-excursion
|
|
5366 @dots{}
|
|
5367 @end group
|
|
5368 @end smallexample
|
|
5369
|
|
5370 @need 1500
|
|
5371 @noindent
|
|
5372 This formatting convention makes it easy to see that the lines in
|
|
5373 the body of the @code{save-excursion} are enclosed by the parentheses
|
|
5374 associated with @code{save-excursion}, just as the
|
|
5375 @code{save-excursion} itself is enclosed by the parentheses associated
|
|
5376 with the @code{let}:
|
|
5377
|
|
5378 @smallexample
|
|
5379 @group
|
|
5380 (let ((oldbuf (current-buffer)))
|
|
5381 (save-excursion
|
|
5382 @dots{}
|
|
5383 (set-buffer @dots{})
|
|
5384 (insert-buffer-substring oldbuf start end)
|
|
5385 @dots{}))
|
|
5386 @end group
|
|
5387 @end smallexample
|
|
5388
|
|
5389 @need 1200
|
|
5390 The use of the @code{save-excursion} function can be viewed as a process
|
|
5391 of filling in the slots of a template:
|
|
5392
|
|
5393 @smallexample
|
|
5394 @group
|
|
5395 (save-excursion
|
|
5396 @var{first-expression-in-body}
|
|
5397 @var{second-expression-in-body}
|
|
5398 @dots{}
|
|
5399 @var{last-expression-in-body})
|
|
5400 @end group
|
|
5401 @end smallexample
|
|
5402
|
|
5403 @need 1200
|
|
5404 @noindent
|
|
5405 In this function, the body of the @code{save-excursion} contains only
|
|
5406 one expression, the @code{let*} expression. You know about a
|
|
5407 @code{let} function. The @code{let*} function is different. It has a
|
|
5408 @samp{*} in its name. It enables Emacs to set each variable in its
|
|
5409 varlist in sequence, one after another.
|
|
5410
|
|
5411 Its critical feature is that variables later in the varlist can make
|
|
5412 use of the values to which Emacs set variables earlier in the varlist.
|
|
5413 @xref{fwd-para let, , The @code{let*} expression}.
|
|
5414
|
|
5415 We will skip functions like @code{let*} and focus on two: the
|
|
5416 @code{set-buffer} function and the @code{insert-buffer-substring}
|
|
5417 function.
|
|
5418
|
|
5419 @need 1250
|
|
5420 In the old days, the @code{set-buffer} expression was simply
|
|
5421
|
|
5422 @smallexample
|
|
5423 (set-buffer (get-buffer-create buffer))
|
|
5424 @end smallexample
|
|
5425
|
|
5426 @need 1250
|
|
5427 @noindent
|
|
5428 but now it is
|
|
5429
|
|
5430 @smallexample
|
|
5431 (set-buffer append-to)
|
|
5432 @end smallexample
|
|
5433
|
|
5434 @noindent
|
|
5435 @code{append-to} is bound to @code{(get-buffer-create buffer)} earlier
|
|
5436 on in the @code{let*} expression. That extra binding would not be
|
|
5437 necessary except for that @code{append-to} is used later in the
|
|
5438 varlist as an argument to @code{get-buffer-window-list}.
|
|
5439
|
|
5440 @ignore
|
|
5441 in GNU Emacs 22
|
|
5442
|
|
5443 (let ((oldbuf (current-buffer)))
|
|
5444 (save-excursion
|
|
5445 (let* ((append-to (get-buffer-create buffer))
|
|
5446 (windows (get-buffer-window-list append-to t t))
|
|
5447 point)
|
|
5448 (set-buffer append-to)
|
|
5449 (setq point (point))
|
|
5450 (barf-if-buffer-read-only)
|
|
5451 (insert-buffer-substring oldbuf start end)
|
|
5452 (dolist (window windows)
|
|
5453 (when (= (window-point window) point)
|
|
5454 (set-window-point window (point))))))))
|
|
5455 @end ignore
|
|
5456
|
|
5457 The @code{append-to-buffer} function definition inserts text from the
|
|
5458 buffer in which you are currently to a named buffer. It happens that
|
|
5459 @code{insert-buffer-substring} copies text from another buffer to the
|
|
5460 current buffer, just the reverse---that is why the
|
|
5461 @code{append-to-buffer} definition starts out with a @code{let} that
|
|
5462 binds the local symbol @code{oldbuf} to the value returned by
|
|
5463 @code{current-buffer}.
|
|
5464
|
|
5465 @need 1250
|
|
5466 The @code{insert-buffer-substring} expression looks like this:
|
|
5467
|
|
5468 @smallexample
|
|
5469 (insert-buffer-substring oldbuf start end)
|
|
5470 @end smallexample
|
|
5471
|
|
5472 @noindent
|
|
5473 The @code{insert-buffer-substring} function copies a string
|
|
5474 @emph{from} the buffer specified as its first argument and inserts the
|
|
5475 string into the present buffer. In this case, the argument to
|
|
5476 @code{insert-buffer-substring} is the value of the variable created
|
|
5477 and bound by the @code{let}, namely the value of @code{oldbuf}, which
|
|
5478 was the current buffer when you gave the @code{append-to-buffer}
|
|
5479 command.
|
|
5480
|
|
5481 After @code{insert-buffer-substring} has done its work,
|
|
5482 @code{save-excursion} will restore the action to the original buffer
|
|
5483 and @code{append-to-buffer} will have done its job.
|
|
5484
|
|
5485 @need 800
|
|
5486 Written in skeletal form, the workings of the body look like this:
|
|
5487
|
|
5488 @smallexample
|
|
5489 @group
|
|
5490 (let (@var{bind-}@code{oldbuf}@var{-to-value-of-}@code{current-buffer})
|
|
5491 (save-excursion ; @r{Keep track of buffer.}
|
|
5492 @var{change-buffer}
|
|
5493 @var{insert-substring-from-}@code{oldbuf}@var{-into-buffer})
|
|
5494
|
|
5495 @var{change-back-to-original-buffer-when-finished}
|
|
5496 @var{let-the-local-meaning-of-}@code{oldbuf}@var{-disappear-when-finished}
|
|
5497 @end group
|
|
5498 @end smallexample
|
|
5499
|
|
5500 In summary, @code{append-to-buffer} works as follows: it saves the
|
|
5501 value of the current buffer in the variable called @code{oldbuf}. It
|
|
5502 gets the new buffer (creating one if need be) and switches Emacs'
|
|
5503 attention to it. Using the value of @code{oldbuf}, it inserts the
|
|
5504 region of text from the old buffer into the new buffer; and then using
|
|
5505 @code{save-excursion}, it brings you back to your original buffer.
|
|
5506
|
|
5507 In looking at @code{append-to-buffer}, you have explored a fairly
|
|
5508 complex function. It shows how to use @code{let} and
|
|
5509 @code{save-excursion}, and how to change to and come back from another
|
|
5510 buffer. Many function definitions use @code{let},
|
|
5511 @code{save-excursion}, and @code{set-buffer} this way.
|
|
5512
|
|
5513 @node Buffer Related Review, Buffer Exercises, append-to-buffer, Buffer Walk Through
|
|
5514 @comment node-name, next, previous, up
|
|
5515 @section Review
|
|
5516
|
|
5517 Here is a brief summary of the various functions discussed in this chapter.
|
|
5518
|
|
5519 @table @code
|
|
5520 @item describe-function
|
|
5521 @itemx describe-variable
|
|
5522 Print the documentation for a function or variable.
|
|
5523 Conventionally bound to @kbd{C-h f} and @kbd{C-h v}.
|
|
5524
|
|
5525 @item find-tag
|
|
5526 Find the file containing the source for a function or variable and
|
|
5527 switch buffers to it, positioning point at the beginning of the item.
|
|
5528 Conventionally bound to @kbd{M-.} (that's a period following the
|
|
5529 @key{META} key).
|
|
5530
|
|
5531 @item save-excursion
|
|
5532 Save the location of point and mark and restore their values after the
|
|
5533 arguments to @code{save-excursion} have been evaluated. Also, remember
|
|
5534 the current buffer and return to it.
|
|
5535
|
|
5536 @item push-mark
|
|
5537 Set mark at a location and record the value of the previous mark on the
|
|
5538 mark ring. The mark is a location in the buffer that will keep its
|
|
5539 relative position even if text is added to or removed from the buffer.
|
|
5540
|
|
5541 @item goto-char
|
|
5542 Set point to the location specified by the value of the argument, which
|
|
5543 can be a number, a marker, or an expression that returns the number of
|
|
5544 a position, such as @code{(point-min)}.
|
|
5545
|
|
5546 @item insert-buffer-substring
|
|
5547 Copy a region of text from a buffer that is passed to the function as
|
|
5548 an argument and insert the region into the current buffer.
|
|
5549
|
|
5550 @item mark-whole-buffer
|
|
5551 Mark the whole buffer as a region. Normally bound to @kbd{C-x h}.
|
|
5552
|
|
5553 @item set-buffer
|
|
5554 Switch the attention of Emacs to another buffer, but do not change the
|
|
5555 window being displayed. Used when the program rather than a human is
|
|
5556 to work on a different buffer.
|
|
5557
|
|
5558 @item get-buffer-create
|
|
5559 @itemx get-buffer
|
|
5560 Find a named buffer or create one if a buffer of that name does not
|
|
5561 exist. The @code{get-buffer} function returns @code{nil} if the named
|
|
5562 buffer does not exist.
|
|
5563 @end table
|
|
5564
|
|
5565 @need 1500
|
|
5566 @node Buffer Exercises, , Buffer Related Review, Buffer Walk Through
|
|
5567 @section Exercises
|
|
5568
|
|
5569 @itemize @bullet
|
|
5570 @item
|
|
5571 Write your own @code{simplified-end-of-buffer} function definition;
|
|
5572 then test it to see whether it works.
|
|
5573
|
|
5574 @item
|
|
5575 Use @code{if} and @code{get-buffer} to write a function that prints a
|
|
5576 message telling you whether a buffer exists.
|
|
5577
|
|
5578 @item
|
|
5579 Using @code{find-tag}, find the source for the @code{copy-to-buffer}
|
|
5580 function.
|
|
5581 @end itemize
|
|
5582
|
|
5583 @node More Complex, Narrowing & Widening, Buffer Walk Through, Top
|
|
5584 @comment node-name, next, previous, up
|
|
5585 @chapter A Few More Complex Functions
|
|
5586
|
|
5587 In this chapter, we build on what we have learned in previous chapters
|
|
5588 by looking at more complex functions. The @code{copy-to-buffer}
|
|
5589 function illustrates use of two @code{save-excursion} expressions in
|
|
5590 one definition, while the @code{insert-buffer} function illustrates
|
|
5591 use of an asterisk in an @code{interactive} expression, use of
|
|
5592 @code{or}, and the important distinction between a name and the object
|
|
5593 to which the name refers.
|
|
5594
|
|
5595 @menu
|
|
5596 * copy-to-buffer:: With @code{set-buffer}, @code{get-buffer-create}.
|
|
5597 * insert-buffer:: Read-only, and with @code{or}.
|
|
5598 * beginning-of-buffer:: Shows @code{goto-char},
|
|
5599 @code{point-min}, and @code{push-mark}.
|
|
5600 * Second Buffer Related Review::
|
|
5601 * optional Exercise::
|
|
5602 @end menu
|
|
5603
|
|
5604 @node copy-to-buffer, insert-buffer, More Complex, More Complex
|
|
5605 @comment node-name, next, previous, up
|
|
5606 @section The Definition of @code{copy-to-buffer}
|
|
5607 @findex copy-to-buffer
|
|
5608
|
|
5609 After understanding how @code{append-to-buffer} works, it is easy to
|
|
5610 understand @code{copy-to-buffer}. This function copies text into a
|
|
5611 buffer, but instead of adding to the second buffer, it replaces all the
|
|
5612 previous text in the second buffer.
|
|
5613
|
|
5614 @need 800
|
|
5615 The body of @code{copy-to-buffer} looks like this,
|
|
5616
|
|
5617 @smallexample
|
|
5618 @group
|
|
5619 @dots{}
|
|
5620 (interactive "BCopy to buffer: \nr")
|
|
5621 (let ((oldbuf (current-buffer)))
|
|
5622 (with-current-buffer (get-buffer-create buffer)
|
|
5623 (barf-if-buffer-read-only)
|
|
5624 (erase-buffer)
|
|
5625 (save-excursion
|
|
5626 (insert-buffer-substring oldbuf start end)))))
|
|
5627 @end group
|
|
5628 @end smallexample
|
|
5629
|
|
5630 The @code{copy-to-buffer} function has a simpler @code{interactive}
|
|
5631 expression than @code{append-to-buffer}.
|
|
5632
|
|
5633 @need 800
|
|
5634 The definition then says
|
|
5635
|
|
5636 @smallexample
|
|
5637 (with-current-buffer (get-buffer-create buffer) @dots{}
|
|
5638 @end smallexample
|
|
5639
|
|
5640 First, look at the earliest inner expression; that is evaluated first.
|
|
5641 That expression starts with @code{get-buffer-create buffer}. The
|
|
5642 function tells the computer to use the buffer with the name specified
|
|
5643 as the one to which you are copying, or if such a buffer does not
|
|
5644 exist, to create it. Then, the @code{with-current-buffer} function
|
|
5645 evaluates its body with that buffer temporarily current.
|
|
5646
|
|
5647 (This demonstrates another way to shift the computer's attention but
|
|
5648 not the user's. The @code{append-to-buffer} function showed how to do
|
|
5649 the same with @code{save-excursion} and @code{set-buffer}.
|
|
5650 @code{with-current-buffer} is a newer, and arguably easier,
|
|
5651 mechanism.)
|
|
5652
|
|
5653 The @code{barf-if-buffer-read-only} function sends you an error
|
|
5654 message saying the buffer is read-only if you cannot modify it.
|
|
5655
|
|
5656 The next line has the @code{erase-buffer} function as its sole
|
|
5657 contents. That function erases the buffer.
|
|
5658
|
|
5659 Finally, the last two lines contain the @code{save-excursion}
|
|
5660 expression with @code{insert-buffer-substring} as its body.
|
|
5661 The @code{insert-buffer-substring} expression copies the text from
|
|
5662 the buffer you are in (and you have not seen the computer shift its
|
|
5663 attention, so you don't know that that buffer is now called
|
|
5664 @code{oldbuf}).
|
|
5665
|
|
5666 Incidentally, this is what is meant by `replacement'. To replace text,
|
|
5667 Emacs erases the previous text and then inserts new text.
|
|
5668
|
|
5669 @need 1250
|
|
5670 In outline, the body of @code{copy-to-buffer} looks like this:
|
|
5671
|
|
5672 @smallexample
|
|
5673 @group
|
|
5674 (let (@var{bind-}@code{oldbuf}@var{-to-value-of-}@code{current-buffer})
|
|
5675 (@var{with-the-buffer-you-are-copying-to}
|
|
5676 (@var{but-do-not-erase-or-copy-to-a-read-only-buffer})
|
|
5677 (erase-buffer)
|
|
5678 (save-excursion
|
|
5679 @var{insert-substring-from-}@code{oldbuf}@var{-into-buffer})))
|
|
5680 @end group
|
|
5681 @end smallexample
|
|
5682
|
|
5683 @node insert-buffer, beginning-of-buffer, copy-to-buffer, More Complex
|
|
5684 @comment node-name, next, previous, up
|
|
5685 @section The Definition of @code{insert-buffer}
|
|
5686 @findex insert-buffer
|
|
5687
|
|
5688 @code{insert-buffer} is yet another buffer-related function. This
|
|
5689 command copies another buffer @emph{into} the current buffer. It is the
|
|
5690 reverse of @code{append-to-buffer} or @code{copy-to-buffer}, since they
|
|
5691 copy a region of text @emph{from} the current buffer to another buffer.
|
|
5692
|
|
5693 Here is a discussion based on the original code. The code was
|
|
5694 simplified in 2003 and is harder to understand.
|
|
5695
|
|
5696 (@xref{New insert-buffer, , New Body for @code{insert-buffer}}, to see
|
|
5697 a discussion of the new body.)
|
|
5698
|
|
5699 In addition, this code illustrates the use of @code{interactive} with a
|
|
5700 buffer that might be @dfn{read-only} and the important distinction
|
|
5701 between the name of an object and the object actually referred to.
|
|
5702
|
|
5703 @menu
|
|
5704 * insert-buffer code::
|
|
5705 * insert-buffer interactive:: When you can read, but not write.
|
|
5706 * insert-buffer body:: The body has an @code{or} and a @code{let}.
|
|
5707 * if & or:: Using an @code{if} instead of an @code{or}.
|
|
5708 * Insert or:: How the @code{or} expression works.
|
|
5709 * Insert let:: Two @code{save-excursion} expressions.
|
|
5710 * New insert-buffer::
|
|
5711 @end menu
|
|
5712
|
|
5713 @node insert-buffer code, insert-buffer interactive, insert-buffer, insert-buffer
|
|
5714 @ifnottex
|
|
5715 @unnumberedsubsec The Code for @code{insert-buffer}
|
|
5716 @end ifnottex
|
|
5717
|
|
5718 @need 800
|
|
5719 Here is the earlier code:
|
|
5720
|
|
5721 @smallexample
|
|
5722 @group
|
|
5723 (defun insert-buffer (buffer)
|
|
5724 "Insert after point the contents of BUFFER.
|
|
5725 Puts mark after the inserted text.
|
|
5726 BUFFER may be a buffer or a buffer name."
|
|
5727 (interactive "*bInsert buffer:@: ")
|
|
5728 @end group
|
|
5729 @group
|
|
5730 (or (bufferp buffer)
|
|
5731 (setq buffer (get-buffer buffer)))
|
|
5732 (let (start end newmark)
|
|
5733 (save-excursion
|
|
5734 (save-excursion
|
|
5735 (set-buffer buffer)
|
|
5736 (setq start (point-min) end (point-max)))
|
|
5737 @end group
|
|
5738 @group
|
|
5739 (insert-buffer-substring buffer start end)
|
|
5740 (setq newmark (point)))
|
|
5741 (push-mark newmark)))
|
|
5742 @end group
|
|
5743 @end smallexample
|
|
5744
|
|
5745 @need 1200
|
|
5746 As with other function definitions, you can use a template to see an
|
|
5747 outline of the function:
|
|
5748
|
|
5749 @smallexample
|
|
5750 @group
|
|
5751 (defun insert-buffer (buffer)
|
|
5752 "@var{documentation}@dots{}"
|
|
5753 (interactive "*bInsert buffer:@: ")
|
|
5754 @var{body}@dots{})
|
|
5755 @end group
|
|
5756 @end smallexample
|
|
5757
|
|
5758 @node insert-buffer interactive, insert-buffer body, insert-buffer code, insert-buffer
|
|
5759 @comment node-name, next, previous, up
|
|
5760 @subsection The Interactive Expression in @code{insert-buffer}
|
|
5761 @findex interactive, @r{example use of}
|
|
5762
|
|
5763 In @code{insert-buffer}, the argument to the @code{interactive}
|
|
5764 declaration has two parts, an asterisk, @samp{*}, and @samp{bInsert
|
|
5765 buffer:@: }.
|
|
5766
|
|
5767 @menu
|
|
5768 * Read-only buffer:: When a buffer cannot be modified.
|
|
5769 * b for interactive:: An existing buffer or else its name.
|
|
5770 @end menu
|
|
5771
|
|
5772 @node Read-only buffer, b for interactive, insert-buffer interactive, insert-buffer interactive
|
|
5773 @comment node-name, next, previous, up
|
|
5774 @unnumberedsubsubsec A Read-only Buffer
|
|
5775 @cindex Read-only buffer
|
|
5776 @cindex Asterisk for read-only buffer
|
|
5777 @findex * @r{for read-only buffer}
|
|
5778
|
|
5779 The asterisk is for the situation when the current buffer is a
|
|
5780 read-only buffer---a buffer that cannot be modified. If
|
|
5781 @code{insert-buffer} is called when the current buffer is read-only, a
|
|
5782 message to this effect is printed in the echo area and the terminal
|
|
5783 may beep or blink at you; you will not be permitted to insert anything
|
|
5784 into current buffer. The asterisk does not need to be followed by a
|
|
5785 newline to separate it from the next argument.
|
|
5786
|
|
5787 @node b for interactive, , Read-only buffer, insert-buffer interactive
|
|
5788 @comment node-name, next, previous, up
|
|
5789 @unnumberedsubsubsec @samp{b} in an Interactive Expression
|
|
5790
|
|
5791 The next argument in the interactive expression starts with a lower
|
|
5792 case @samp{b}. (This is different from the code for
|
|
5793 @code{append-to-buffer}, which uses an upper-case @samp{B}.
|
|
5794 @xref{append-to-buffer, , The Definition of @code{append-to-buffer}}.)
|
|
5795 The lower-case @samp{b} tells the Lisp interpreter that the argument
|
|
5796 for @code{insert-buffer} should be an existing buffer or else its
|
|
5797 name. (The upper-case @samp{B} option provides for the possibility
|
|
5798 that the buffer does not exist.) Emacs will prompt you for the name
|
|
5799 of the buffer, offering you a default buffer, with name completion
|
|
5800 enabled. If the buffer does not exist, you receive a message that
|
|
5801 says ``No match''; your terminal may beep at you as well.
|
|
5802
|
|
5803 The new and simplified code generates a list for @code{interactive}.
|
|
5804 It uses the @code{barf-if-buffer-read-only} and @code{read-buffer}
|
|
5805 functions with which we are already familiar and the @code{progn}
|
|
5806 special form with which we are not. (It will be described later.)
|
|
5807
|
|
5808 @node insert-buffer body, if & or, insert-buffer interactive, insert-buffer
|
|
5809 @comment node-name, next, previous, up
|
|
5810 @subsection The Body of the @code{insert-buffer} Function
|
|
5811
|
|
5812 The body of the @code{insert-buffer} function has two major parts: an
|
|
5813 @code{or} expression and a @code{let} expression. The purpose of the
|
|
5814 @code{or} expression is to ensure that the argument @code{buffer} is
|
|
5815 bound to a buffer and not just the name of a buffer. The body of the
|
|
5816 @code{let} expression contains the code which copies the other buffer
|
|
5817 into the current buffer.
|
|
5818
|
|
5819 @need 1250
|
|
5820 In outline, the two expressions fit into the @code{insert-buffer}
|
|
5821 function like this:
|
|
5822
|
|
5823 @smallexample
|
|
5824 @group
|
|
5825 (defun insert-buffer (buffer)
|
|
5826 "@var{documentation}@dots{}"
|
|
5827 (interactive "*bInsert buffer:@: ")
|
|
5828 (or @dots{}
|
|
5829 @dots{}
|
|
5830 @end group
|
|
5831 @group
|
|
5832 (let (@var{varlist})
|
|
5833 @var{body-of-}@code{let}@dots{} )
|
|
5834 @end group
|
|
5835 @end smallexample
|
|
5836
|
|
5837 To understand how the @code{or} expression ensures that the argument
|
|
5838 @code{buffer} is bound to a buffer and not to the name of a buffer, it
|
|
5839 is first necessary to understand the @code{or} function.
|
|
5840
|
|
5841 Before doing this, let me rewrite this part of the function using
|
|
5842 @code{if} so that you can see what is done in a manner that will be familiar.
|
|
5843
|
|
5844 @node if & or, Insert or, insert-buffer body, insert-buffer
|
|
5845 @comment node-name, next, previous, up
|
|
5846 @subsection @code{insert-buffer} With an @code{if} Instead of an @code{or}
|
|
5847
|
|
5848 The job to be done is to make sure the value of @code{buffer} is a
|
|
5849 buffer itself and not the name of a buffer. If the value is the name,
|
|
5850 then the buffer itself must be got.
|
|
5851
|
|
5852 You can imagine yourself at a conference where an usher is wandering
|
|
5853 around holding a list with your name on it and looking for you: the
|
|
5854 usher is ``bound'' to your name, not to you; but when the usher finds
|
|
5855 you and takes your arm, the usher becomes ``bound'' to you.
|
|
5856
|
|
5857 @need 800
|
|
5858 In Lisp, you might describe this situation like this:
|
|
5859
|
|
5860 @smallexample
|
|
5861 @group
|
|
5862 (if (not (holding-on-to-guest))
|
|
5863 (find-and-take-arm-of-guest))
|
|
5864 @end group
|
|
5865 @end smallexample
|
|
5866
|
|
5867 We want to do the same thing with a buffer---if we do not have the
|
|
5868 buffer itself, we want to get it.
|
|
5869
|
|
5870 @need 1200
|
|
5871 Using a predicate called @code{bufferp} that tells us whether we have a
|
|
5872 buffer (rather than its name), we can write the code like this:
|
|
5873
|
|
5874 @smallexample
|
|
5875 @group
|
|
5876 (if (not (bufferp buffer)) ; @r{if-part}
|
|
5877 (setq buffer (get-buffer buffer))) ; @r{then-part}
|
|
5878 @end group
|
|
5879 @end smallexample
|
|
5880
|
|
5881 @noindent
|
|
5882 Here, the true-or-false-test of the @code{if} expression is
|
|
5883 @w{@code{(not (bufferp buffer))}}; and the then-part is the expression
|
|
5884 @w{@code{(setq buffer (get-buffer buffer))}}.
|
|
5885
|
|
5886 In the test, the function @code{bufferp} returns true if its argument is
|
|
5887 a buffer---but false if its argument is the name of the buffer. (The
|
|
5888 last character of the function name @code{bufferp} is the character
|
|
5889 @samp{p}; as we saw earlier, such use of @samp{p} is a convention that
|
|
5890 indicates that the function is a predicate, which is a term that means
|
|
5891 that the function will determine whether some property is true or false.
|
|
5892 @xref{Wrong Type of Argument, , Using the Wrong Type Object as an
|
|
5893 Argument}.)
|
|
5894
|
|
5895 @need 1200
|
|
5896 The function @code{not} precedes the expression @code{(bufferp buffer)},
|
|
5897 so the true-or-false-test looks like this:
|
|
5898
|
|
5899 @smallexample
|
|
5900 (not (bufferp buffer))
|
|
5901 @end smallexample
|
|
5902
|
|
5903 @noindent
|
|
5904 @code{not} is a function that returns true if its argument is false
|
|
5905 and false if its argument is true. So if @code{(bufferp buffer)}
|
|
5906 returns true, the @code{not} expression returns false and vice-verse:
|
|
5907 what is ``not true'' is false and what is ``not false'' is true.
|
|
5908
|
|
5909 Using this test, the @code{if} expression works as follows: when the
|
|
5910 value of the variable @code{buffer} is actually a buffer rather than
|
|
5911 its name, the true-or-false-test returns false and the @code{if}
|
|
5912 expression does not evaluate the then-part. This is fine, since we do
|
|
5913 not need to do anything to the variable @code{buffer} if it really is
|
|
5914 a buffer.
|
|
5915
|
|
5916 On the other hand, when the value of @code{buffer} is not a buffer
|
|
5917 itself, but the name of a buffer, the true-or-false-test returns true
|
|
5918 and the then-part of the expression is evaluated. In this case, the
|
|
5919 then-part is @code{(setq buffer (get-buffer buffer))}. This
|
|
5920 expression uses the @code{get-buffer} function to return an actual
|
|
5921 buffer itself, given its name. The @code{setq} then sets the variable
|
|
5922 @code{buffer} to the value of the buffer itself, replacing its previous
|
|
5923 value (which was the name of the buffer).
|
|
5924
|
|
5925 @node Insert or, Insert let, if & or, insert-buffer
|
|
5926 @comment node-name, next, previous, up
|
|
5927 @subsection The @code{or} in the Body
|
|
5928
|
|
5929 The purpose of the @code{or} expression in the @code{insert-buffer}
|
|
5930 function is to ensure that the argument @code{buffer} is bound to a
|
|
5931 buffer and not just to the name of a buffer. The previous section shows
|
|
5932 how the job could have been done using an @code{if} expression.
|
|
5933 However, the @code{insert-buffer} function actually uses @code{or}.
|
|
5934 To understand this, it is necessary to understand how @code{or} works.
|
|
5935
|
|
5936 @findex or
|
|
5937 An @code{or} function can have any number of arguments. It evaluates
|
|
5938 each argument in turn and returns the value of the first of its
|
|
5939 arguments that is not @code{nil}. Also, and this is a crucial feature
|
|
5940 of @code{or}, it does not evaluate any subsequent arguments after
|
|
5941 returning the first non-@code{nil} value.
|
|
5942
|
|
5943 @need 800
|
|
5944 The @code{or} expression looks like this:
|
|
5945
|
|
5946 @smallexample
|
|
5947 @group
|
|
5948 (or (bufferp buffer)
|
|
5949 (setq buffer (get-buffer buffer)))
|
|
5950 @end group
|
|
5951 @end smallexample
|
|
5952
|
|
5953 @noindent
|
|
5954 The first argument to @code{or} is the expression @code{(bufferp buffer)}.
|
|
5955 This expression returns true (a non-@code{nil} value) if the buffer is
|
|
5956 actually a buffer, and not just the name of a buffer. In the @code{or}
|
|
5957 expression, if this is the case, the @code{or} expression returns this
|
|
5958 true value and does not evaluate the next expression---and this is fine
|
|
5959 with us, since we do not want to do anything to the value of
|
|
5960 @code{buffer} if it really is a buffer.
|
|
5961
|
|
5962 On the other hand, if the value of @code{(bufferp buffer)} is @code{nil},
|
|
5963 which it will be if the value of @code{buffer} is the name of a buffer,
|
|
5964 the Lisp interpreter evaluates the next element of the @code{or}
|
|
5965 expression. This is the expression @code{(setq buffer (get-buffer
|
|
5966 buffer))}. This expression returns a non-@code{nil} value, which
|
|
5967 is the value to which it sets the variable @code{buffer}---and this
|
|
5968 value is a buffer itself, not the name of a buffer.
|
|
5969
|
|
5970 The result of all this is that the symbol @code{buffer} is always
|
|
5971 bound to a buffer itself rather than to the name of a buffer. All
|
|
5972 this is necessary because the @code{set-buffer} function in a
|
|
5973 following line only works with a buffer itself, not with the name to a
|
|
5974 buffer.
|
|
5975
|
|
5976 @need 1250
|
|
5977 Incidentally, using @code{or}, the situation with the usher would be
|
|
5978 written like this:
|
|
5979
|
|
5980 @smallexample
|
|
5981 (or (holding-on-to-guest) (find-and-take-arm-of-guest))
|
|
5982 @end smallexample
|
|
5983
|
|
5984 @node Insert let, New insert-buffer, Insert or, insert-buffer
|
|
5985 @comment node-name, next, previous, up
|
|
5986 @subsection The @code{let} Expression in @code{insert-buffer}
|
|
5987
|
|
5988 After ensuring that the variable @code{buffer} refers to a buffer itself
|
|
5989 and not just to the name of a buffer, the @code{insert-buffer function}
|
|
5990 continues with a @code{let} expression. This specifies three local
|
|
5991 variables, @code{start}, @code{end}, and @code{newmark} and binds them
|
|
5992 to the initial value @code{nil}. These variables are used inside the
|
|
5993 remainder of the @code{let} and temporarily hide any other occurrence of
|
|
5994 variables of the same name in Emacs until the end of the @code{let}.
|
|
5995
|
|
5996 @need 1200
|
|
5997 The body of the @code{let} contains two @code{save-excursion}
|
|
5998 expressions. First, we will look at the inner @code{save-excursion}
|
|
5999 expression in detail. The expression looks like this:
|
|
6000
|
|
6001 @smallexample
|
|
6002 @group
|
|
6003 (save-excursion
|
|
6004 (set-buffer buffer)
|
|
6005 (setq start (point-min) end (point-max)))
|
|
6006 @end group
|
|
6007 @end smallexample
|
|
6008
|
|
6009 @noindent
|
|
6010 The expression @code{(set-buffer buffer)} changes Emacs' attention
|
|
6011 from the current buffer to the one from which the text will copied.
|
|
6012 In that buffer, the variables @code{start} and @code{end} are set to
|
|
6013 the beginning and end of the buffer, using the commands
|
|
6014 @code{point-min} and @code{point-max}. Note that we have here an
|
|
6015 illustration of how @code{setq} is able to set two variables in the
|
|
6016 same expression. The first argument of @code{setq} is set to the
|
|
6017 value of its second, and its third argument is set to the value of its
|
|
6018 fourth.
|
|
6019
|
|
6020 After the body of the inner @code{save-excursion} is evaluated, the
|
|
6021 @code{save-excursion} restores the original buffer, but @code{start} and
|
|
6022 @code{end} remain set to the values of the beginning and end of the
|
|
6023 buffer from which the text will be copied.
|
|
6024
|
|
6025 @need 1250
|
|
6026 The outer @code{save-excursion} expression looks like this:
|
|
6027
|
|
6028 @smallexample
|
|
6029 @group
|
|
6030 (save-excursion
|
|
6031 (@var{inner-}@code{save-excursion}@var{-expression}
|
|
6032 (@var{go-to-new-buffer-and-set-}@code{start}@var{-and-}@code{end})
|
|
6033 (insert-buffer-substring buffer start end)
|
|
6034 (setq newmark (point)))
|
|
6035 @end group
|
|
6036 @end smallexample
|
|
6037
|
|
6038 @noindent
|
|
6039 The @code{insert-buffer-substring} function copies the text
|
|
6040 @emph{into} the current buffer @emph{from} the region indicated by
|
|
6041 @code{start} and @code{end} in @code{buffer}. Since the whole of the
|
|
6042 second buffer lies between @code{start} and @code{end}, the whole of
|
|
6043 the second buffer is copied into the buffer you are editing. Next,
|
|
6044 the value of point, which will be at the end of the inserted text, is
|
|
6045 recorded in the variable @code{newmark}.
|
|
6046
|
|
6047 After the body of the outer @code{save-excursion} is evaluated, point
|
|
6048 and mark are relocated to their original places.
|
|
6049
|
|
6050 However, it is convenient to locate a mark at the end of the newly
|
|
6051 inserted text and locate point at its beginning. The @code{newmark}
|
|
6052 variable records the end of the inserted text. In the last line of
|
|
6053 the @code{let} expression, the @code{(push-mark newmark)} expression
|
|
6054 function sets a mark to this location. (The previous location of the
|
|
6055 mark is still accessible; it is recorded on the mark ring and you can
|
|
6056 go back to it with @kbd{C-u C-@key{SPC}}.) Meanwhile, point is
|
|
6057 located at the beginning of the inserted text, which is where it was
|
|
6058 before you called the insert function, the position of which was saved
|
|
6059 by the first @code{save-excursion}.
|
|
6060
|
|
6061 @need 1250
|
|
6062 The whole @code{let} expression looks like this:
|
|
6063
|
|
6064 @smallexample
|
|
6065 @group
|
|
6066 (let (start end newmark)
|
|
6067 (save-excursion
|
|
6068 (save-excursion
|
|
6069 (set-buffer buffer)
|
|
6070 (setq start (point-min) end (point-max)))
|
|
6071 (insert-buffer-substring buffer start end)
|
|
6072 (setq newmark (point)))
|
|
6073 (push-mark newmark))
|
|
6074 @end group
|
|
6075 @end smallexample
|
|
6076
|
|
6077 Like the @code{append-to-buffer} function, the @code{insert-buffer}
|
|
6078 function uses @code{let}, @code{save-excursion}, and
|
|
6079 @code{set-buffer}. In addition, the function illustrates one way to
|
|
6080 use @code{or}. All these functions are building blocks that we will
|
|
6081 find and use again and again.
|
|
6082
|
|
6083 @node New insert-buffer, , Insert let, insert-buffer
|
|
6084 @comment node-name, next, previous, up
|
|
6085 @subsection New Body for @code{insert-buffer}
|
|
6086 @findex insert-buffer, new version body
|
|
6087 @findex new version body for insert-buffer
|
|
6088
|
|
6089 The body in the GNU Emacs 22 version is more confusing than the original.
|
|
6090
|
|
6091 @need 1250
|
|
6092 It consists of two expressions,
|
|
6093
|
|
6094 @smallexample
|
|
6095 @group
|
|
6096 (push-mark
|
|
6097 (save-excursion
|
|
6098 (insert-buffer-substring (get-buffer buffer))
|
|
6099 (point)))
|
|
6100
|
|
6101 nil
|
|
6102 @end group
|
|
6103 @end smallexample
|
|
6104
|
|
6105 @noindent
|
|
6106 except, and this is what confuses novices, very important work is done
|
|
6107 inside the @code{push-mark} expression.
|
|
6108
|
|
6109 The @code{get-buffer} function returns a buffer with the name
|
|
6110 provided. You will note that the function is @emph{not} called
|
|
6111 @code{get-buffer-create}; it does not create a buffer if one does not
|
|
6112 already exist. The buffer returned by @code{get-buffer}, an existing
|
|
6113 buffer, is passed to @code{insert-buffer-substring}, which inserts the
|
|
6114 whole of the buffer (since you did not specify anything else).
|
|
6115
|
|
6116 The location into which the buffer is inserted is recorded by
|
|
6117 @code{push-mark}. Then the function returns @code{nil}, the value of
|
|
6118 its last command. Put another way, the @code{insert-buffer} function
|
|
6119 exists only to produce a side effect, inserting another buffer, not to
|
|
6120 return any value.
|
|
6121
|
|
6122 @node beginning-of-buffer, Second Buffer Related Review, insert-buffer, More Complex
|
|
6123 @comment node-name, next, previous, up
|
|
6124 @section Complete Definition of @code{beginning-of-buffer}
|
|
6125 @findex beginning-of-buffer
|
|
6126
|
|
6127 The basic structure of the @code{beginning-of-buffer} function has
|
|
6128 already been discussed. (@xref{simplified-beginning-of-buffer, , A
|
|
6129 Simplified @code{beginning-of-buffer} Definition}.)
|
|
6130 This section describes the complex part of the definition.
|
|
6131
|
|
6132 As previously described, when invoked without an argument,
|
|
6133 @code{beginning-of-buffer} moves the cursor to the beginning of the
|
|
6134 buffer (in truth, the beginning of the accessible portion of the
|
|
6135 buffer), leaving the mark at the previous position. However, when the
|
|
6136 command is invoked with a number between one and ten, the function
|
|
6137 considers that number to be a fraction of the length of the buffer,
|
|
6138 measured in tenths, and Emacs moves the cursor that fraction of the
|
|
6139 way from the beginning of the buffer. Thus, you can either call this
|
|
6140 function with the key command @kbd{M-<}, which will move the cursor to
|
|
6141 the beginning of the buffer, or with a key command such as @kbd{C-u 7
|
|
6142 M-<} which will move the cursor to a point 70% of the way through the
|
|
6143 buffer. If a number bigger than ten is used for the argument, it
|
|
6144 moves to the end of the buffer.
|
|
6145
|
|
6146 The @code{beginning-of-buffer} function can be called with or without an
|
|
6147 argument. The use of the argument is optional.
|
|
6148
|
|
6149 @menu
|
|
6150 * Optional Arguments::
|
|
6151 * beginning-of-buffer opt arg:: Example with optional argument.
|
|
6152 * beginning-of-buffer complete::
|
|
6153 @end menu
|
|
6154
|
|
6155 @node Optional Arguments, beginning-of-buffer opt arg, beginning-of-buffer, beginning-of-buffer
|
|
6156 @subsection Optional Arguments
|
|
6157
|
|
6158 Unless told otherwise, Lisp expects that a function with an argument in
|
|
6159 its function definition will be called with a value for that argument.
|
|
6160 If that does not happen, you get an error and a message that says
|
|
6161 @samp{Wrong number of arguments}.
|
|
6162
|
|
6163 @cindex Optional arguments
|
|
6164 @cindex Keyword
|
|
6165 @findex optional
|
|
6166 However, optional arguments are a feature of Lisp: a particular
|
|
6167 @dfn{keyword} is used to tell the Lisp interpreter that an argument is
|
|
6168 optional. The keyword is @code{&optional}. (The @samp{&} in front of
|
|
6169 @samp{optional} is part of the keyword.) In a function definition, if
|
|
6170 an argument follows the keyword @code{&optional}, no value need be
|
|
6171 passed to that argument when the function is called.
|
|
6172
|
|
6173 @need 1200
|
|
6174 The first line of the function definition of @code{beginning-of-buffer}
|
|
6175 therefore looks like this:
|
|
6176
|
|
6177 @smallexample
|
|
6178 (defun beginning-of-buffer (&optional arg)
|
|
6179 @end smallexample
|
|
6180
|
|
6181 @need 1250
|
|
6182 In outline, the whole function looks like this:
|
|
6183
|
|
6184 @smallexample
|
|
6185 @group
|
|
6186 (defun beginning-of-buffer (&optional arg)
|
|
6187 "@var{documentation}@dots{}"
|
|
6188 (interactive "P")
|
|
6189 (or (@var{is-the-argument-a-cons-cell} arg)
|
|
6190 (and @var{are-both-transient-mark-mode-and-mark-active-true})
|
|
6191 (push-mark))
|
|
6192 (let (@var{determine-size-and-set-it})
|
|
6193 (goto-char
|
|
6194 (@var{if-there-is-an-argument}
|
|
6195 @var{figure-out-where-to-go}
|
|
6196 @var{else-go-to}
|
|
6197 (point-min))))
|
|
6198 @var{do-nicety}
|
|
6199 @end group
|
|
6200 @end smallexample
|
|
6201
|
|
6202 The function is similar to the @code{simplified-beginning-of-buffer}
|
|
6203 function except that the @code{interactive} expression has @code{"P"}
|
|
6204 as an argument and the @code{goto-char} function is followed by an
|
|
6205 if-then-else expression that figures out where to put the cursor if
|
|
6206 there is an argument that is not a cons cell.
|
|
6207
|
|
6208 (Since I do not explain a cons cell for many more chapters, please
|
|
6209 consider ignoring the function @code{consp}. @xref{List
|
|
6210 Implementation, , How Lists are Implemented}, and @ref{Cons Cell Type,
|
|
6211 , Cons Cell and List Types, elisp, The GNU Emacs Lisp Reference
|
|
6212 Manual}.)
|
|
6213
|
|
6214 The @code{"P"} in the @code{interactive} expression tells Emacs to
|
|
6215 pass a prefix argument, if there is one, to the function in raw form.
|
|
6216 A prefix argument is made by typing the @key{META} key followed by a
|
|
6217 number, or by typing @kbd{C-u} and then a number. (If you don't type
|
|
6218 a number, @kbd{C-u} defaults to a cons cell with a 4. A lowercase
|
|
6219 @code{"p"} in the @code{interactive} expression causes the function to
|
|
6220 convert a prefix arg to a number.)
|
|
6221
|
|
6222 The true-or-false-test of the @code{if} expression looks complex, but
|
|
6223 it is not: it checks whether @code{arg} has a value that is not
|
|
6224 @code{nil} and whether it is a cons cell. (That is what @code{consp}
|
|
6225 does; it checks whether its argument is a cons cell.) If @code{arg}
|
|
6226 has a value that is not @code{nil} (and is not a cons cell), which
|
|
6227 will be the case if @code{beginning-of-buffer} is called with a
|
|
6228 numeric argument, then this true-or-false-test will return true and
|
|
6229 the then-part of the @code{if} expression will be evaluated. On the
|
|
6230 other hand, if @code{beginning-of-buffer} is not called with an
|
|
6231 argument, the value of @code{arg} will be @code{nil} and the else-part
|
|
6232 of the @code{if} expression will be evaluated. The else-part is
|
|
6233 simply @code{point-min}, and when this is the outcome, the whole
|
|
6234 @code{goto-char} expression is @code{(goto-char (point-min))}, which
|
|
6235 is how we saw the @code{beginning-of-buffer} function in its
|
|
6236 simplified form.
|
|
6237
|
|
6238 @node beginning-of-buffer opt arg, beginning-of-buffer complete, Optional Arguments, beginning-of-buffer
|
|
6239 @subsection @code{beginning-of-buffer} with an Argument
|
|
6240
|
|
6241 When @code{beginning-of-buffer} is called with an argument, an
|
|
6242 expression is evaluated which calculates what value to pass to
|
|
6243 @code{goto-char}. This expression is rather complicated at first sight.
|
|
6244 It includes an inner @code{if} expression and much arithmetic. It looks
|
|
6245 like this:
|
|
6246
|
|
6247 @smallexample
|
|
6248 @group
|
|
6249 (if (> (buffer-size) 10000)
|
|
6250 ;; @r{Avoid overflow for large buffer sizes!}
|
|
6251 (* (prefix-numeric-value arg)
|
|
6252 (/ size 10))
|
|
6253 (/
|
|
6254 (+ 10
|
|
6255 (*
|
|
6256 size (prefix-numeric-value arg))) 10)))
|
|
6257 @end group
|
|
6258 @end smallexample
|
|
6259
|
|
6260 @menu
|
|
6261 * Disentangle beginning-of-buffer::
|
|
6262 * Large buffer case::
|
|
6263 * Small buffer case::
|
|
6264 @end menu
|
|
6265
|
|
6266 @node Disentangle beginning-of-buffer, Large buffer case, beginning-of-buffer opt arg, beginning-of-buffer opt arg
|
|
6267 @ifnottex
|
|
6268 @unnumberedsubsubsec Disentangle @code{beginning-of-buffer}
|
|
6269 @end ifnottex
|
|
6270
|
|
6271 Like other complex-looking expressions, the conditional expression
|
|
6272 within @code{beginning-of-buffer} can be disentangled by looking at it
|
|
6273 as parts of a template, in this case, the template for an if-then-else
|
|
6274 expression. In skeletal form, the expression looks like this:
|
|
6275
|
|
6276 @smallexample
|
|
6277 @group
|
|
6278 (if (@var{buffer-is-large}
|
|
6279 @var{divide-buffer-size-by-10-and-multiply-by-arg}
|
|
6280 @var{else-use-alternate-calculation}
|
|
6281 @end group
|
|
6282 @end smallexample
|
|
6283
|
|
6284 The true-or-false-test of this inner @code{if} expression checks the
|
|
6285 size of the buffer. The reason for this is that the old version 18
|
|
6286 Emacs used numbers that are no bigger than eight million or so and in
|
|
6287 the computation that followed, the programmer feared that Emacs might
|
|
6288 try to use over-large numbers if the buffer were large. The term
|
|
6289 `overflow', mentioned in the comment, means numbers that are over
|
|
6290 large. More recent versions of Emacs use larger numbers, but this
|
|
6291 code has not been touched, if only because people now look at buffers
|
|
6292 that are far, far larger than ever before.
|
|
6293
|
|
6294 There are two cases: if the buffer is large and if it is not.
|
|
6295
|
|
6296 @node Large buffer case, Small buffer case, Disentangle beginning-of-buffer, beginning-of-buffer opt arg
|
|
6297 @comment node-name, next, previous, up
|
|
6298 @unnumberedsubsubsec What happens in a large buffer
|
|
6299
|
|
6300 In @code{beginning-of-buffer}, the inner @code{if} expression tests
|
|
6301 whether the size of the buffer is greater than 10,000 characters. To do
|
|
6302 this, it uses the @code{>} function and the computation of @code{size}
|
|
6303 that comes from the let expression.
|
|
6304
|
|
6305 In the old days, the function @code{buffer-size} was used. Not only
|
|
6306 was that function called several times, it gave the size of the whole
|
|
6307 buffer, not the accessible part. The computation makes much more
|
|
6308 sense when it handles just the accessible part. (@xref{Narrowing &
|
|
6309 Widening, , Narrowing and Widening}, for more information on focusing
|
|
6310 attention to an `accessible' part.)
|
|
6311
|
|
6312 @need 800
|
|
6313 The line looks like this:
|
|
6314
|
|
6315 @smallexample
|
|
6316 (if (> size 10000)
|
|
6317 @end smallexample
|
|
6318
|
|
6319 @need 1200
|
|
6320 @noindent
|
|
6321 When the buffer is large, the then-part of the @code{if} expression is
|
|
6322 evaluated. It reads like this (after formatting for easy reading):
|
|
6323
|
|
6324 @smallexample
|
|
6325 @group
|
|
6326 (*
|
|
6327 (prefix-numeric-value arg)
|
|
6328 (/ size 10))
|
|
6329 @end group
|
|
6330 @end smallexample
|
|
6331
|
|
6332 @noindent
|
|
6333 This expression is a multiplication, with two arguments to the function
|
|
6334 @code{*}.
|
|
6335
|
|
6336 The first argument is @code{(prefix-numeric-value arg)}. When
|
|
6337 @code{"P"} is used as the argument for @code{interactive}, the value
|
|
6338 passed to the function as its argument is passed a ``raw prefix
|
|
6339 argument'', and not a number. (It is a number in a list.) To perform
|
|
6340 the arithmetic, a conversion is necessary, and
|
|
6341 @code{prefix-numeric-value} does the job.
|
|
6342
|
|
6343 @findex / @r{(division)}
|
|
6344 @cindex Division
|
|
6345 The second argument is @code{(/ size 10)}. This expression divides
|
|
6346 the numeric value by ten --- the numeric value of the size of the
|
|
6347 accessible portion of the buffer. This produces a number that tells
|
|
6348 how many characters make up one tenth of the buffer size. (In Lisp,
|
|
6349 @code{/} is used for division, just as @code{*} is used for
|
|
6350 multiplication.)
|
|
6351
|
|
6352 @need 1200
|
|
6353 In the multiplication expression as a whole, this amount is multiplied
|
|
6354 by the value of the prefix argument---the multiplication looks like this:
|
|
6355
|
|
6356 @smallexample
|
|
6357 @group
|
|
6358 (* @var{numeric-value-of-prefix-arg}
|
|
6359 @var{number-of-characters-in-one-tenth-of-the-accessible-buffer})
|
|
6360 @end group
|
|
6361 @end smallexample
|
|
6362
|
|
6363 @noindent
|
|
6364 If, for example, the prefix argument is @samp{7}, the one-tenth value
|
|
6365 will be multiplied by 7 to give a position 70% of the way through.
|
|
6366
|
|
6367 @need 1200
|
|
6368 The result of all this is that if the accessible portion of the buffer
|
|
6369 is large, the @code{goto-char} expression reads like this:
|
|
6370
|
|
6371 @smallexample
|
|
6372 @group
|
|
6373 (goto-char (* (prefix-numeric-value arg)
|
|
6374 (/ size 10)))
|
|
6375 @end group
|
|
6376 @end smallexample
|
|
6377
|
|
6378 This puts the cursor where we want it.
|
|
6379
|
|
6380 @node Small buffer case, , Large buffer case, beginning-of-buffer opt arg
|
|
6381 @comment node-name, next, previous, up
|
|
6382 @unnumberedsubsubsec What happens in a small buffer
|
|
6383
|
|
6384 If the buffer contains fewer than 10,000 characters, a slightly
|
|
6385 different computation is performed. You might think this is not
|
|
6386 necessary, since the first computation could do the job. However, in
|
|
6387 a small buffer, the first method may not put the cursor on exactly the
|
|
6388 desired line; the second method does a better job.
|
|
6389
|
|
6390 @need 800
|
|
6391 The code looks like this:
|
|
6392
|
|
6393 @c Keep this on one line.
|
|
6394 @smallexample
|
|
6395 (/ (+ 10 (* size (prefix-numeric-value arg))) 10))
|
|
6396 @end smallexample
|
|
6397
|
|
6398 @need 1200
|
|
6399 @noindent
|
|
6400 This is code in which you figure out what happens by discovering how the
|
|
6401 functions are embedded in parentheses. It is easier to read if you
|
|
6402 reformat it with each expression indented more deeply than its
|
|
6403 enclosing expression:
|
|
6404
|
|
6405 @smallexample
|
|
6406 @group
|
|
6407 (/
|
|
6408 (+ 10
|
|
6409 (*
|
|
6410 size
|
|
6411 (prefix-numeric-value arg)))
|
|
6412 10))
|
|
6413 @end group
|
|
6414 @end smallexample
|
|
6415
|
|
6416 @need 1200
|
|
6417 @noindent
|
|
6418 Looking at parentheses, we see that the innermost operation is
|
|
6419 @code{(prefix-numeric-value arg)}, which converts the raw argument to
|
|
6420 a number. In the following expression, this number is multiplied by
|
|
6421 the size of the accessible portion of the buffer:
|
|
6422
|
|
6423 @smallexample
|
|
6424 (* size (prefix-numeric-value arg))
|
|
6425 @end smallexample
|
|
6426
|
|
6427 @noindent
|
|
6428 This multiplication creates a number that may be larger than the size of
|
|
6429 the buffer---seven times larger if the argument is 7, for example. Ten
|
|
6430 is then added to this number and finally the large number is divided by
|
|
6431 ten to provide a value that is one character larger than the percentage
|
|
6432 position in the buffer.
|
|
6433
|
|
6434 The number that results from all this is passed to @code{goto-char} and
|
|
6435 the cursor is moved to that point.
|
|
6436
|
|
6437 @need 1500
|
|
6438 @node beginning-of-buffer complete, , beginning-of-buffer opt arg, beginning-of-buffer
|
|
6439 @comment node-name, next, previous, up
|
|
6440 @subsection The Complete @code{beginning-of-buffer}
|
|
6441
|
|
6442 @need 1000
|
|
6443 Here is the complete text of the @code{beginning-of-buffer} function:
|
|
6444 @sp 1
|
|
6445
|
|
6446 @c In GNU Emacs 22
|
|
6447 @smallexample
|
|
6448 @group
|
|
6449 (defun beginning-of-buffer (&optional arg)
|
|
6450 "Move point to the beginning of the buffer;
|
|
6451 leave mark at previous position.
|
|
6452 With \\[universal-argument] prefix,
|
|
6453 do not set mark at previous position.
|
|
6454 With numeric arg N,
|
|
6455 put point N/10 of the way from the beginning.
|
|
6456
|
|
6457 If the buffer is narrowed,
|
|
6458 this command uses the beginning and size
|
|
6459 of the accessible part of the buffer.
|
|
6460 @end group
|
|
6461
|
|
6462 @group
|
|
6463 Don't use this command in Lisp programs!
|
|
6464 \(goto-char (point-min)) is faster
|
|
6465 and avoids clobbering the mark."
|
|
6466 (interactive "P")
|
|
6467 (or (consp arg)
|
|
6468 (and transient-mark-mode mark-active)
|
|
6469 (push-mark))
|
|
6470 @end group
|
|
6471 @group
|
|
6472 (let ((size (- (point-max) (point-min))))
|
|
6473 (goto-char (if (and arg (not (consp arg)))
|
|
6474 (+ (point-min)
|
|
6475 (if (> size 10000)
|
|
6476 ;; Avoid overflow for large buffer sizes!
|
|
6477 (* (prefix-numeric-value arg)
|
|
6478 (/ size 10))
|
98525
|
6479 (/ (+ 10 (* size (prefix-numeric-value arg)))
|
|
6480 10)))
|
83955
|
6481 (point-min))))
|
|
6482 (if arg (forward-line 1)))
|
|
6483 @end group
|
|
6484 @end smallexample
|
|
6485
|
|
6486 @ignore
|
|
6487 From before GNU Emacs 22
|
|
6488 @smallexample
|
|
6489 @group
|
|
6490 (defun beginning-of-buffer (&optional arg)
|
|
6491 "Move point to the beginning of the buffer;
|
|
6492 leave mark at previous position.
|
|
6493 With arg N, put point N/10 of the way
|
|
6494 from the true beginning.
|
|
6495 @end group
|
|
6496 @group
|
|
6497 Don't use this in Lisp programs!
|
|
6498 \(goto-char (point-min)) is faster
|
|
6499 and does not set the mark."
|
|
6500 (interactive "P")
|
|
6501 (push-mark)
|
|
6502 @end group
|
|
6503 @group
|
|
6504 (goto-char
|
|
6505 (if arg
|
|
6506 (if (> (buffer-size) 10000)
|
|
6507 ;; @r{Avoid overflow for large buffer sizes!}
|
|
6508 (* (prefix-numeric-value arg)
|
|
6509 (/ (buffer-size) 10))
|
|
6510 @end group
|
|
6511 @group
|
|
6512 (/ (+ 10 (* (buffer-size)
|
|
6513 (prefix-numeric-value arg)))
|
|
6514 10))
|
|
6515 (point-min)))
|
|
6516 (if arg (forward-line 1)))
|
|
6517 @end group
|
|
6518 @end smallexample
|
|
6519 @end ignore
|
|
6520
|
|
6521 @noindent
|
|
6522 Except for two small points, the previous discussion shows how this
|
|
6523 function works. The first point deals with a detail in the
|
|
6524 documentation string, and the second point concerns the last line of
|
|
6525 the function.
|
|
6526
|
|
6527 @need 800
|
|
6528 In the documentation string, there is reference to an expression:
|
|
6529
|
|
6530 @smallexample
|
|
6531 \\[universal-argument]
|
|
6532 @end smallexample
|
|
6533
|
|
6534 @noindent
|
|
6535 A @samp{\\} is used before the first square bracket of this
|
|
6536 expression. This @samp{\\} tells the Lisp interpreter to substitute
|
|
6537 whatever key is currently bound to the @samp{[@dots{}]}. In the case
|
|
6538 of @code{universal-argument}, that is usually @kbd{C-u}, but it might
|
|
6539 be different. (@xref{Documentation Tips, , Tips for Documentation
|
|
6540 Strings, elisp, The GNU Emacs Lisp Reference Manual}, for more
|
|
6541 information.)
|
|
6542
|
|
6543 @need 1200
|
|
6544 Finally, the last line of the @code{beginning-of-buffer} command says
|
|
6545 to move point to the beginning of the next line if the command is
|
|
6546 invoked with an argument:
|
|
6547
|
|
6548 @smallexample
|
|
6549 (if arg (forward-line 1)))
|
|
6550 @end smallexample
|
|
6551
|
|
6552 @noindent
|
|
6553 This puts the cursor at the beginning of the first line after the
|
|
6554 appropriate tenths position in the buffer. This is a flourish that
|
|
6555 means that the cursor is always located @emph{at least} the requested
|
|
6556 tenths of the way through the buffer, which is a nicety that is,
|
|
6557 perhaps, not necessary, but which, if it did not occur, would be sure
|
|
6558 to draw complaints.
|
|
6559
|
|
6560 On the other hand, it also means that if you specify the command with
|
|
6561 a @kbd{C-u}, but without a number, that is to say, if the `raw prefix
|
|
6562 argument' is simply a cons cell, then the command puts you at the
|
|
6563 beginning of the second line @dots{} I don't know whether this is
|
|
6564 intended or whether no one has dealt with the code to avoid this
|
|
6565 happening.
|
|
6566
|
|
6567 @node Second Buffer Related Review, optional Exercise, beginning-of-buffer, More Complex
|
|
6568 @comment node-name, next, previous, up
|
|
6569 @section Review
|
|
6570
|
|
6571 Here is a brief summary of some of the topics covered in this chapter.
|
|
6572
|
|
6573 @table @code
|
|
6574 @item or
|
|
6575 Evaluate each argument in sequence, and return the value of the first
|
|
6576 argument that is not @code{nil}; if none return a value that is not
|
|
6577 @code{nil}, return @code{nil}. In brief, return the first true value
|
|
6578 of the arguments; return a true value if one @emph{or} any of the
|
|
6579 others are true.
|
|
6580
|
|
6581 @item and
|
|
6582 Evaluate each argument in sequence, and if any are @code{nil}, return
|
|
6583 @code{nil}; if none are @code{nil}, return the value of the last
|
|
6584 argument. In brief, return a true value only if all the arguments are
|
|
6585 true; return a true value if one @emph{and} each of the others is
|
|
6586 true.
|
|
6587
|
|
6588 @item &optional
|
|
6589 A keyword used to indicate that an argument to a function definition
|
|
6590 is optional; this means that the function can be evaluated without the
|
|
6591 argument, if desired.
|
|
6592
|
|
6593 @item prefix-numeric-value
|
|
6594 Convert the `raw prefix argument' produced by @code{(interactive
|
|
6595 "P")} to a numeric value.
|
|
6596
|
|
6597 @item forward-line
|
|
6598 Move point forward to the beginning of the next line, or if the argument
|
|
6599 is greater than one, forward that many lines. If it can't move as far
|
|
6600 forward as it is supposed to, @code{forward-line} goes forward as far as
|
|
6601 it can and then returns a count of the number of additional lines it was
|
|
6602 supposed to move but couldn't.
|
|
6603
|
|
6604 @item erase-buffer
|
|
6605 Delete the entire contents of the current buffer.
|
|
6606
|
|
6607 @item bufferp
|
|
6608 Return @code{t} if its argument is a buffer; otherwise return @code{nil}.
|
|
6609 @end table
|
|
6610
|
|
6611 @node optional Exercise, , Second Buffer Related Review, More Complex
|
|
6612 @section @code{optional} Argument Exercise
|
|
6613
|
|
6614 Write an interactive function with an optional argument that tests
|
|
6615 whether its argument, a number, is greater than or equal to, or else,
|
|
6616 less than the value of @code{fill-column}, and tells you which, in a
|
|
6617 message. However, if you do not pass an argument to the function, use
|
|
6618 56 as a default value.
|
|
6619
|
|
6620 @node Narrowing & Widening, car cdr & cons, More Complex, Top
|
|
6621 @comment node-name, next, previous, up
|
|
6622 @chapter Narrowing and Widening
|
|
6623 @cindex Focusing attention (narrowing)
|
|
6624 @cindex Narrowing
|
|
6625 @cindex Widening
|
|
6626
|
|
6627 Narrowing is a feature of Emacs that makes it possible for you to focus
|
|
6628 on a specific part of a buffer, and work without accidentally changing
|
|
6629 other parts. Narrowing is normally disabled since it can confuse
|
|
6630 novices.
|
|
6631
|
|
6632 @menu
|
|
6633 * Narrowing advantages:: The advantages of narrowing
|
|
6634 * save-restriction:: The @code{save-restriction} special form.
|
|
6635 * what-line:: The number of the line that point is on.
|
|
6636 * narrow Exercise::
|
|
6637 @end menu
|
|
6638
|
|
6639 @node Narrowing advantages, save-restriction, Narrowing & Widening, Narrowing & Widening
|
|
6640 @ifnottex
|
|
6641 @unnumberedsec The Advantages of Narrowing
|
|
6642 @end ifnottex
|
|
6643
|
|
6644 With narrowing, the rest of a buffer is made invisible, as if it weren't
|
|
6645 there. This is an advantage if, for example, you want to replace a word
|
|
6646 in one part of a buffer but not in another: you narrow to the part you want
|
|
6647 and the replacement is carried out only in that section, not in the rest
|
|
6648 of the buffer. Searches will only work within a narrowed region, not
|
|
6649 outside of one, so if you are fixing a part of a document, you can keep
|
|
6650 yourself from accidentally finding parts you do not need to fix by
|
|
6651 narrowing just to the region you want.
|
|
6652 (The key binding for @code{narrow-to-region} is @kbd{C-x n n}.)
|
|
6653
|
|
6654 However, narrowing does make the rest of the buffer invisible, which
|
|
6655 can scare people who inadvertently invoke narrowing and think they
|
|
6656 have deleted a part of their file. Moreover, the @code{undo} command
|
|
6657 (which is usually bound to @kbd{C-x u}) does not turn off narrowing
|
|
6658 (nor should it), so people can become quite desperate if they do not
|
|
6659 know that they can return the rest of a buffer to visibility with the
|
|
6660 @code{widen} command.
|
|
6661 (The key binding for @code{widen} is @kbd{C-x n w}.)
|
|
6662
|
|
6663 Narrowing is just as useful to the Lisp interpreter as to a human.
|
|
6664 Often, an Emacs Lisp function is designed to work on just part of a
|
|
6665 buffer; or conversely, an Emacs Lisp function needs to work on all of a
|
|
6666 buffer that has been narrowed. The @code{what-line} function, for
|
|
6667 example, removes the narrowing from a buffer, if it has any narrowing
|
|
6668 and when it has finished its job, restores the narrowing to what it was.
|
|
6669 On the other hand, the @code{count-lines} function, which is called by
|
|
6670 @code{what-line}, uses narrowing to restrict itself to just that portion
|
|
6671 of the buffer in which it is interested and then restores the previous
|
|
6672 situation.
|
|
6673
|
|
6674 @node save-restriction, what-line, Narrowing advantages, Narrowing & Widening
|
|
6675 @comment node-name, next, previous, up
|
|
6676 @section The @code{save-restriction} Special Form
|
|
6677 @findex save-restriction
|
|
6678
|
|
6679 In Emacs Lisp, you can use the @code{save-restriction} special form to
|
|
6680 keep track of whatever narrowing is in effect, if any. When the Lisp
|
|
6681 interpreter meets with @code{save-restriction}, it executes the code
|
|
6682 in the body of the @code{save-restriction} expression, and then undoes
|
|
6683 any changes to narrowing that the code caused. If, for example, the
|
|
6684 buffer is narrowed and the code that follows @code{save-restriction}
|
|
6685 gets rid of the narrowing, @code{save-restriction} returns the buffer
|
|
6686 to its narrowed region afterwards. In the @code{what-line} command,
|
|
6687 any narrowing the buffer may have is undone by the @code{widen}
|
|
6688 command that immediately follows the @code{save-restriction} command.
|
|
6689 Any original narrowing is restored just before the completion of the
|
|
6690 function.
|
|
6691
|
|
6692 @need 1250
|
|
6693 The template for a @code{save-restriction} expression is simple:
|
|
6694
|
|
6695 @smallexample
|
|
6696 @group
|
|
6697 (save-restriction
|
|
6698 @var{body}@dots{} )
|
|
6699 @end group
|
|
6700 @end smallexample
|
|
6701
|
|
6702 @noindent
|
|
6703 The body of the @code{save-restriction} is one or more expressions that
|
|
6704 will be evaluated in sequence by the Lisp interpreter.
|
|
6705
|
|
6706 Finally, a point to note: when you use both @code{save-excursion} and
|
|
6707 @code{save-restriction}, one right after the other, you should use
|
|
6708 @code{save-excursion} outermost. If you write them in reverse order,
|
|
6709 you may fail to record narrowing in the buffer to which Emacs switches
|
|
6710 after calling @code{save-excursion}. Thus, when written together,
|
|
6711 @code{save-excursion} and @code{save-restriction} should be written
|
|
6712 like this:
|
|
6713
|
|
6714 @smallexample
|
|
6715 @group
|
|
6716 (save-excursion
|
|
6717 (save-restriction
|
|
6718 @var{body}@dots{}))
|
|
6719 @end group
|
|
6720 @end smallexample
|
|
6721
|
|
6722 In other circumstances, when not written together, the
|
|
6723 @code{save-excursion} and @code{save-restriction} special forms must
|
|
6724 be written in the order appropriate to the function.
|
|
6725
|
|
6726 @need 1250
|
|
6727 For example,
|
|
6728
|
|
6729 @smallexample
|
|
6730 @group
|
|
6731 (save-restriction
|
|
6732 (widen)
|
|
6733 (save-excursion
|
|
6734 @var{body}@dots{}))
|
|
6735 @end group
|
|
6736 @end smallexample
|
|
6737
|
|
6738 @ignore
|
|
6739 Emacs 22
|
|
6740 /usr/local/src/emacs/lisp/simple.el
|
|
6741
|
|
6742 (defun what-line ()
|
|
6743 "Print the current buffer line number and narrowed line number of point."
|
|
6744 (interactive)
|
|
6745 (let ((start (point-min))
|
|
6746 (n (line-number-at-pos)))
|
|
6747 (if (= start 1)
|
|
6748 (message "Line %d" n)
|
|
6749 (save-excursion
|
|
6750 (save-restriction
|
|
6751 (widen)
|
|
6752 (message "line %d (narrowed line %d)"
|
|
6753 (+ n (line-number-at-pos start) -1) n))))))
|
|
6754
|
|
6755 (defun line-number-at-pos (&optional pos)
|
|
6756 "Return (narrowed) buffer line number at position POS.
|
|
6757 If POS is nil, use current buffer location.
|
|
6758 Counting starts at (point-min), so the value refers
|
|
6759 to the contents of the accessible portion of the buffer."
|
|
6760 (let ((opoint (or pos (point))) start)
|
|
6761 (save-excursion
|
|
6762 (goto-char (point-min))
|
|
6763 (setq start (point))
|
|
6764 (goto-char opoint)
|
|
6765 (forward-line 0)
|
|
6766 (1+ (count-lines start (point))))))
|
|
6767
|
|
6768 (defun count-lines (start end)
|
|
6769 "Return number of lines between START and END.
|
|
6770 This is usually the number of newlines between them,
|
|
6771 but can be one more if START is not equal to END
|
|
6772 and the greater of them is not at the start of a line."
|
|
6773 (save-excursion
|
|
6774 (save-restriction
|
|
6775 (narrow-to-region start end)
|
|
6776 (goto-char (point-min))
|
|
6777 (if (eq selective-display t)
|
|
6778 (save-match-data
|
|
6779 (let ((done 0))
|
|
6780 (while (re-search-forward "[\n\C-m]" nil t 40)
|
|
6781 (setq done (+ 40 done)))
|
|
6782 (while (re-search-forward "[\n\C-m]" nil t 1)
|
|
6783 (setq done (+ 1 done)))
|
|
6784 (goto-char (point-max))
|
|
6785 (if (and (/= start end)
|
|
6786 (not (bolp)))
|
|
6787 (1+ done)
|
|
6788 done)))
|
|
6789 (- (buffer-size) (forward-line (buffer-size)))))))
|
|
6790 @end ignore
|
|
6791
|
|
6792 @node what-line, narrow Exercise, save-restriction, Narrowing & Widening
|
|
6793 @comment node-name, next, previous, up
|
|
6794 @section @code{what-line}
|
|
6795 @findex what-line
|
|
6796 @cindex Widening, example of
|
|
6797
|
|
6798 The @code{what-line} command tells you the number of the line in which
|
|
6799 the cursor is located. The function illustrates the use of the
|
|
6800 @code{save-restriction} and @code{save-excursion} commands. Here is the
|
|
6801 original text of the function:
|
|
6802
|
|
6803 @smallexample
|
|
6804 @group
|
|
6805 (defun what-line ()
|
|
6806 "Print the current line number (in the buffer) of point."
|
|
6807 (interactive)
|
|
6808 (save-restriction
|
|
6809 (widen)
|
|
6810 (save-excursion
|
|
6811 (beginning-of-line)
|
|
6812 (message "Line %d"
|
|
6813 (1+ (count-lines 1 (point)))))))
|
|
6814 @end group
|
|
6815 @end smallexample
|
|
6816
|
|
6817 (In recent versions of GNU Emacs, the @code{what-line} function has
|
|
6818 been expanded to tell you your line number in a narrowed buffer as
|
|
6819 well as your line number in a widened buffer. The recent version is
|
|
6820 more complex than the version shown here. If you feel adventurous,
|
|
6821 you might want to look at it after figuring out how this version
|
|
6822 works. You will probably need to use @kbd{C-h f}
|
|
6823 (@code{describe-function}). The newer version uses a conditional to
|
|
6824 determine whether the buffer has been narrowed.
|
|
6825
|
|
6826 (Also, it uses @code{line-number-at-pos}, which among other simple
|
|
6827 expressions, such as @code{(goto-char (point-min))}, moves point to
|
|
6828 the beginning of the current line with @code{(forward-line 0)} rather
|
|
6829 than @code{beginning-of-line}.)
|
|
6830
|
|
6831 The @code{what-line} function as shown here has a documentation line
|
|
6832 and is interactive, as you would expect. The next two lines use the
|
|
6833 functions @code{save-restriction} and @code{widen}.
|
|
6834
|
|
6835 The @code{save-restriction} special form notes whatever narrowing is in
|
|
6836 effect, if any, in the current buffer and restores that narrowing after
|
|
6837 the code in the body of the @code{save-restriction} has been evaluated.
|
|
6838
|
|
6839 The @code{save-restriction} special form is followed by @code{widen}.
|
|
6840 This function undoes any narrowing the current buffer may have had
|
|
6841 when @code{what-line} was called. (The narrowing that was there is
|
|
6842 the narrowing that @code{save-restriction} remembers.) This widening
|
|
6843 makes it possible for the line counting commands to count from the
|
|
6844 beginning of the buffer. Otherwise, they would have been limited to
|
|
6845 counting within the accessible region. Any original narrowing is
|
|
6846 restored just before the completion of the function by the
|
|
6847 @code{save-restriction} special form.
|
|
6848
|
|
6849 The call to @code{widen} is followed by @code{save-excursion}, which
|
|
6850 saves the location of the cursor (i.e., of point) and of the mark, and
|
|
6851 restores them after the code in the body of the @code{save-excursion}
|
|
6852 uses the @code{beginning-of-line} function to move point.
|
|
6853
|
|
6854 (Note that the @code{(widen)} expression comes between the
|
|
6855 @code{save-restriction} and @code{save-excursion} special forms. When
|
|
6856 you write the two @code{save- @dots{}} expressions in sequence, write
|
|
6857 @code{save-excursion} outermost.)
|
|
6858
|
|
6859 @need 1200
|
|
6860 The last two lines of the @code{what-line} function are functions to
|
|
6861 count the number of lines in the buffer and then print the number in the
|
|
6862 echo area.
|
|
6863
|
|
6864 @smallexample
|
|
6865 @group
|
|
6866 (message "Line %d"
|
|
6867 (1+ (count-lines 1 (point)))))))
|
|
6868 @end group
|
|
6869 @end smallexample
|
|
6870
|
|
6871 The @code{message} function prints a one-line message at the bottom of
|
|
6872 the Emacs screen. The first argument is inside of quotation marks and
|
|
6873 is printed as a string of characters. However, it may contain a
|
|
6874 @samp{%d} expression to print a following argument. @samp{%d} prints
|
|
6875 the argument as a decimal, so the message will say something such as
|
|
6876 @samp{Line 243}.
|
|
6877
|
|
6878 @need 1200
|
|
6879 The number that is printed in place of the @samp{%d} is computed by the
|
|
6880 last line of the function:
|
|
6881
|
|
6882 @smallexample
|
|
6883 (1+ (count-lines 1 (point)))
|
|
6884 @end smallexample
|
|
6885
|
|
6886 @ignore
|
|
6887 GNU Emacs 22
|
|
6888
|
|
6889 (defun count-lines (start end)
|
|
6890 "Return number of lines between START and END.
|
|
6891 This is usually the number of newlines between them,
|
|
6892 but can be one more if START is not equal to END
|
|
6893 and the greater of them is not at the start of a line."
|
|
6894 (save-excursion
|
|
6895 (save-restriction
|
|
6896 (narrow-to-region start end)
|
|
6897 (goto-char (point-min))
|
|
6898 (if (eq selective-display t)
|
|
6899 (save-match-data
|
|
6900 (let ((done 0))
|
|
6901 (while (re-search-forward "[\n\C-m]" nil t 40)
|
|
6902 (setq done (+ 40 done)))
|
|
6903 (while (re-search-forward "[\n\C-m]" nil t 1)
|
|
6904 (setq done (+ 1 done)))
|
|
6905 (goto-char (point-max))
|
|
6906 (if (and (/= start end)
|
|
6907 (not (bolp)))
|
|
6908 (1+ done)
|
|
6909 done)))
|
|
6910 (- (buffer-size) (forward-line (buffer-size)))))))
|
|
6911 @end ignore
|
|
6912
|
|
6913 @noindent
|
|
6914 What this does is count the lines from the first position of the
|
|
6915 buffer, indicated by the @code{1}, up to @code{(point)}, and then add
|
|
6916 one to that number. (The @code{1+} function adds one to its
|
|
6917 argument.) We add one to it because line 2 has only one line before
|
|
6918 it, and @code{count-lines} counts only the lines @emph{before} the
|
|
6919 current line.
|
|
6920
|
|
6921 After @code{count-lines} has done its job, and the message has been
|
|
6922 printed in the echo area, the @code{save-excursion} restores point and
|
|
6923 mark to their original positions; and @code{save-restriction} restores
|
|
6924 the original narrowing, if any.
|
|
6925
|
|
6926 @node narrow Exercise, , what-line, Narrowing & Widening
|
|
6927 @section Exercise with Narrowing
|
|
6928
|
|
6929 Write a function that will display the first 60 characters of the
|
|
6930 current buffer, even if you have narrowed the buffer to its latter
|
|
6931 half so that the first line is inaccessible. Restore point, mark, and
|
|
6932 narrowing. For this exercise, you need to use a whole potpourri of
|
|
6933 functions, including @code{save-restriction}, @code{widen},
|
|
6934 @code{goto-char}, @code{point-min}, @code{message}, and
|
|
6935 @code{buffer-substring}.
|
|
6936
|
|
6937 @cindex Properties, mention of @code{buffer-substring-no-properties}
|
|
6938 (@code{buffer-substring} is a previously unmentioned function you will
|
|
6939 have to investigate yourself; or perhaps you will have to use
|
|
6940 @code{buffer-substring-no-properties} or
|
|
6941 @code{filter-buffer-substring} @dots{}, yet other functions. Text
|
|
6942 properties are a feature otherwise not discussed here. @xref{Text
|
|
6943 Properties, , Text Properties, elisp, The GNU Emacs Lisp Reference
|
|
6944 Manual}.)
|
|
6945
|
|
6946 Additionally, do you really need @code{goto-char} or @code{point-min}?
|
|
6947 Or can you write the function without them?
|
|
6948
|
|
6949 @node car cdr & cons, Cutting & Storing Text, Narrowing & Widening, Top
|
|
6950 @comment node-name, next, previous, up
|
|
6951 @chapter @code{car}, @code{cdr}, @code{cons}: Fundamental Functions
|
|
6952 @findex car, @r{introduced}
|
|
6953 @findex cdr, @r{introduced}
|
|
6954
|
|
6955 In Lisp, @code{car}, @code{cdr}, and @code{cons} are fundamental
|
|
6956 functions. The @code{cons} function is used to construct lists, and
|
|
6957 the @code{car} and @code{cdr} functions are used to take them apart.
|
|
6958
|
|
6959 In the walk through of the @code{copy-region-as-kill} function, we
|
|
6960 will see @code{cons} as well as two variants on @code{cdr},
|
|
6961 namely, @code{setcdr} and @code{nthcdr}. (@xref{copy-region-as-kill}.)
|
|
6962
|
|
6963 @menu
|
|
6964 * Strange Names:: An historical aside: why the strange names?
|
|
6965 * car & cdr:: Functions for extracting part of a list.
|
|
6966 * cons:: Constructing a list.
|
|
6967 * nthcdr:: Calling @code{cdr} repeatedly.
|
|
6968 * nth::
|
|
6969 * setcar:: Changing the first element of a list.
|
|
6970 * setcdr:: Changing the rest of a list.
|
|
6971 * cons Exercise::
|
|
6972 @end menu
|
|
6973
|
|
6974 @node Strange Names, car & cdr, car cdr & cons, car cdr & cons
|
|
6975 @ifnottex
|
|
6976 @unnumberedsec Strange Names
|
|
6977 @end ifnottex
|
|
6978
|
|
6979 The name of the @code{cons} function is not unreasonable: it is an
|
|
6980 abbreviation of the word `construct'. The origins of the names for
|
|
6981 @code{car} and @code{cdr}, on the other hand, are esoteric: @code{car}
|
|
6982 is an acronym from the phrase `Contents of the Address part of the
|
|
6983 Register'; and @code{cdr} (pronounced `could-er') is an acronym from
|
|
6984 the phrase `Contents of the Decrement part of the Register'. These
|
|
6985 phrases refer to specific pieces of hardware on the very early
|
|
6986 computer on which the original Lisp was developed. Besides being
|
|
6987 obsolete, the phrases have been completely irrelevant for more than 25
|
|
6988 years to anyone thinking about Lisp. Nonetheless, although a few
|
|
6989 brave scholars have begun to use more reasonable names for these
|
|
6990 functions, the old terms are still in use. In particular, since the
|
|
6991 terms are used in the Emacs Lisp source code, we will use them in this
|
|
6992 introduction.
|
|
6993
|
|
6994 @node car & cdr, cons, Strange Names, car cdr & cons
|
|
6995 @comment node-name, next, previous, up
|
|
6996 @section @code{car} and @code{cdr}
|
|
6997
|
|
6998 The @sc{car} of a list is, quite simply, the first item in the list.
|
|
6999 Thus the @sc{car} of the list @code{(rose violet daisy buttercup)} is
|
|
7000 @code{rose}.
|
|
7001
|
|
7002 @need 1200
|
|
7003 If you are reading this in Info in GNU Emacs, you can see this by
|
|
7004 evaluating the following:
|
|
7005
|
|
7006 @smallexample
|
|
7007 (car '(rose violet daisy buttercup))
|
|
7008 @end smallexample
|
|
7009
|
|
7010 @noindent
|
|
7011 After evaluating the expression, @code{rose} will appear in the echo
|
|
7012 area.
|
|
7013
|
|
7014 Clearly, a more reasonable name for the @code{car} function would be
|
|
7015 @code{first} and this is often suggested.
|
|
7016
|
|
7017 @code{car} does not remove the first item from the list; it only reports
|
|
7018 what it is. After @code{car} has been applied to a list, the list is
|
|
7019 still the same as it was. In the jargon, @code{car} is
|
|
7020 `non-destructive'. This feature turns out to be important.
|
|
7021
|
|
7022 The @sc{cdr} of a list is the rest of the list, that is, the
|
|
7023 @code{cdr} function returns the part of the list that follows the
|
|
7024 first item. Thus, while the @sc{car} of the list @code{'(rose violet
|
|
7025 daisy buttercup)} is @code{rose}, the rest of the list, the value
|
|
7026 returned by the @code{cdr} function, is @code{(violet daisy
|
|
7027 buttercup)}.
|
|
7028
|
|
7029 @need 800
|
|
7030 You can see this by evaluating the following in the usual way:
|
|
7031
|
|
7032 @smallexample
|
|
7033 (cdr '(rose violet daisy buttercup))
|
|
7034 @end smallexample
|
|
7035
|
|
7036 @noindent
|
|
7037 When you evaluate this, @code{(violet daisy buttercup)} will appear in
|
|
7038 the echo area.
|
|
7039
|
|
7040 Like @code{car}, @code{cdr} does not remove any elements from the
|
|
7041 list---it just returns a report of what the second and subsequent
|
|
7042 elements are.
|
|
7043
|
|
7044 Incidentally, in the example, the list of flowers is quoted. If it were
|
|
7045 not, the Lisp interpreter would try to evaluate the list by calling
|
|
7046 @code{rose} as a function. In this example, we do not want to do that.
|
|
7047
|
|
7048 Clearly, a more reasonable name for @code{cdr} would be @code{rest}.
|
|
7049
|
|
7050 (There is a lesson here: when you name new functions, consider very
|
|
7051 carefully what you are doing, since you may be stuck with the names
|
|
7052 for far longer than you expect. The reason this document perpetuates
|
|
7053 these names is that the Emacs Lisp source code uses them, and if I did
|
|
7054 not use them, you would have a hard time reading the code; but do,
|
|
7055 please, try to avoid using these terms yourself. The people who come
|
|
7056 after you will be grateful to you.)
|
|
7057
|
|
7058 When @code{car} and @code{cdr} are applied to a list made up of symbols,
|
|
7059 such as the list @code{(pine fir oak maple)}, the element of the list
|
|
7060 returned by the function @code{car} is the symbol @code{pine} without
|
|
7061 any parentheses around it. @code{pine} is the first element in the
|
|
7062 list. However, the @sc{cdr} of the list is a list itself, @code{(fir
|
|
7063 oak maple)}, as you can see by evaluating the following expressions in
|
|
7064 the usual way:
|
|
7065
|
|
7066 @smallexample
|
|
7067 @group
|
|
7068 (car '(pine fir oak maple))
|
|
7069
|
|
7070 (cdr '(pine fir oak maple))
|
|
7071 @end group
|
|
7072 @end smallexample
|
|
7073
|
|
7074 On the other hand, in a list of lists, the first element is itself a
|
|
7075 list. @code{car} returns this first element as a list. For example,
|
|
7076 the following list contains three sub-lists, a list of carnivores, a
|
|
7077 list of herbivores and a list of sea mammals:
|
|
7078
|
|
7079 @smallexample
|
|
7080 @group
|
|
7081 (car '((lion tiger cheetah)
|
|
7082 (gazelle antelope zebra)
|
|
7083 (whale dolphin seal)))
|
|
7084 @end group
|
|
7085 @end smallexample
|
|
7086
|
|
7087 @noindent
|
|
7088 In this example, the first element or @sc{car} of the list is the list of
|
|
7089 carnivores, @code{(lion tiger cheetah)}, and the rest of the list is
|
|
7090 @code{((gazelle antelope zebra) (whale dolphin seal))}.
|
|
7091
|
|
7092 @smallexample
|
|
7093 @group
|
|
7094 (cdr '((lion tiger cheetah)
|
|
7095 (gazelle antelope zebra)
|
|
7096 (whale dolphin seal)))
|
|
7097 @end group
|
|
7098 @end smallexample
|
|
7099
|
|
7100 It is worth saying again that @code{car} and @code{cdr} are
|
|
7101 non-destructive---that is, they do not modify or change lists to which
|
|
7102 they are applied. This is very important for how they are used.
|
|
7103
|
|
7104 Also, in the first chapter, in the discussion about atoms, I said that
|
|
7105 in Lisp, ``certain kinds of atom, such as an array, can be separated
|
|
7106 into parts; but the mechanism for doing this is different from the
|
|
7107 mechanism for splitting a list. As far as Lisp is concerned, the
|
|
7108 atoms of a list are unsplittable.'' (@xref{Lisp Atoms}.) The
|
|
7109 @code{car} and @code{cdr} functions are used for splitting lists and
|
|
7110 are considered fundamental to Lisp. Since they cannot split or gain
|
|
7111 access to the parts of an array, an array is considered an atom.
|
|
7112 Conversely, the other fundamental function, @code{cons}, can put
|
|
7113 together or construct a list, but not an array. (Arrays are handled
|
|
7114 by array-specific functions. @xref{Arrays, , Arrays, elisp, The GNU
|
|
7115 Emacs Lisp Reference Manual}.)
|
|
7116
|
|
7117 @node cons, nthcdr, car & cdr, car cdr & cons
|
|
7118 @comment node-name, next, previous, up
|
|
7119 @section @code{cons}
|
|
7120 @findex cons, @r{introduced}
|
|
7121
|
|
7122 The @code{cons} function constructs lists; it is the inverse of
|
|
7123 @code{car} and @code{cdr}. For example, @code{cons} can be used to make
|
|
7124 a four element list from the three element list, @code{(fir oak maple)}:
|
|
7125
|
|
7126 @smallexample
|
|
7127 (cons 'pine '(fir oak maple))
|
|
7128 @end smallexample
|
|
7129
|
|
7130 @need 800
|
|
7131 @noindent
|
|
7132 After evaluating this list, you will see
|
|
7133
|
|
7134 @smallexample
|
|
7135 (pine fir oak maple)
|
|
7136 @end smallexample
|
|
7137
|
|
7138 @noindent
|
|
7139 appear in the echo area. @code{cons} causes the creation of a new
|
|
7140 list in which the element is followed by the elements of the original
|
|
7141 list.
|
|
7142
|
|
7143 We often say that `@code{cons} puts a new element at the beginning of
|
|
7144 a list; it attaches or pushes elements onto the list', but this
|
|
7145 phrasing can be misleading, since @code{cons} does not change an
|
|
7146 existing list, but creates a new one.
|
|
7147
|
|
7148 Like @code{car} and @code{cdr}, @code{cons} is non-destructive.
|
|
7149
|
|
7150 @menu
|
|
7151 * Build a list::
|
|
7152 * length:: How to find the length of a list.
|
|
7153 @end menu
|
|
7154
|
|
7155 @node Build a list, length, cons, cons
|
|
7156 @ifnottex
|
|
7157 @unnumberedsubsec Build a list
|
|
7158 @end ifnottex
|
|
7159
|
|
7160 @code{cons} must have a list to attach to.@footnote{Actually, you can
|
|
7161 @code{cons} an element to an atom to produce a dotted pair. Dotted
|
|
7162 pairs are not discussed here; see @ref{Dotted Pair Notation, , Dotted
|
|
7163 Pair Notation, elisp, The GNU Emacs Lisp Reference Manual}.} You
|
|
7164 cannot start from absolutely nothing. If you are building a list, you
|
|
7165 need to provide at least an empty list at the beginning. Here is a
|
|
7166 series of @code{cons} expressions that build up a list of flowers. If
|
|
7167 you are reading this in Info in GNU Emacs, you can evaluate each of
|
|
7168 the expressions in the usual way; the value is printed in this text
|
|
7169 after @samp{@result{}}, which you may read as `evaluates to'.
|
|
7170
|
|
7171 @smallexample
|
|
7172 @group
|
|
7173 (cons 'buttercup ())
|
|
7174 @result{} (buttercup)
|
|
7175 @end group
|
|
7176
|
|
7177 @group
|
|
7178 (cons 'daisy '(buttercup))
|
|
7179 @result{} (daisy buttercup)
|
|
7180 @end group
|
|
7181
|
|
7182 @group
|
|
7183 (cons 'violet '(daisy buttercup))
|
|
7184 @result{} (violet daisy buttercup)
|
|
7185 @end group
|
|
7186
|
|
7187 @group
|
|
7188 (cons 'rose '(violet daisy buttercup))
|
|
7189 @result{} (rose violet daisy buttercup)
|
|
7190 @end group
|
|
7191 @end smallexample
|
|
7192
|
|
7193 @noindent
|
|
7194 In the first example, the empty list is shown as @code{()} and a list
|
|
7195 made up of @code{buttercup} followed by the empty list is constructed.
|
|
7196 As you can see, the empty list is not shown in the list that was
|
|
7197 constructed. All that you see is @code{(buttercup)}. The empty list is
|
|
7198 not counted as an element of a list because there is nothing in an empty
|
|
7199 list. Generally speaking, an empty list is invisible.
|
|
7200
|
|
7201 The second example, @code{(cons 'daisy '(buttercup))} constructs a new,
|
|
7202 two element list by putting @code{daisy} in front of @code{buttercup};
|
|
7203 and the third example constructs a three element list by putting
|
|
7204 @code{violet} in front of @code{daisy} and @code{buttercup}.
|
|
7205
|
|
7206 @node length, , Build a list, cons
|
|
7207 @comment node-name, next, previous, up
|
|
7208 @subsection Find the Length of a List: @code{length}
|
|
7209 @findex length
|
|
7210
|
|
7211 You can find out how many elements there are in a list by using the Lisp
|
|
7212 function @code{length}, as in the following examples:
|
|
7213
|
|
7214 @smallexample
|
|
7215 @group
|
|
7216 (length '(buttercup))
|
|
7217 @result{} 1
|
|
7218 @end group
|
|
7219
|
|
7220 @group
|
|
7221 (length '(daisy buttercup))
|
|
7222 @result{} 2
|
|
7223 @end group
|
|
7224
|
|
7225 @group
|
|
7226 (length (cons 'violet '(daisy buttercup)))
|
|
7227 @result{} 3
|
|
7228 @end group
|
|
7229 @end smallexample
|
|
7230
|
|
7231 @noindent
|
|
7232 In the third example, the @code{cons} function is used to construct a
|
|
7233 three element list which is then passed to the @code{length} function as
|
|
7234 its argument.
|
|
7235
|
|
7236 @need 1200
|
|
7237 We can also use @code{length} to count the number of elements in an
|
|
7238 empty list:
|
|
7239
|
|
7240 @smallexample
|
|
7241 @group
|
|
7242 (length ())
|
|
7243 @result{} 0
|
|
7244 @end group
|
|
7245 @end smallexample
|
|
7246
|
|
7247 @noindent
|
|
7248 As you would expect, the number of elements in an empty list is zero.
|
|
7249
|
|
7250 An interesting experiment is to find out what happens if you try to find
|
|
7251 the length of no list at all; that is, if you try to call @code{length}
|
|
7252 without giving it an argument, not even an empty list:
|
|
7253
|
|
7254 @smallexample
|
|
7255 (length )
|
|
7256 @end smallexample
|
|
7257
|
|
7258 @need 800
|
|
7259 @noindent
|
|
7260 What you see, if you evaluate this, is the error message
|
|
7261
|
|
7262 @smallexample
|
|
7263 Lisp error: (wrong-number-of-arguments length 0)
|
|
7264 @end smallexample
|
|
7265
|
|
7266 @noindent
|
|
7267 This means that the function receives the wrong number of
|
|
7268 arguments, zero, when it expects some other number of arguments. In
|
|
7269 this case, one argument is expected, the argument being a list whose
|
|
7270 length the function is measuring. (Note that @emph{one} list is
|
|
7271 @emph{one} argument, even if the list has many elements inside it.)
|
|
7272
|
|
7273 The part of the error message that says @samp{length} is the name of
|
|
7274 the function.
|
|
7275
|
|
7276 @ignore
|
|
7277 @code{length} is still a subroutine, but you need C-h f to discover that.
|
|
7278
|
|
7279 In an earlier version:
|
|
7280 This is written with a special notation, @samp{#<subr},
|
|
7281 that indicates that the function @code{length} is one of the primitive
|
|
7282 functions written in C rather than in Emacs Lisp. (@samp{subr} is an
|
|
7283 abbreviation for `subroutine'.) @xref{What Is a Function, , What Is a
|
|
7284 Function?, elisp , The GNU Emacs Lisp Reference Manual}, for more
|
|
7285 about subroutines.
|
|
7286 @end ignore
|
|
7287
|
|
7288 @node nthcdr, nth, cons, car cdr & cons
|
|
7289 @comment node-name, next, previous, up
|
|
7290 @section @code{nthcdr}
|
|
7291 @findex nthcdr
|
|
7292
|
|
7293 The @code{nthcdr} function is associated with the @code{cdr} function.
|
|
7294 What it does is take the @sc{cdr} of a list repeatedly.
|
|
7295
|
|
7296 If you take the @sc{cdr} of the list @code{(pine fir
|
|
7297 oak maple)}, you will be returned the list @code{(fir oak maple)}. If you
|
|
7298 repeat this on what was returned, you will be returned the list
|
|
7299 @code{(oak maple)}. (Of course, repeated @sc{cdr}ing on the original
|
|
7300 list will just give you the original @sc{cdr} since the function does
|
|
7301 not change the list. You need to evaluate the @sc{cdr} of the
|
|
7302 @sc{cdr} and so on.) If you continue this, eventually you will be
|
|
7303 returned an empty list, which in this case, instead of being shown as
|
|
7304 @code{()} is shown as @code{nil}.
|
|
7305
|
|
7306 @need 1200
|
|
7307 For review, here is a series of repeated @sc{cdr}s, the text following
|
|
7308 the @samp{@result{}} shows what is returned.
|
|
7309
|
|
7310 @smallexample
|
|
7311 @group
|
|
7312 (cdr '(pine fir oak maple))
|
|
7313 @result{}(fir oak maple)
|
|
7314 @end group
|
|
7315
|
|
7316 @group
|
|
7317 (cdr '(fir oak maple))
|
|
7318 @result{} (oak maple)
|
|
7319 @end group
|
|
7320
|
|
7321 @group
|
|
7322 (cdr '(oak maple))
|
|
7323 @result{}(maple)
|
|
7324 @end group
|
|
7325
|
|
7326 @group
|
|
7327 (cdr '(maple))
|
|
7328 @result{} nil
|
|
7329 @end group
|
|
7330
|
|
7331 @group
|
|
7332 (cdr 'nil)
|
|
7333 @result{} nil
|
|
7334 @end group
|
|
7335
|
|
7336 @group
|
|
7337 (cdr ())
|
|
7338 @result{} nil
|
|
7339 @end group
|
|
7340 @end smallexample
|
|
7341
|
|
7342 @need 1200
|
|
7343 You can also do several @sc{cdr}s without printing the values in
|
|
7344 between, like this:
|
|
7345
|
|
7346 @smallexample
|
|
7347 @group
|
|
7348 (cdr (cdr '(pine fir oak maple)))
|
|
7349 @result{} (oak maple)
|
|
7350 @end group
|
|
7351 @end smallexample
|
|
7352
|
|
7353 @noindent
|
|
7354 In this example, the Lisp interpreter evaluates the innermost list first.
|
|
7355 The innermost list is quoted, so it just passes the list as it is to the
|
|
7356 innermost @code{cdr}. This @code{cdr} passes a list made up of the
|
|
7357 second and subsequent elements of the list to the outermost @code{cdr},
|
|
7358 which produces a list composed of the third and subsequent elements of
|
|
7359 the original list. In this example, the @code{cdr} function is repeated
|
|
7360 and returns a list that consists of the original list without its
|
|
7361 first two elements.
|
|
7362
|
|
7363 The @code{nthcdr} function does the same as repeating the call to
|
|
7364 @code{cdr}. In the following example, the argument 2 is passed to the
|
|
7365 function @code{nthcdr}, along with the list, and the value returned is
|
|
7366 the list without its first two items, which is exactly the same
|
|
7367 as repeating @code{cdr} twice on the list:
|
|
7368
|
|
7369 @smallexample
|
|
7370 @group
|
|
7371 (nthcdr 2 '(pine fir oak maple))
|
|
7372 @result{} (oak maple)
|
|
7373 @end group
|
|
7374 @end smallexample
|
|
7375
|
|
7376 @need 1200
|
|
7377 Using the original four element list, we can see what happens when
|
|
7378 various numeric arguments are passed to @code{nthcdr}, including 0, 1,
|
|
7379 and 5:
|
|
7380
|
|
7381 @smallexample
|
|
7382 @group
|
|
7383 ;; @r{Leave the list as it was.}
|
|
7384 (nthcdr 0 '(pine fir oak maple))
|
|
7385 @result{} (pine fir oak maple)
|
|
7386 @end group
|
|
7387
|
|
7388 @group
|
|
7389 ;; @r{Return a copy without the first element.}
|
|
7390 (nthcdr 1 '(pine fir oak maple))
|
|
7391 @result{} (fir oak maple)
|
|
7392 @end group
|
|
7393
|
|
7394 @group
|
|
7395 ;; @r{Return a copy of the list without three elements.}
|
|
7396 (nthcdr 3 '(pine fir oak maple))
|
|
7397 @result{} (maple)
|
|
7398 @end group
|
|
7399
|
|
7400 @group
|
|
7401 ;; @r{Return a copy lacking all four elements.}
|
|
7402 (nthcdr 4 '(pine fir oak maple))
|
|
7403 @result{} nil
|
|
7404 @end group
|
|
7405
|
|
7406 @group
|
|
7407 ;; @r{Return a copy lacking all elements.}
|
|
7408 (nthcdr 5 '(pine fir oak maple))
|
|
7409 @result{} nil
|
|
7410 @end group
|
|
7411 @end smallexample
|
|
7412
|
|
7413 @node nth, setcar, nthcdr, car cdr & cons
|
|
7414 @comment node-name, next, previous, up
|
|
7415 @section @code{nth}
|
|
7416 @findex nth
|
|
7417
|
|
7418 The @code{nthcdr} function takes the @sc{cdr} of a list repeatedly.
|
|
7419 The @code{nth} function takes the @sc{car} of the result returned by
|
|
7420 @code{nthcdr}. It returns the Nth element of the list.
|
|
7421
|
|
7422 @need 1500
|
|
7423 Thus, if it were not defined in C for speed, the definition of
|
|
7424 @code{nth} would be:
|
|
7425
|
|
7426 @smallexample
|
|
7427 @group
|
|
7428 (defun nth (n list)
|
|
7429 "Returns the Nth element of LIST.
|
|
7430 N counts from zero. If LIST is not that long, nil is returned."
|
|
7431 (car (nthcdr n list)))
|
|
7432 @end group
|
|
7433 @end smallexample
|
|
7434
|
|
7435 @noindent
|
|
7436 (Originally, @code{nth} was defined in Emacs Lisp in @file{subr.el},
|
|
7437 but its definition was redone in C in the 1980s.)
|
|
7438
|
|
7439 The @code{nth} function returns a single element of a list.
|
|
7440 This can be very convenient.
|
|
7441
|
|
7442 Note that the elements are numbered from zero, not one. That is to
|
|
7443 say, the first element of a list, its @sc{car} is the zeroth element.
|
|
7444 This is called `zero-based' counting and often bothers people who
|
|
7445 are accustomed to the first element in a list being number one, which
|
|
7446 is `one-based'.
|
|
7447
|
|
7448 @need 1250
|
|
7449 For example:
|
|
7450
|
|
7451 @smallexample
|
|
7452 @group
|
|
7453 (nth 0 '("one" "two" "three"))
|
|
7454 @result{} "one"
|
|
7455
|
|
7456 (nth 1 '("one" "two" "three"))
|
|
7457 @result{} "two"
|
|
7458 @end group
|
|
7459 @end smallexample
|
|
7460
|
|
7461 It is worth mentioning that @code{nth}, like @code{nthcdr} and
|
|
7462 @code{cdr}, does not change the original list---the function is
|
|
7463 non-destructive. This is in sharp contrast to the @code{setcar} and
|
|
7464 @code{setcdr} functions.
|
|
7465
|
|
7466 @node setcar, setcdr, nth, car cdr & cons
|
|
7467 @comment node-name, next, previous, up
|
|
7468 @section @code{setcar}
|
|
7469 @findex setcar
|
|
7470
|
|
7471 As you might guess from their names, the @code{setcar} and @code{setcdr}
|
|
7472 functions set the @sc{car} or the @sc{cdr} of a list to a new value.
|
|
7473 They actually change the original list, unlike @code{car} and @code{cdr}
|
|
7474 which leave the original list as it was. One way to find out how this
|
|
7475 works is to experiment. We will start with the @code{setcar} function.
|
|
7476
|
|
7477 @need 1200
|
|
7478 First, we can make a list and then set the value of a variable to the
|
|
7479 list, using the @code{setq} function. Here is a list of animals:
|
|
7480
|
|
7481 @smallexample
|
|
7482 (setq animals '(antelope giraffe lion tiger))
|
|
7483 @end smallexample
|
|
7484
|
|
7485 @noindent
|
|
7486 If you are reading this in Info inside of GNU Emacs, you can evaluate
|
|
7487 this expression in the usual fashion, by positioning the cursor after
|
|
7488 the expression and typing @kbd{C-x C-e}. (I'm doing this right here
|
|
7489 as I write this. This is one of the advantages of having the
|
|
7490 interpreter built into the computing environment. Incidentally, when
|
|
7491 there is nothing on the line after the final parentheses, such as a
|
|
7492 comment, point can be on the next line. Thus, if your cursor is in
|
|
7493 the first column of the next line, you do not need to move it.
|
|
7494 Indeed, Emacs permits any amount of white space after the final
|
|
7495 parenthesis.)
|
|
7496
|
|
7497 @need 1200
|
|
7498 When we evaluate the variable @code{animals}, we see that it is bound to
|
|
7499 the list @code{(antelope giraffe lion tiger)}:
|
|
7500
|
|
7501 @smallexample
|
|
7502 @group
|
|
7503 animals
|
|
7504 @result{} (antelope giraffe lion tiger)
|
|
7505 @end group
|
|
7506 @end smallexample
|
|
7507
|
|
7508 @noindent
|
|
7509 Put another way, the variable @code{animals} points to the list
|
|
7510 @code{(antelope giraffe lion tiger)}.
|
|
7511
|
|
7512 Next, evaluate the function @code{setcar} while passing it two
|
|
7513 arguments, the variable @code{animals} and the quoted symbol
|
|
7514 @code{hippopotamus}; this is done by writing the three element list
|
|
7515 @code{(setcar animals 'hippopotamus)} and then evaluating it in the
|
|
7516 usual fashion:
|
|
7517
|
|
7518 @smallexample
|
|
7519 (setcar animals 'hippopotamus)
|
|
7520 @end smallexample
|
|
7521
|
|
7522 @need 1200
|
|
7523 @noindent
|
|
7524 After evaluating this expression, evaluate the variable @code{animals}
|
|
7525 again. You will see that the list of animals has changed:
|
|
7526
|
|
7527 @smallexample
|
|
7528 @group
|
|
7529 animals
|
|
7530 @result{} (hippopotamus giraffe lion tiger)
|
|
7531 @end group
|
|
7532 @end smallexample
|
|
7533
|
|
7534 @noindent
|
|
7535 The first element on the list, @code{antelope} is replaced by
|
|
7536 @code{hippopotamus}.
|
|
7537
|
|
7538 So we can see that @code{setcar} did not add a new element to the list
|
|
7539 as @code{cons} would have; it replaced @code{antelope} with
|
|
7540 @code{hippopotamus}; it @emph{changed} the list.
|
|
7541
|
|
7542 @node setcdr, cons Exercise, setcar, car cdr & cons
|
|
7543 @comment node-name, next, previous, up
|
|
7544 @section @code{setcdr}
|
|
7545 @findex setcdr
|
|
7546
|
|
7547 The @code{setcdr} function is similar to the @code{setcar} function,
|
|
7548 except that the function replaces the second and subsequent elements of
|
|
7549 a list rather than the first element.
|
|
7550
|
|
7551 (To see how to change the last element of a list, look ahead to
|
|
7552 @ref{kill-new function, , The @code{kill-new} function}, which uses
|
|
7553 the @code{nthcdr} and @code{setcdr} functions.)
|
|
7554
|
|
7555 @need 1200
|
|
7556 To see how this works, set the value of the variable to a list of
|
|
7557 domesticated animals by evaluating the following expression:
|
|
7558
|
|
7559 @smallexample
|
|
7560 (setq domesticated-animals '(horse cow sheep goat))
|
|
7561 @end smallexample
|
|
7562
|
|
7563 @need 1200
|
|
7564 @noindent
|
|
7565 If you now evaluate the list, you will be returned the list
|
|
7566 @code{(horse cow sheep goat)}:
|
|
7567
|
|
7568 @smallexample
|
|
7569 @group
|
|
7570 domesticated-animals
|
|
7571 @result{} (horse cow sheep goat)
|
|
7572 @end group
|
|
7573 @end smallexample
|
|
7574
|
|
7575 @need 1200
|
|
7576 Next, evaluate @code{setcdr} with two arguments, the name of the
|
|
7577 variable which has a list as its value, and the list to which the
|
|
7578 @sc{cdr} of the first list will be set;
|
|
7579
|
|
7580 @smallexample
|
|
7581 (setcdr domesticated-animals '(cat dog))
|
|
7582 @end smallexample
|
|
7583
|
|
7584 @noindent
|
|
7585 If you evaluate this expression, the list @code{(cat dog)} will appear
|
|
7586 in the echo area. This is the value returned by the function. The
|
|
7587 result we are interested in is the ``side effect'', which we can see by
|
|
7588 evaluating the variable @code{domesticated-animals}:
|
|
7589
|
|
7590 @smallexample
|
|
7591 @group
|
|
7592 domesticated-animals
|
|
7593 @result{} (horse cat dog)
|
|
7594 @end group
|
|
7595 @end smallexample
|
|
7596
|
|
7597 @noindent
|
|
7598 Indeed, the list is changed from @code{(horse cow sheep goat)} to
|
|
7599 @code{(horse cat dog)}. The @sc{cdr} of the list is changed from
|
|
7600 @code{(cow sheep goat)} to @code{(cat dog)}.
|
|
7601
|
|
7602 @node cons Exercise, , setcdr, car cdr & cons
|
|
7603 @section Exercise
|
|
7604
|
|
7605 Construct a list of four birds by evaluating several expressions with
|
|
7606 @code{cons}. Find out what happens when you @code{cons} a list onto
|
|
7607 itself. Replace the first element of the list of four birds with a
|
|
7608 fish. Replace the rest of that list with a list of other fish.
|
|
7609
|
|
7610 @node Cutting & Storing Text, List Implementation, car cdr & cons, Top
|
|
7611 @comment node-name, next, previous, up
|
|
7612 @chapter Cutting and Storing Text
|
|
7613 @cindex Cutting and storing text
|
|
7614 @cindex Storing and cutting text
|
|
7615 @cindex Killing text
|
|
7616 @cindex Clipping text
|
|
7617 @cindex Erasing text
|
|
7618 @cindex Deleting text
|
|
7619
|
|
7620 Whenever you cut or clip text out of a buffer with a `kill' command in
|
|
7621 GNU Emacs, it is stored in a list and you can bring it back with a
|
|
7622 `yank' command.
|
|
7623
|
|
7624 (The use of the word `kill' in Emacs for processes which specifically
|
|
7625 @emph{do not} destroy the values of the entities is an unfortunate
|
|
7626 historical accident. A much more appropriate word would be `clip' since
|
|
7627 that is what the kill commands do; they clip text out of a buffer and
|
|
7628 put it into storage from which it can be brought back. I have often
|
|
7629 been tempted to replace globally all occurrences of `kill' in the Emacs
|
|
7630 sources with `clip' and all occurrences of `killed' with `clipped'.)
|
|
7631
|
|
7632 @menu
|
|
7633 * Storing Text:: Text is stored in a list.
|
|
7634 * zap-to-char:: Cutting out text up to a character.
|
|
7635 * kill-region:: Cutting text out of a region.
|
|
7636 * copy-region-as-kill:: A definition for copying text.
|
|
7637 * Digression into C:: Minor note on C programming language macros.
|
|
7638 * defvar:: How to give a variable an initial value.
|
|
7639 * cons & search-fwd Review::
|
|
7640 * search Exercises::
|
|
7641 @end menu
|
|
7642
|
|
7643 @node Storing Text, zap-to-char, Cutting & Storing Text, Cutting & Storing Text
|
|
7644 @ifnottex
|
|
7645 @unnumberedsec Storing Text in a List
|
|
7646 @end ifnottex
|
|
7647
|
|
7648 When text is cut out of a buffer, it is stored on a list. Successive
|
|
7649 pieces of text are stored on the list successively, so the list might
|
|
7650 look like this:
|
|
7651
|
|
7652 @smallexample
|
|
7653 ("a piece of text" "previous piece")
|
|
7654 @end smallexample
|
|
7655
|
|
7656 @need 1200
|
|
7657 @noindent
|
|
7658 The function @code{cons} can be used to create a new list from a piece
|
|
7659 of text (an `atom', to use the jargon) and an existing list, like
|
|
7660 this:
|
|
7661
|
|
7662 @smallexample
|
|
7663 @group
|
|
7664 (cons "another piece"
|
|
7665 '("a piece of text" "previous piece"))
|
|
7666 @end group
|
|
7667 @end smallexample
|
|
7668
|
|
7669 @need 1200
|
|
7670 @noindent
|
|
7671 If you evaluate this expression, a list of three elements will appear in
|
|
7672 the echo area:
|
|
7673
|
|
7674 @smallexample
|
|
7675 ("another piece" "a piece of text" "previous piece")
|
|
7676 @end smallexample
|
|
7677
|
|
7678 With the @code{car} and @code{nthcdr} functions, you can retrieve
|
|
7679 whichever piece of text you want. For example, in the following code,
|
|
7680 @code{nthcdr 1 @dots{}} returns the list with the first item removed;
|
|
7681 and the @code{car} returns the first element of that remainder---the
|
|
7682 second element of the original list:
|
|
7683
|
|
7684 @smallexample
|
|
7685 @group
|
|
7686 (car (nthcdr 1 '("another piece"
|
|
7687 "a piece of text"
|
|
7688 "previous piece")))
|
|
7689 @result{} "a piece of text"
|
|
7690 @end group
|
|
7691 @end smallexample
|
|
7692
|
|
7693 The actual functions in Emacs are more complex than this, of course.
|
|
7694 The code for cutting and retrieving text has to be written so that
|
|
7695 Emacs can figure out which element in the list you want---the first,
|
|
7696 second, third, or whatever. In addition, when you get to the end of
|
|
7697 the list, Emacs should give you the first element of the list, rather
|
|
7698 than nothing at all.
|
|
7699
|
|
7700 The list that holds the pieces of text is called the @dfn{kill ring}.
|
|
7701 This chapter leads up to a description of the kill ring and how it is
|
|
7702 used by first tracing how the @code{zap-to-char} function works. This
|
|
7703 function uses (or `calls') a function that invokes a function that
|
|
7704 manipulates the kill ring. Thus, before reaching the mountains, we
|
|
7705 climb the foothills.
|
|
7706
|
|
7707 A subsequent chapter describes how text that is cut from the buffer is
|
|
7708 retrieved. @xref{Yanking, , Yanking Text Back}.
|
|
7709
|
|
7710 @node zap-to-char, kill-region, Storing Text, Cutting & Storing Text
|
|
7711 @comment node-name, next, previous, up
|
|
7712 @section @code{zap-to-char}
|
|
7713 @findex zap-to-char
|
|
7714
|
|
7715 The @code{zap-to-char} function changed little between GNU Emacs
|
|
7716 version 19 and GNU Emacs version 22. However, @code{zap-to-char}
|
|
7717 calls another function, @code{kill-region}, which enjoyed a major
|
|
7718 rewrite.
|
|
7719
|
|
7720 The @code{kill-region} function in Emacs 19 is complex, but does not
|
|
7721 use code that is important at this time. We will skip it.
|
|
7722
|
|
7723 The @code{kill-region} function in Emacs 22 is easier to read than the
|
|
7724 same function in Emacs 19 and introduces a very important concept,
|
|
7725 that of error handling. We will walk through the function.
|
|
7726
|
|
7727 But first, let us look at the interactive @code{zap-to-char} function.
|
|
7728
|
|
7729 @menu
|
|
7730 * Complete zap-to-char:: The complete implementation.
|
|
7731 * zap-to-char interactive:: A three part interactive expression.
|
|
7732 * zap-to-char body:: A short overview.
|
|
7733 * search-forward:: How to search for a string.
|
|
7734 * progn:: The @code{progn} special form.
|
|
7735 * Summing up zap-to-char:: Using @code{point} and @code{search-forward}.
|
|
7736 @end menu
|
|
7737
|
|
7738 @node Complete zap-to-char, zap-to-char interactive, zap-to-char, zap-to-char
|
|
7739 @ifnottex
|
|
7740 @unnumberedsubsec The Complete @code{zap-to-char} Implementation
|
|
7741 @end ifnottex
|
|
7742
|
|
7743 The @code{zap-to-char} function removes the text in the region between
|
|
7744 the location of the cursor (i.e., of point) up to and including the
|
|
7745 next occurrence of a specified character. The text that
|
|
7746 @code{zap-to-char} removes is put in the kill ring; and it can be
|
|
7747 retrieved from the kill ring by typing @kbd{C-y} (@code{yank}). If
|
|
7748 the command is given an argument, it removes text through that number
|
|
7749 of occurrences. Thus, if the cursor were at the beginning of this
|
|
7750 sentence and the character were @samp{s}, @samp{Thus} would be
|
|
7751 removed. If the argument were two, @samp{Thus, if the curs} would be
|
|
7752 removed, up to and including the @samp{s} in @samp{cursor}.
|
|
7753
|
|
7754 If the specified character is not found, @code{zap-to-char} will say
|
|
7755 ``Search failed'', tell you the character you typed, and not remove
|
|
7756 any text.
|
|
7757
|
|
7758 In order to determine how much text to remove, @code{zap-to-char} uses
|
|
7759 a search function. Searches are used extensively in code that
|
|
7760 manipulates text, and we will focus attention on them as well as on the
|
|
7761 deletion command.
|
|
7762
|
|
7763 @ignore
|
|
7764 @c GNU Emacs version 19
|
|
7765 (defun zap-to-char (arg char) ; version 19 implementation
|
|
7766 "Kill up to and including ARG'th occurrence of CHAR.
|
|
7767 Goes backward if ARG is negative; error if CHAR not found."
|
|
7768 (interactive "*p\ncZap to char: ")
|
|
7769 (kill-region (point)
|
|
7770 (progn
|
|
7771 (search-forward
|
|
7772 (char-to-string char) nil nil arg)
|
|
7773 (point))))
|
|
7774 @end ignore
|
|
7775
|
|
7776 @need 1250
|
|
7777 Here is the complete text of the version 22 implementation of the function:
|
|
7778
|
|
7779 @c GNU Emacs 22
|
|
7780 @smallexample
|
|
7781 @group
|
|
7782 (defun zap-to-char (arg char)
|
|
7783 "Kill up to and including ARG'th occurrence of CHAR.
|
|
7784 Case is ignored if `case-fold-search' is non-nil in the current buffer.
|
|
7785 Goes backward if ARG is negative; error if CHAR not found."
|
|
7786 (interactive "p\ncZap to char: ")
|
|
7787 (if (char-table-p translation-table-for-input)
|
|
7788 (setq char (or (aref translation-table-for-input char) char)))
|
|
7789 (kill-region (point) (progn
|
98525
|
7790 (search-forward (char-to-string char)
|
|
7791 nil nil arg)
|
83955
|
7792 (point))))
|
|
7793 @end group
|
|
7794 @end smallexample
|
|
7795
|
|
7796 The documentation is thorough. You do need to know the jargon meaning
|
|
7797 of the word `kill'.
|
|
7798
|
|
7799 @node zap-to-char interactive, zap-to-char body, Complete zap-to-char, zap-to-char
|
|
7800 @comment node-name, next, previous, up
|
|
7801 @subsection The @code{interactive} Expression
|
|
7802
|
|
7803 @need 800
|
|
7804 The interactive expression in the @code{zap-to-char} command looks like
|
|
7805 this:
|
|
7806
|
|
7807 @smallexample
|
|
7808 (interactive "p\ncZap to char: ")
|
|
7809 @end smallexample
|
|
7810
|
|
7811 The part within quotation marks, @code{"p\ncZap to char:@: "}, specifies
|
|
7812 two different things. First, and most simply, is the @samp{p}.
|
|
7813 This part is separated from the next part by a newline, @samp{\n}.
|
|
7814 The @samp{p} means that the first argument to the function will be
|
|
7815 passed the value of a `processed prefix'. The prefix argument is
|
|
7816 passed by typing @kbd{C-u} and a number, or @kbd{M-} and a number. If
|
|
7817 the function is called interactively without a prefix, 1 is passed to
|
|
7818 this argument.
|
|
7819
|
|
7820 The second part of @code{"p\ncZap to char:@: "} is
|
|
7821 @samp{cZap to char:@: }. In this part, the lower case @samp{c}
|
|
7822 indicates that @code{interactive} expects a prompt and that the
|
|
7823 argument will be a character. The prompt follows the @samp{c} and is
|
|
7824 the string @samp{Zap to char:@: } (with a space after the colon to
|
|
7825 make it look good).
|
|
7826
|
|
7827 What all this does is prepare the arguments to @code{zap-to-char} so they
|
|
7828 are of the right type, and give the user a prompt.
|
|
7829
|
|
7830 In a read-only buffer, the @code{zap-to-char} function copies the text
|
|
7831 to the kill ring, but does not remove it. The echo area displays a
|
|
7832 message saying that the buffer is read-only. Also, the terminal may
|
|
7833 beep or blink at you.
|
|
7834
|
|
7835 @node zap-to-char body, search-forward, zap-to-char interactive, zap-to-char
|
|
7836 @comment node-name, next, previous, up
|
|
7837 @subsection The Body of @code{zap-to-char}
|
|
7838
|
|
7839 The body of the @code{zap-to-char} function contains the code that
|
|
7840 kills (that is, removes) the text in the region from the current
|
|
7841 position of the cursor up to and including the specified character.
|
|
7842
|
|
7843 The first part of the code looks like this:
|
|
7844
|
|
7845 @smallexample
|
|
7846 (if (char-table-p translation-table-for-input)
|
|
7847 (setq char (or (aref translation-table-for-input char) char)))
|
|
7848 (kill-region (point) (progn
|
|
7849 (search-forward (char-to-string char) nil nil arg)
|
|
7850 (point)))
|
|
7851 @end smallexample
|
|
7852
|
|
7853 @noindent
|
|
7854 @code{char-table-p} is an hitherto unseen function. It determines
|
|
7855 whether its argument is a character table. When it is, it sets the
|
|
7856 character passed to @code{zap-to-char} to one of them, if that
|
|
7857 character exists, or to the character itself. (This becomes important
|
|
7858 for certain characters in non-European languages. The @code{aref}
|
|
7859 function extracts an element from an array. It is an array-specific
|
|
7860 function that is not described in this document. @xref{Arrays, ,
|
|
7861 Arrays, elisp, The GNU Emacs Lisp Reference Manual}.)
|
|
7862
|
|
7863 @noindent
|
|
7864 @code{(point)} is the current position of the cursor.
|
|
7865
|
|
7866 The next part of the code is an expression using @code{progn}. The body
|
|
7867 of the @code{progn} consists of calls to @code{search-forward} and
|
|
7868 @code{point}.
|
|
7869
|
|
7870 It is easier to understand how @code{progn} works after learning about
|
|
7871 @code{search-forward}, so we will look at @code{search-forward} and
|
|
7872 then at @code{progn}.
|
|
7873
|
|
7874 @node search-forward, progn, zap-to-char body, zap-to-char
|
|
7875 @comment node-name, next, previous, up
|
|
7876 @subsection The @code{search-forward} Function
|
|
7877 @findex search-forward
|
|
7878
|
|
7879 The @code{search-forward} function is used to locate the
|
|
7880 zapped-for-character in @code{zap-to-char}. If the search is
|
|
7881 successful, @code{search-forward} leaves point immediately after the
|
|
7882 last character in the target string. (In @code{zap-to-char}, the
|
|
7883 target string is just one character long. @code{zap-to-char} uses the
|
|
7884 function @code{char-to-string} to ensure that the computer treats that
|
|
7885 character as a string.) If the search is backwards,
|
|
7886 @code{search-forward} leaves point just before the first character in
|
|
7887 the target. Also, @code{search-forward} returns @code{t} for true.
|
|
7888 (Moving point is therefore a `side effect'.)
|
|
7889
|
|
7890 @need 1250
|
|
7891 In @code{zap-to-char}, the @code{search-forward} function looks like this:
|
|
7892
|
|
7893 @smallexample
|
|
7894 (search-forward (char-to-string char) nil nil arg)
|
|
7895 @end smallexample
|
|
7896
|
|
7897 The @code{search-forward} function takes four arguments:
|
|
7898
|
|
7899 @enumerate
|
|
7900 @item
|
|
7901 The first argument is the target, what is searched for. This must be a
|
|
7902 string, such as @samp{"z"}.
|
|
7903
|
|
7904 As it happens, the argument passed to @code{zap-to-char} is a single
|
|
7905 character. Because of the way computers are built, the Lisp
|
|
7906 interpreter may treat a single character as being different from a
|
|
7907 string of characters. Inside the computer, a single character has a
|
|
7908 different electronic format than a string of one character. (A single
|
|
7909 character can often be recorded in the computer using exactly one
|
|
7910 byte; but a string may be longer, and the computer needs to be ready
|
|
7911 for this.) Since the @code{search-forward} function searches for a
|
|
7912 string, the character that the @code{zap-to-char} function receives as
|
|
7913 its argument must be converted inside the computer from one format to
|
|
7914 the other; otherwise the @code{search-forward} function will fail.
|
|
7915 The @code{char-to-string} function is used to make this conversion.
|
|
7916
|
|
7917 @item
|
|
7918 The second argument bounds the search; it is specified as a position in
|
|
7919 the buffer. In this case, the search can go to the end of the buffer,
|
|
7920 so no bound is set and the second argument is @code{nil}.
|
|
7921
|
|
7922 @item
|
|
7923 The third argument tells the function what it should do if the search
|
|
7924 fails---it can signal an error (and print a message) or it can return
|
|
7925 @code{nil}. A @code{nil} as the third argument causes the function to
|
|
7926 signal an error when the search fails.
|
|
7927
|
|
7928 @item
|
|
7929 The fourth argument to @code{search-forward} is the repeat count---how
|
|
7930 many occurrences of the string to look for. This argument is optional
|
|
7931 and if the function is called without a repeat count, this argument is
|
|
7932 passed the value 1. If this argument is negative, the search goes
|
|
7933 backwards.
|
|
7934 @end enumerate
|
|
7935
|
|
7936 @need 800
|
|
7937 In template form, a @code{search-forward} expression looks like this:
|
|
7938
|
|
7939 @smallexample
|
|
7940 @group
|
|
7941 (search-forward "@var{target-string}"
|
|
7942 @var{limit-of-search}
|
|
7943 @var{what-to-do-if-search-fails}
|
|
7944 @var{repeat-count})
|
|
7945 @end group
|
|
7946 @end smallexample
|
|
7947
|
|
7948 We will look at @code{progn} next.
|
|
7949
|
|
7950 @node progn, Summing up zap-to-char, search-forward, zap-to-char
|
|
7951 @comment node-name, next, previous, up
|
|
7952 @subsection The @code{progn} Special Form
|
|
7953 @findex progn
|
|
7954
|
|
7955 @code{progn} is a special form that causes each of its arguments to be
|
|
7956 evaluated in sequence and then returns the value of the last one. The
|
|
7957 preceding expressions are evaluated only for the side effects they
|
|
7958 perform. The values produced by them are discarded.
|
|
7959
|
|
7960 @need 800
|
|
7961 The template for a @code{progn} expression is very simple:
|
|
7962
|
|
7963 @smallexample
|
|
7964 @group
|
|
7965 (progn
|
|
7966 @var{body}@dots{})
|
|
7967 @end group
|
|
7968 @end smallexample
|
|
7969
|
|
7970 In @code{zap-to-char}, the @code{progn} expression has to do two things:
|
|
7971 put point in exactly the right position; and return the location of
|
|
7972 point so that @code{kill-region} will know how far to kill to.
|
|
7973
|
|
7974 The first argument to the @code{progn} is @code{search-forward}. When
|
|
7975 @code{search-forward} finds the string, the function leaves point
|
|
7976 immediately after the last character in the target string. (In this
|
|
7977 case the target string is just one character long.) If the search is
|
|
7978 backwards, @code{search-forward} leaves point just before the first
|
|
7979 character in the target. The movement of point is a side effect.
|
|
7980
|
|
7981 The second and last argument to @code{progn} is the expression
|
|
7982 @code{(point)}. This expression returns the value of point, which in
|
|
7983 this case will be the location to which it has been moved by
|
|
7984 @code{search-forward}. (In the source, a line that tells the function
|
|
7985 to go to the previous character, if it is going forward, was commented
|
|
7986 out in 1999; I don't remember whether that feature or mis-feature was
|
|
7987 ever a part of the distributed source.) The value of @code{point} is
|
|
7988 returned by the @code{progn} expression and is passed to
|
|
7989 @code{kill-region} as @code{kill-region}'s second argument.
|
|
7990
|
|
7991 @node Summing up zap-to-char, , progn, zap-to-char
|
|
7992 @comment node-name, next, previous, up
|
|
7993 @subsection Summing up @code{zap-to-char}
|
|
7994
|
|
7995 Now that we have seen how @code{search-forward} and @code{progn} work,
|
|
7996 we can see how the @code{zap-to-char} function works as a whole.
|
|
7997
|
|
7998 The first argument to @code{kill-region} is the position of the cursor
|
|
7999 when the @code{zap-to-char} command is given---the value of point at
|
|
8000 that time. Within the @code{progn}, the search function then moves
|
|
8001 point to just after the zapped-to-character and @code{point} returns the
|
|
8002 value of this location. The @code{kill-region} function puts together
|
|
8003 these two values of point, the first one as the beginning of the region
|
|
8004 and the second one as the end of the region, and removes the region.
|
|
8005
|
|
8006 The @code{progn} special form is necessary because the
|
|
8007 @code{kill-region} command takes two arguments; and it would fail if
|
|
8008 @code{search-forward} and @code{point} expressions were written in
|
|
8009 sequence as two additional arguments. The @code{progn} expression is
|
|
8010 a single argument to @code{kill-region} and returns the one value that
|
|
8011 @code{kill-region} needs for its second argument.
|
|
8012
|
|
8013 @node kill-region, copy-region-as-kill, zap-to-char, Cutting & Storing Text
|
|
8014 @comment node-name, next, previous, up
|
|
8015 @section @code{kill-region}
|
|
8016 @findex kill-region
|
|
8017
|
|
8018 The @code{zap-to-char} function uses the @code{kill-region} function.
|
|
8019 This function clips text from a region and copies that text to
|
|
8020 the kill ring, from which it may be retrieved.
|
|
8021
|
|
8022 @ignore
|
|
8023 GNU Emacs 22:
|
|
8024
|
|
8025 (defun kill-region (beg end &optional yank-handler)
|
|
8026 "Kill (\"cut\") text between point and mark.
|
|
8027 This deletes the text from the buffer and saves it in the kill ring.
|
|
8028 The command \\[yank] can retrieve it from there.
|
|
8029 \(If you want to kill and then yank immediately, use \\[kill-ring-save].)
|
|
8030
|
|
8031 If you want to append the killed region to the last killed text,
|
|
8032 use \\[append-next-kill] before \\[kill-region].
|
|
8033
|
|
8034 If the buffer is read-only, Emacs will beep and refrain from deleting
|
|
8035 the text, but put the text in the kill ring anyway. This means that
|
|
8036 you can use the killing commands to copy text from a read-only buffer.
|
|
8037
|
|
8038 This is the primitive for programs to kill text (as opposed to deleting it).
|
|
8039 Supply two arguments, character positions indicating the stretch of text
|
|
8040 to be killed.
|
|
8041 Any command that calls this function is a \"kill command\".
|
|
8042 If the previous command was also a kill command,
|
|
8043 the text killed this time appends to the text killed last time
|
|
8044 to make one entry in the kill ring.
|
|
8045
|
|
8046 In Lisp code, optional third arg YANK-HANDLER, if non-nil,
|
|
8047 specifies the yank-handler text property to be set on the killed
|
|
8048 text. See `insert-for-yank'."
|
|
8049 ;; Pass point first, then mark, because the order matters
|
|
8050 ;; when calling kill-append.
|
|
8051 (interactive (list (point) (mark)))
|
|
8052 (unless (and beg end)
|
|
8053 (error "The mark is not set now, so there is no region"))
|
|
8054 (condition-case nil
|
|
8055 (let ((string (filter-buffer-substring beg end t)))
|
|
8056 (when string ;STRING is nil if BEG = END
|
|
8057 ;; Add that string to the kill ring, one way or another.
|
|
8058 (if (eq last-command 'kill-region)
|
|
8059 (kill-append string (< end beg) yank-handler)
|
|
8060 (kill-new string nil yank-handler)))
|
|
8061 (when (or string (eq last-command 'kill-region))
|
|
8062 (setq this-command 'kill-region))
|
|
8063 nil)
|
|
8064 ((buffer-read-only text-read-only)
|
|
8065 ;; The code above failed because the buffer, or some of the characters
|
|
8066 ;; in the region, are read-only.
|
|
8067 ;; We should beep, in case the user just isn't aware of this.
|
|
8068 ;; However, there's no harm in putting
|
|
8069 ;; the region's text in the kill ring, anyway.
|
|
8070 (copy-region-as-kill beg end)
|
|
8071 ;; Set this-command now, so it will be set even if we get an error.
|
|
8072 (setq this-command 'kill-region)
|
|
8073 ;; This should barf, if appropriate, and give us the correct error.
|
|
8074 (if kill-read-only-ok
|
|
8075 (progn (message "Read only text copied to kill ring") nil)
|
|
8076 ;; Signal an error if the buffer is read-only.
|
|
8077 (barf-if-buffer-read-only)
|
|
8078 ;; If the buffer isn't read-only, the text is.
|
|
8079 (signal 'text-read-only (list (current-buffer)))))))
|
|
8080 @end ignore
|
|
8081
|
|
8082 The Emacs 22 version of that function uses @code{condition-case} and
|
|
8083 @code{copy-region-as-kill}, both of which we will explain.
|
|
8084 @code{condition-case} is an important special form.
|
|
8085
|
|
8086 In essence, the @code{kill-region} function calls
|
|
8087 @code{condition-case}, which takes three arguments. In this function,
|
|
8088 the first argument does nothing. The second argument contains the
|
|
8089 code that does the work when all goes well. The third argument
|
|
8090 contains the code that is called in the event of an error.
|
|
8091
|
|
8092 @menu
|
|
8093 * Complete kill-region:: The function definition.
|
|
8094 * condition-case:: Dealing with a problem.
|
|
8095 * Lisp macro::
|
|
8096 @end menu
|
|
8097
|
|
8098 @node Complete kill-region, condition-case, kill-region, kill-region
|
|
8099 @ifnottex
|
|
8100 @unnumberedsubsec The Complete @code{kill-region} Definition
|
|
8101 @end ifnottex
|
|
8102
|
|
8103 @need 1200
|
|
8104 We will go through the @code{condition-case} code in a moment. First,
|
|
8105 let us look at the definition of @code{kill-region}, with comments
|
|
8106 added:
|
|
8107
|
|
8108 @c GNU Emacs 22:
|
|
8109 @smallexample
|
|
8110 @group
|
|
8111 (defun kill-region (beg end)
|
|
8112 "Kill (\"cut\") text between point and mark.
|
|
8113 This deletes the text from the buffer and saves it in the kill ring.
|
|
8114 The command \\[yank] can retrieve it from there. @dots{} "
|
|
8115 @end group
|
|
8116
|
|
8117 @group
|
|
8118 ;; @bullet{} Since order matters, pass point first.
|
|
8119 (interactive (list (point) (mark)))
|
|
8120 ;; @bullet{} And tell us if we cannot cut the text.
|
|
8121 ;; `unless' is an `if' without a then-part.
|
|
8122 (unless (and beg end)
|
|
8123 (error "The mark is not set now, so there is no region"))
|
|
8124 @end group
|
|
8125
|
|
8126 @group
|
|
8127 ;; @bullet{} `condition-case' takes three arguments.
|
|
8128 ;; If the first argument is nil, as it is here,
|
|
8129 ;; information about the error signal is not
|
|
8130 ;; stored for use by another function.
|
|
8131 (condition-case nil
|
|
8132 @end group
|
|
8133
|
|
8134 @group
|
|
8135 ;; @bullet{} The second argument to `condition-case' tells the
|
|
8136 ;; Lisp interpreter what to do when all goes well.
|
|
8137 @end group
|
|
8138
|
|
8139 @group
|
|
8140 ;; It starts with a `let' function that extracts the string
|
|
8141 ;; and tests whether it exists. If so (that is what the
|
|
8142 ;; `when' checks), it calls an `if' function that determines
|
|
8143 ;; whether the previous command was another call to
|
|
8144 ;; `kill-region'; if it was, then the new text is appended to
|
|
8145 ;; the previous text; if not, then a different function,
|
|
8146 ;; `kill-new', is called.
|
|
8147 @end group
|
|
8148
|
|
8149 @group
|
|
8150 ;; The `kill-append' function concatenates the new string and
|
|
8151 ;; the old. The `kill-new' function inserts text into a new
|
|
8152 ;; item in the kill ring.
|
|
8153 @end group
|
|
8154
|
|
8155 @group
|
|
8156 ;; `when' is an `if' without an else-part. The second `when'
|
|
8157 ;; again checks whether the current string exists; in
|
|
8158 ;; addition, it checks whether the previous command was
|
|
8159 ;; another call to `kill-region'. If one or the other
|
|
8160 ;; condition is true, then it sets the current command to
|
|
8161 ;; be `kill-region'.
|
|
8162 @end group
|
|
8163 @group
|
|
8164 (let ((string (filter-buffer-substring beg end t)))
|
|
8165 (when string ;STRING is nil if BEG = END
|
|
8166 ;; Add that string to the kill ring, one way or another.
|
|
8167 (if (eq last-command 'kill-region)
|
|
8168 @end group
|
|
8169 @group
|
|
8170 ;; @minus{} `yank-handler' is an optional argument to
|
|
8171 ;; `kill-region' that tells the `kill-append' and
|
|
8172 ;; `kill-new' functions how deal with properties
|
|
8173 ;; added to the text, such as `bold' or `italics'.
|
|
8174 (kill-append string (< end beg) yank-handler)
|
|
8175 (kill-new string nil yank-handler)))
|
|
8176 (when (or string (eq last-command 'kill-region))
|
|
8177 (setq this-command 'kill-region))
|
|
8178 nil)
|
|
8179 @end group
|
|
8180
|
|
8181 @group
|
|
8182 ;; @bullet{} The third argument to `condition-case' tells the interpreter
|
|
8183 ;; what to do with an error.
|
|
8184 @end group
|
|
8185 @group
|
|
8186 ;; The third argument has a conditions part and a body part.
|
|
8187 ;; If the conditions are met (in this case,
|
|
8188 ;; if text or buffer are read-only)
|
|
8189 ;; then the body is executed.
|
|
8190 @end group
|
|
8191 @group
|
|
8192 ;; The first part of the third argument is the following:
|
|
8193 ((buffer-read-only text-read-only) ;; the if-part
|
|
8194 ;; @dots{} the then-part
|
|
8195 (copy-region-as-kill beg end)
|
|
8196 @end group
|
|
8197 @group
|
|
8198 ;; Next, also as part of the then-part, set this-command, so
|
|
8199 ;; it will be set in an error
|
|
8200 (setq this-command 'kill-region)
|
|
8201 ;; Finally, in the then-part, send a message if you may copy
|
|
8202 ;; the text to the kill ring without signally an error, but
|
|
8203 ;; don't if you may not.
|
|
8204 @end group
|
|
8205 @group
|
|
8206 (if kill-read-only-ok
|
|
8207 (progn (message "Read only text copied to kill ring") nil)
|
|
8208 (barf-if-buffer-read-only)
|
|
8209 ;; If the buffer isn't read-only, the text is.
|
|
8210 (signal 'text-read-only (list (current-buffer)))))
|
|
8211 @end group
|
|
8212 @end smallexample
|
|
8213
|
|
8214 @ignore
|
|
8215 @c v 21
|
|
8216 @smallexample
|
|
8217 @group
|
|
8218 (defun kill-region (beg end)
|
|
8219 "Kill between point and mark.
|
|
8220 The text is deleted but saved in the kill ring."
|
|
8221 (interactive "r")
|
|
8222 @end group
|
|
8223
|
|
8224 @group
|
|
8225 ;; 1. `condition-case' takes three arguments.
|
|
8226 ;; If the first argument is nil, as it is here,
|
|
8227 ;; information about the error signal is not
|
|
8228 ;; stored for use by another function.
|
|
8229 (condition-case nil
|
|
8230 @end group
|
|
8231
|
|
8232 @group
|
|
8233 ;; 2. The second argument to `condition-case'
|
|
8234 ;; tells the Lisp interpreter what to do when all goes well.
|
|
8235 @end group
|
|
8236
|
|
8237 @group
|
|
8238 ;; The `delete-and-extract-region' function usually does the
|
|
8239 ;; work. If the beginning and ending of the region are both
|
|
8240 ;; the same, then the variable `string' will be empty, or nil
|
|
8241 (let ((string (delete-and-extract-region beg end)))
|
|
8242 @end group
|
|
8243
|
|
8244 @group
|
|
8245 ;; `when' is an `if' clause that cannot take an `else-part'.
|
|
8246 ;; Emacs normally sets the value of `last-command' to the
|
|
8247 ;; previous command.
|
|
8248 @end group
|
|
8249 @group
|
|
8250 ;; `kill-append' concatenates the new string and the old.
|
|
8251 ;; `kill-new' inserts text into a new item in the kill ring.
|
|
8252 (when string
|
|
8253 (if (eq last-command 'kill-region)
|
|
8254 ;; if true, prepend string
|
|
8255 (kill-append string (< end beg))
|
|
8256 (kill-new string)))
|
|
8257 (setq this-command 'kill-region))
|
|
8258 @end group
|
|
8259
|
|
8260 @group
|
|
8261 ;; 3. The third argument to `condition-case' tells the interpreter
|
|
8262 ;; what to do with an error.
|
|
8263 @end group
|
|
8264 @group
|
|
8265 ;; The third argument has a conditions part and a body part.
|
|
8266 ;; If the conditions are met (in this case,
|
|
8267 ;; if text or buffer are read-only)
|
|
8268 ;; then the body is executed.
|
|
8269 @end group
|
|
8270 @group
|
|
8271 ((buffer-read-only text-read-only) ;; this is the if-part
|
|
8272 ;; then...
|
|
8273 (copy-region-as-kill beg end)
|
|
8274 @end group
|
|
8275 @group
|
|
8276 (if kill-read-only-ok ;; usually this variable is nil
|
|
8277 (message "Read only text copied to kill ring")
|
|
8278 ;; or else, signal an error if the buffer is read-only;
|
|
8279 (barf-if-buffer-read-only)
|
|
8280 ;; and, in any case, signal that the text is read-only.
|
|
8281 (signal 'text-read-only (list (current-buffer)))))))
|
|
8282 @end group
|
|
8283 @end smallexample
|
|
8284 @end ignore
|
|
8285
|
|
8286 @node condition-case, Lisp macro, Complete kill-region, kill-region
|
|
8287 @comment node-name, next, previous, up
|
|
8288 @subsection @code{condition-case}
|
|
8289 @findex condition-case
|
|
8290
|
|
8291 As we have seen earlier (@pxref{Making Errors, , Generate an Error
|
|
8292 Message}), when the Emacs Lisp interpreter has trouble evaluating an
|
|
8293 expression, it provides you with help; in the jargon, this is called
|
|
8294 ``signaling an error''. Usually, the computer stops the program and
|
|
8295 shows you a message.
|
|
8296
|
|
8297 However, some programs undertake complicated actions. They should not
|
|
8298 simply stop on an error. In the @code{kill-region} function, the most
|
|
8299 likely error is that you will try to kill text that is read-only and
|
|
8300 cannot be removed. So the @code{kill-region} function contains code
|
|
8301 to handle this circumstance. This code, which makes up the body of
|
|
8302 the @code{kill-region} function, is inside of a @code{condition-case}
|
|
8303 special form.
|
|
8304
|
|
8305 @need 800
|
|
8306 The template for @code{condition-case} looks like this:
|
|
8307
|
|
8308 @smallexample
|
|
8309 @group
|
|
8310 (condition-case
|
|
8311 @var{var}
|
|
8312 @var{bodyform}
|
|
8313 @var{error-handler}@dots{})
|
|
8314 @end group
|
|
8315 @end smallexample
|
|
8316
|
|
8317 The second argument, @var{bodyform}, is straightforward. The
|
|
8318 @code{condition-case} special form causes the Lisp interpreter to
|
|
8319 evaluate the code in @var{bodyform}. If no error occurs, the special
|
|
8320 form returns the code's value and produces the side-effects, if any.
|
|
8321
|
|
8322 In short, the @var{bodyform} part of a @code{condition-case}
|
|
8323 expression determines what should happen when everything works
|
|
8324 correctly.
|
|
8325
|
|
8326 However, if an error occurs, among its other actions, the function
|
|
8327 generating the error signal will define one or more error condition
|
|
8328 names.
|
|
8329
|
|
8330 An error handler is the third argument to @code{condition case}.
|
|
8331 An error handler has two parts, a @var{condition-name} and a
|
|
8332 @var{body}. If the @var{condition-name} part of an error handler
|
|
8333 matches a condition name generated by an error, then the @var{body}
|
|
8334 part of the error handler is run.
|
|
8335
|
|
8336 As you will expect, the @var{condition-name} part of an error handler
|
|
8337 may be either a single condition name or a list of condition names.
|
|
8338
|
|
8339 Also, a complete @code{condition-case} expression may contain more
|
|
8340 than one error handler. When an error occurs, the first applicable
|
|
8341 handler is run.
|
|
8342
|
|
8343 Lastly, the first argument to the @code{condition-case} expression,
|
|
8344 the @var{var} argument, is sometimes bound to a variable that
|
|
8345 contains information about the error. However, if that argument is
|
|
8346 nil, as is the case in @code{kill-region}, that information is
|
|
8347 discarded.
|
|
8348
|
|
8349 @need 1200
|
|
8350 In brief, in the @code{kill-region} function, the code
|
|
8351 @code{condition-case} works like this:
|
|
8352
|
|
8353 @smallexample
|
|
8354 @group
|
|
8355 @var{If no errors}, @var{run only this code}
|
|
8356 @var{but}, @var{if errors}, @var{run this other code}.
|
|
8357 @end group
|
|
8358 @end smallexample
|
|
8359
|
|
8360 @ignore
|
|
8361 2006 Oct 24
|
|
8362 In Emacs 22,
|
|
8363 copy-region-as-kill is short, 12 lines, and uses
|
|
8364 filter-buffer-substring, which is longer, 39 lines
|
|
8365 and has delete-and-extract-region in it.
|
|
8366 delete-and-extract-region is written in C.
|
|
8367
|
|
8368 see Initializing a Variable with @code{defvar}
|
|
8369 this is line 8054
|
|
8370 Initializing a Variable with @code{defvar} includes line 8350
|
|
8371 @end ignore
|
|
8372
|
|
8373 @node Lisp macro, , condition-case, kill-region
|
|
8374 @comment node-name, next, previous, up
|
|
8375 @subsection Lisp macro
|
|
8376 @cindex Macro, lisp
|
|
8377 @cindex Lisp macro
|
|
8378
|
|
8379 The part of the @code{condition-case} expression that is evaluated in
|
|
8380 the expectation that all goes well has a @code{when}. The code uses
|
|
8381 @code{when} to determine whether the @code{string} variable points to
|
|
8382 text that exists.
|
|
8383
|
|
8384 A @code{when} expression is simply a programmers' convenience. It is
|
|
8385 an @code{if} without the possibility of an else clause. In your mind,
|
|
8386 you can replace @code{when} with @code{if} and understand what goes
|
|
8387 on. That is what the Lisp interpreter does.
|
|
8388
|
|
8389 Technically speaking, @code{when} is a Lisp macro. A Lisp @dfn{macro}
|
|
8390 enables you to define new control constructs and other language
|
|
8391 features. It tells the interpreter how to compute another Lisp
|
|
8392 expression which will in turn compute the value. In this case, the
|
|
8393 `other expression' is an @code{if} expression.
|
|
8394
|
|
8395 The @code{kill-region} function definition also has an @code{unless}
|
|
8396 macro; it is the converse of @code{when}. The @code{unless} macro is
|
|
8397 an @code{if} without a then clause
|
|
8398
|
|
8399 For more about Lisp macros, see @ref{Macros, , Macros, elisp, The GNU
|
|
8400 Emacs Lisp Reference Manual}. The C programming language also
|
|
8401 provides macros. These are different, but also useful.
|
|
8402
|
|
8403 @ignore
|
|
8404 We will briefly look at C macros in
|
|
8405 @ref{Digression into C}.
|
|
8406 @end ignore
|
|
8407
|
|
8408 @need 1200
|
|
8409 Regarding the @code{when} macro, in the @code{condition-case}
|
|
8410 expression, when the string has content, then another conditional
|
|
8411 expression is executed. This is an @code{if} with both a then-part
|
|
8412 and an else-part.
|
|
8413
|
|
8414 @smallexample
|
|
8415 @group
|
|
8416 (if (eq last-command 'kill-region)
|
|
8417 (kill-append string (< end beg) yank-handler)
|
|
8418 (kill-new string nil yank-handler))
|
|
8419 @end group
|
|
8420 @end smallexample
|
|
8421
|
|
8422 The then-part is evaluated if the previous command was another call to
|
|
8423 @code{kill-region}; if not, the else-part is evaluated.
|
|
8424
|
|
8425 @code{yank-handler} is an optional argument to @code{kill-region} that
|
|
8426 tells the @code{kill-append} and @code{kill-new} functions how deal
|
|
8427 with properties added to the text, such as `bold' or `italics'.
|
|
8428
|
|
8429 @code{last-command} is a variable that comes with Emacs that we have
|
|
8430 not seen before. Normally, whenever a function is executed, Emacs
|
|
8431 sets the value of @code{last-command} to the previous command.
|
|
8432
|
|
8433 @need 1200
|
|
8434 In this segment of the definition, the @code{if} expression checks
|
|
8435 whether the previous command was @code{kill-region}. If it was,
|
|
8436
|
|
8437 @smallexample
|
|
8438 (kill-append string (< end beg) yank-handler)
|
|
8439 @end smallexample
|
|
8440
|
|
8441 @noindent
|
|
8442 concatenates a copy of the newly clipped text to the just previously
|
|
8443 clipped text in the kill ring.
|
|
8444
|
|
8445 @node copy-region-as-kill, Digression into C, kill-region, Cutting & Storing Text
|
|
8446 @comment node-name, next, previous, up
|
|
8447 @section @code{copy-region-as-kill}
|
|
8448 @findex copy-region-as-kill
|
|
8449 @findex nthcdr
|
|
8450
|
|
8451 The @code{copy-region-as-kill} function copies a region of text from a
|
|
8452 buffer and (via either @code{kill-append} or @code{kill-new}) saves it
|
|
8453 in the @code{kill-ring}.
|
|
8454
|
|
8455 If you call @code{copy-region-as-kill} immediately after a
|
|
8456 @code{kill-region} command, Emacs appends the newly copied text to the
|
|
8457 previously copied text. This means that if you yank back the text, you
|
|
8458 get it all, from both this and the previous operation. On the other
|
|
8459 hand, if some other command precedes the @code{copy-region-as-kill},
|
|
8460 the function copies the text into a separate entry in the kill ring.
|
|
8461
|
|
8462 @menu
|
|
8463 * Complete copy-region-as-kill:: The complete function definition.
|
|
8464 * copy-region-as-kill body:: The body of @code{copy-region-as-kill}.
|
|
8465 @end menu
|
|
8466
|
|
8467 @node Complete copy-region-as-kill, copy-region-as-kill body, copy-region-as-kill, copy-region-as-kill
|
|
8468 @ifnottex
|
|
8469 @unnumberedsubsec The complete @code{copy-region-as-kill} function definition
|
|
8470 @end ifnottex
|
|
8471
|
|
8472 @need 1200
|
|
8473 Here is the complete text of the version 22 @code{copy-region-as-kill}
|
|
8474 function:
|
|
8475
|
|
8476 @smallexample
|
|
8477 @group
|
|
8478 (defun copy-region-as-kill (beg end)
|
|
8479 "Save the region as if killed, but don't kill it.
|
|
8480 In Transient Mark mode, deactivate the mark.
|
|
8481 If `interprogram-cut-function' is non-nil, also save the text for a window
|
|
8482 system cut and paste."
|
|
8483 (interactive "r")
|
|
8484 @end group
|
|
8485 @group
|
|
8486 (if (eq last-command 'kill-region)
|
|
8487 (kill-append (filter-buffer-substring beg end) (< end beg))
|
|
8488 (kill-new (filter-buffer-substring beg end)))
|
|
8489 @end group
|
|
8490 @group
|
|
8491 (if transient-mark-mode
|
|
8492 (setq deactivate-mark t))
|
|
8493 nil)
|
|
8494 @end group
|
|
8495 @end smallexample
|
|
8496
|
|
8497 @need 800
|
|
8498 As usual, this function can be divided into its component parts:
|
|
8499
|
|
8500 @smallexample
|
|
8501 @group
|
|
8502 (defun copy-region-as-kill (@var{argument-list})
|
|
8503 "@var{documentation}@dots{}"
|
|
8504 (interactive "r")
|
|
8505 @var{body}@dots{})
|
|
8506 @end group
|
|
8507 @end smallexample
|
|
8508
|
|
8509 The arguments are @code{beg} and @code{end} and the function is
|
|
8510 interactive with @code{"r"}, so the two arguments must refer to the
|
|
8511 beginning and end of the region. If you have been reading though this
|
|
8512 document from the beginning, understanding these parts of a function is
|
|
8513 almost becoming routine.
|
|
8514
|
|
8515 The documentation is somewhat confusing unless you remember that the
|
|
8516 word `kill' has a meaning different from usual. The `Transient Mark'
|
|
8517 and @code{interprogram-cut-function} comments explain certain
|
|
8518 side-effects.
|
|
8519
|
|
8520 After you once set a mark, a buffer always contains a region. If you
|
|
8521 wish, you can use Transient Mark mode to highlight the region
|
|
8522 temporarily. (No one wants to highlight the region all the time, so
|
|
8523 Transient Mark mode highlights it only at appropriate times. Many
|
|
8524 people turn off Transient Mark mode, so the region is never
|
|
8525 highlighted.)
|
|
8526
|
|
8527 Also, a windowing system allows you to copy, cut, and paste among
|
|
8528 different programs. In the X windowing system, for example, the
|
|
8529 @code{interprogram-cut-function} function is @code{x-select-text},
|
|
8530 which works with the windowing system's equivalent of the Emacs kill
|
|
8531 ring.
|
|
8532
|
|
8533 The body of the @code{copy-region-as-kill} function starts with an
|
|
8534 @code{if} clause. What this clause does is distinguish between two
|
|
8535 different situations: whether or not this command is executed
|
|
8536 immediately after a previous @code{kill-region} command. In the first
|
|
8537 case, the new region is appended to the previously copied text.
|
|
8538 Otherwise, it is inserted into the beginning of the kill ring as a
|
|
8539 separate piece of text from the previous piece.
|
|
8540
|
|
8541 The last two lines of the function prevent the region from lighting up
|
|
8542 if Transient Mark mode is turned on.
|
|
8543
|
|
8544 The body of @code{copy-region-as-kill} merits discussion in detail.
|
|
8545
|
|
8546 @node copy-region-as-kill body, , Complete copy-region-as-kill, copy-region-as-kill
|
|
8547 @comment node-name, next, previous, up
|
|
8548 @subsection The Body of @code{copy-region-as-kill}
|
|
8549
|
|
8550 The @code{copy-region-as-kill} function works in much the same way as
|
|
8551 the @code{kill-region} function. Both are written so that two or more
|
|
8552 kills in a row combine their text into a single entry. If you yank
|
|
8553 back the text from the kill ring, you get it all in one piece.
|
|
8554 Moreover, kills that kill forward from the current position of the
|
|
8555 cursor are added to the end of the previously copied text and commands
|
|
8556 that copy text backwards add it to the beginning of the previously
|
|
8557 copied text. This way, the words in the text stay in the proper
|
|
8558 order.
|
|
8559
|
|
8560 Like @code{kill-region}, the @code{copy-region-as-kill} function makes
|
|
8561 use of the @code{last-command} variable that keeps track of the
|
|
8562 previous Emacs command.
|
|
8563
|
|
8564 @menu
|
|
8565 * last-command & this-command::
|
|
8566 * kill-append function::
|
|
8567 * kill-new function::
|
|
8568 @end menu
|
|
8569
|
|
8570 @node last-command & this-command, kill-append function, copy-region-as-kill body, copy-region-as-kill body
|
|
8571 @ifnottex
|
|
8572 @unnumberedsubsubsec @code{last-command} and @code{this-command}
|
|
8573 @end ifnottex
|
|
8574
|
|
8575 Normally, whenever a function is executed, Emacs sets the value of
|
|
8576 @code{this-command} to the function being executed (which in this case
|
|
8577 would be @code{copy-region-as-kill}). At the same time, Emacs sets
|
|
8578 the value of @code{last-command} to the previous value of
|
|
8579 @code{this-command}.
|
|
8580
|
|
8581 In the first part of the body of the @code{copy-region-as-kill}
|
|
8582 function, an @code{if} expression determines whether the value of
|
|
8583 @code{last-command} is @code{kill-region}. If so, the then-part of
|
|
8584 the @code{if} expression is evaluated; it uses the @code{kill-append}
|
|
8585 function to concatenate the text copied at this call to the function
|
|
8586 with the text already in the first element (the @sc{car}) of the kill
|
|
8587 ring. On the other hand, if the value of @code{last-command} is not
|
|
8588 @code{kill-region}, then the @code{copy-region-as-kill} function
|
|
8589 attaches a new element to the kill ring using the @code{kill-new}
|
|
8590 function.
|
|
8591
|
|
8592 @need 1250
|
|
8593 The @code{if} expression reads as follows; it uses @code{eq}:
|
|
8594
|
|
8595 @smallexample
|
|
8596 @group
|
|
8597 (if (eq last-command 'kill-region)
|
|
8598 ;; @r{then-part}
|
|
8599 (kill-append (filter-buffer-substring beg end) (< end beg))
|
|
8600 ;; @r{else-part}
|
|
8601 (kill-new (filter-buffer-substring beg end)))
|
|
8602 @end group
|
|
8603 @end smallexample
|
|
8604
|
|
8605 @findex filter-buffer-substring
|
|
8606 (The @code{filter-buffer-substring} function returns a filtered
|
|
8607 substring of the buffer, if any. Optionally---the arguments are not
|
|
8608 here, so neither is done---the function may delete the initial text or
|
|
8609 return the text without its properties; this function is a replacement
|
|
8610 for the older @code{buffer-substring} function, which came before text
|
|
8611 properties were implemented.)
|
|
8612
|
|
8613 @findex eq @r{(example of use)}
|
|
8614 @noindent
|
|
8615 The @code{eq} function tests whether its first argument is the same Lisp
|
|
8616 object as its second argument. The @code{eq} function is similar to the
|
|
8617 @code{equal} function in that it is used to test for equality, but
|
|
8618 differs in that it determines whether two representations are actually
|
|
8619 the same object inside the computer, but with different names.
|
|
8620 @code{equal} determines whether the structure and contents of two
|
|
8621 expressions are the same.
|
|
8622
|
|
8623 If the previous command was @code{kill-region}, then the Emacs Lisp
|
|
8624 interpreter calls the @code{kill-append} function
|
|
8625
|
|
8626 @node kill-append function, kill-new function, last-command & this-command, copy-region-as-kill body
|
|
8627 @unnumberedsubsubsec The @code{kill-append} function
|
|
8628 @findex kill-append
|
|
8629
|
|
8630 @need 800
|
|
8631 The @code{kill-append} function looks like this:
|
|
8632
|
|
8633 @c in GNU Emacs 22
|
|
8634 @smallexample
|
|
8635 @group
|
|
8636 (defun kill-append (string before-p &optional yank-handler)
|
|
8637 "Append STRING to the end of the latest kill in the kill ring.
|
|
8638 If BEFORE-P is non-nil, prepend STRING to the kill.
|
|
8639 @dots{} "
|
|
8640 (let* ((cur (car kill-ring)))
|
|
8641 (kill-new (if before-p (concat string cur) (concat cur string))
|
|
8642 (or (= (length cur) 0)
|
|
8643 (equal yank-handler
|
|
8644 (get-text-property 0 'yank-handler cur)))
|
|
8645 yank-handler)))
|
|
8646 @end group
|
|
8647 @end smallexample
|
|
8648
|
|
8649 @ignore
|
|
8650 was:
|
|
8651 (defun kill-append (string before-p)
|
|
8652 "Append STRING to the end of the latest kill in the kill ring.
|
|
8653 If BEFORE-P is non-nil, prepend STRING to the kill.
|
|
8654 If `interprogram-cut-function' is set, pass the resulting kill to
|
|
8655 it."
|
|
8656 (kill-new (if before-p
|
|
8657 (concat string (car kill-ring))
|
|
8658 (concat (car kill-ring) string))
|
|
8659 t))
|
|
8660 @end ignore
|
|
8661
|
|
8662 @noindent
|
|
8663 The @code{kill-append} function is fairly straightforward. It uses
|
|
8664 the @code{kill-new} function, which we will discuss in more detail in
|
|
8665 a moment.
|
|
8666
|
|
8667 (Also, the function provides an optional argument called
|
|
8668 @code{yank-handler}; when invoked, this argument tells the function
|
|
8669 how to deal with properties added to the text, such as `bold' or
|
|
8670 `italics'.)
|
|
8671
|
|
8672 @c !!! bug in GNU Emacs 22 version of kill-append ?
|
|
8673 It has a @code{let*} function to set the value of the first element of
|
|
8674 the kill ring to @code{cur}. (I do not know why the function does not
|
|
8675 use @code{let} instead; only one value is set in the expression.
|
|
8676 Perhaps this is a bug that produces no problems?)
|
|
8677
|
|
8678 Consider the conditional that is one of the two arguments to
|
|
8679 @code{kill-new}. It uses @code{concat} to concatenate the new text to
|
|
8680 the @sc{car} of the kill ring. Whether it prepends or appends the
|
|
8681 text depends on the results of an @code{if} expression:
|
|
8682
|
|
8683 @smallexample
|
|
8684 @group
|
|
8685 (if before-p ; @r{if-part}
|
|
8686 (concat string cur) ; @r{then-part}
|
|
8687 (concat cur string)) ; @r{else-part}
|
|
8688 @end group
|
|
8689 @end smallexample
|
|
8690
|
|
8691 @noindent
|
|
8692 If the region being killed is before the region that was killed in the
|
|
8693 last command, then it should be prepended before the material that was
|
|
8694 saved in the previous kill; and conversely, if the killed text follows
|
|
8695 what was just killed, it should be appended after the previous text.
|
|
8696 The @code{if} expression depends on the predicate @code{before-p} to
|
|
8697 decide whether the newly saved text should be put before or after the
|
|
8698 previously saved text.
|
|
8699
|
|
8700 The symbol @code{before-p} is the name of one of the arguments to
|
|
8701 @code{kill-append}. When the @code{kill-append} function is
|
|
8702 evaluated, it is bound to the value returned by evaluating the actual
|
|
8703 argument. In this case, this is the expression @code{(< end beg)}.
|
|
8704 This expression does not directly determine whether the killed text in
|
|
8705 this command is located before or after the kill text of the last
|
|
8706 command; what it does is determine whether the value of the variable
|
|
8707 @code{end} is less than the value of the variable @code{beg}. If it
|
|
8708 is, it means that the user is most likely heading towards the
|
|
8709 beginning of the buffer. Also, the result of evaluating the predicate
|
|
8710 expression, @code{(< end beg)}, will be true and the text will be
|
|
8711 prepended before the previous text. On the other hand, if the value of
|
|
8712 the variable @code{end} is greater than the value of the variable
|
|
8713 @code{beg}, the text will be appended after the previous text.
|
|
8714
|
|
8715 @need 800
|
|
8716 When the newly saved text will be prepended, then the string with the new
|
|
8717 text will be concatenated before the old text:
|
|
8718
|
|
8719 @smallexample
|
|
8720 (concat string cur)
|
|
8721 @end smallexample
|
|
8722
|
|
8723 @need 1200
|
|
8724 @noindent
|
|
8725 But if the text will be appended, it will be concatenated
|
|
8726 after the old text:
|
|
8727
|
|
8728 @smallexample
|
|
8729 (concat cur string))
|
|
8730 @end smallexample
|
|
8731
|
|
8732 To understand how this works, we first need to review the
|
|
8733 @code{concat} function. The @code{concat} function links together or
|
|
8734 unites two strings of text. The result is a string. For example:
|
|
8735
|
|
8736 @smallexample
|
|
8737 @group
|
|
8738 (concat "abc" "def")
|
|
8739 @result{} "abcdef"
|
|
8740 @end group
|
|
8741
|
|
8742 @group
|
|
8743 (concat "new "
|
|
8744 (car '("first element" "second element")))
|
|
8745 @result{} "new first element"
|
|
8746
|
|
8747 (concat (car
|
|
8748 '("first element" "second element")) " modified")
|
|
8749 @result{} "first element modified"
|
|
8750 @end group
|
|
8751 @end smallexample
|
|
8752
|
|
8753 We can now make sense of @code{kill-append}: it modifies the contents
|
|
8754 of the kill ring. The kill ring is a list, each element of which is
|
|
8755 saved text. The @code{kill-append} function uses the @code{kill-new}
|
|
8756 function which in turn uses the @code{setcar} function.
|
|
8757
|
|
8758 @node kill-new function, , kill-append function, copy-region-as-kill body
|
|
8759 @unnumberedsubsubsec The @code{kill-new} function
|
|
8760 @findex kill-new
|
|
8761
|
|
8762 @c in GNU Emacs 22, additional documentation to kill-new:
|
|
8763 @ignore
|
|
8764 Optional third arguments YANK-HANDLER controls how the STRING is later
|
|
8765 inserted into a buffer; see `insert-for-yank' for details.
|
|
8766 When a yank handler is specified, STRING must be non-empty (the yank
|
|
8767 handler, if non-nil, is stored as a `yank-handler' text property on STRING).
|
|
8768
|
|
8769 When the yank handler has a non-nil PARAM element, the original STRING
|
|
8770 argument is not used by `insert-for-yank'. However, since Lisp code
|
|
8771 may access and use elements from the kill ring directly, the STRING
|
|
8772 argument should still be a \"useful\" string for such uses."
|
|
8773 @end ignore
|
|
8774 @need 1200
|
|
8775 The @code{kill-new} function looks like this:
|
|
8776
|
|
8777 @smallexample
|
|
8778 @group
|
|
8779 (defun kill-new (string &optional replace yank-handler)
|
|
8780 "Make STRING the latest kill in the kill ring.
|
|
8781 Set `kill-ring-yank-pointer' to point to it.
|
|
8782
|
|
8783 If `interprogram-cut-function' is non-nil, apply it to STRING.
|
|
8784 Optional second argument REPLACE non-nil means that STRING will replace
|
|
8785 the front of the kill ring, rather than being added to the list.
|
|
8786 @dots{}"
|
|
8787 @end group
|
|
8788 @group
|
|
8789 (if (> (length string) 0)
|
|
8790 (if yank-handler
|
|
8791 (put-text-property 0 (length string)
|
|
8792 'yank-handler yank-handler string))
|
|
8793 (if yank-handler
|
|
8794 (signal 'args-out-of-range
|
|
8795 (list string "yank-handler specified for empty string"))))
|
|
8796 @end group
|
|
8797 @group
|
|
8798 (if (fboundp 'menu-bar-update-yank-menu)
|
|
8799 (menu-bar-update-yank-menu string (and replace (car kill-ring))))
|
|
8800 @end group
|
|
8801 @group
|
|
8802 (if (and replace kill-ring)
|
|
8803 (setcar kill-ring string)
|
|
8804 (push string kill-ring)
|
|
8805 (if (> (length kill-ring) kill-ring-max)
|
|
8806 (setcdr (nthcdr (1- kill-ring-max) kill-ring) nil)))
|
|
8807 @end group
|
|
8808 @group
|
|
8809 (setq kill-ring-yank-pointer kill-ring)
|
|
8810 (if interprogram-cut-function
|
|
8811 (funcall interprogram-cut-function string (not replace))))
|
|
8812 @end group
|
|
8813 @end smallexample
|
|
8814 @ignore
|
|
8815 was:
|
|
8816 (defun kill-new (string &optional replace)
|
|
8817 "Make STRING the latest kill in the kill ring.
|
|
8818 Set the kill-ring-yank pointer to point to it.
|
|
8819 If `interprogram-cut-function' is non-nil, apply it to STRING.
|
|
8820 Optional second argument REPLACE non-nil means that STRING will replace
|
|
8821 the front of the kill ring, rather than being added to the list."
|
|
8822 (and (fboundp 'menu-bar-update-yank-menu)
|
|
8823 (menu-bar-update-yank-menu string (and replace (car kill-ring))))
|
|
8824 (if (and replace kill-ring)
|
|
8825 (setcar kill-ring string)
|
|
8826 (setq kill-ring (cons string kill-ring))
|
|
8827 (if (> (length kill-ring) kill-ring-max)
|
|
8828 (setcdr (nthcdr (1- kill-ring-max) kill-ring) nil)))
|
|
8829 (setq kill-ring-yank-pointer kill-ring)
|
|
8830 (if interprogram-cut-function
|
|
8831 (funcall interprogram-cut-function string (not replace))))
|
|
8832 @end ignore
|
|
8833
|
|
8834 (Notice that the function is not interactive.)
|
|
8835
|
|
8836 As usual, we can look at this function in parts.
|
|
8837
|
|
8838 The function definition has an optional @code{yank-handler} argument,
|
|
8839 which when invoked tells the function how to deal with properties
|
|
8840 added to the text, such as `bold' or `italics'. We will skip that.
|
|
8841
|
|
8842 @need 1200
|
|
8843 The first line of the documentation makes sense:
|
|
8844
|
|
8845 @smallexample
|
|
8846 Make STRING the latest kill in the kill ring.
|
|
8847 @end smallexample
|
|
8848
|
|
8849 @noindent
|
|
8850 Let's skip over the rest of the documentation for the moment.
|
|
8851
|
|
8852 @noindent
|
|
8853 Also, let's skip over the initial @code{if} expression and those lines
|
|
8854 of code involving @code{menu-bar-update-yank-menu}. We will explain
|
|
8855 them below.
|
|
8856
|
|
8857 @need 1200
|
|
8858 The critical lines are these:
|
|
8859
|
|
8860 @smallexample
|
|
8861 @group
|
|
8862 (if (and replace kill-ring)
|
|
8863 ;; @r{then}
|
|
8864 (setcar kill-ring string)
|
|
8865 @end group
|
|
8866 @group
|
|
8867 ;; @r{else}
|
|
8868 (push string kill-ring)
|
|
8869 @end group
|
|
8870 @group
|
|
8871 (setq kill-ring (cons string kill-ring))
|
|
8872 (if (> (length kill-ring) kill-ring-max)
|
|
8873 ;; @r{avoid overly long kill ring}
|
|
8874 (setcdr (nthcdr (1- kill-ring-max) kill-ring) nil)))
|
|
8875 @end group
|
|
8876 @group
|
|
8877 (setq kill-ring-yank-pointer kill-ring)
|
|
8878 (if interprogram-cut-function
|
|
8879 (funcall interprogram-cut-function string (not replace))))
|
|
8880 @end group
|
|
8881 @end smallexample
|
|
8882
|
|
8883 The conditional test is @w{@code{(and replace kill-ring)}}.
|
|
8884 This will be true when two conditions are met: the kill ring has
|
|
8885 something in it, and the @code{replace} variable is true.
|
|
8886
|
|
8887 @need 1250
|
|
8888 When the @code{kill-append} function sets @code{replace} to be true
|
|
8889 and when the kill ring has at least one item in it, the @code{setcar}
|
|
8890 expression is executed:
|
|
8891
|
|
8892 @smallexample
|
|
8893 (setcar kill-ring string)
|
|
8894 @end smallexample
|
|
8895
|
|
8896 The @code{setcar} function actually changes the first element of the
|
|
8897 @code{kill-ring} list to the value of @code{string}. It replaces the
|
|
8898 first element.
|
|
8899
|
|
8900 @need 1250
|
|
8901 On the other hand, if the kill ring is empty, or replace is false, the
|
|
8902 else-part of the condition is executed:
|
|
8903
|
|
8904 @smallexample
|
|
8905 (push string kill-ring)
|
|
8906 @end smallexample
|
|
8907
|
|
8908 @noindent
|
|
8909 @need 1250
|
|
8910 @code{push} puts its first argument onto the second. It is similar to
|
|
8911 the older
|
|
8912
|
|
8913 @smallexample
|
|
8914 (setq kill-ring (cons string kill-ring))
|
|
8915 @end smallexample
|
|
8916
|
|
8917 @noindent
|
|
8918 @need 1250
|
|
8919 or the newer
|
|
8920
|
|
8921 @smallexample
|
|
8922 (add-to-list kill-ring string)
|
|
8923 @end smallexample
|
|
8924
|
|
8925 @noindent
|
|
8926 When it is false, the expression first constructs a new version of the
|
|
8927 kill ring by prepending @code{string} to the existing kill ring as a
|
|
8928 new element (that is what the @code{push} does). Then it executes a
|
|
8929 second @code{if} clause. This second @code{if} clause keeps the kill
|
|
8930 ring from growing too long.
|
|
8931
|
|
8932 Let's look at these two expressions in order.
|
|
8933
|
|
8934 The @code{push} line of the else-part sets the new value of the kill
|
|
8935 ring to what results from adding the string being killed to the old
|
|
8936 kill ring.
|
|
8937
|
|
8938 We can see how this works with an example.
|
|
8939
|
|
8940 @need 800
|
|
8941 First,
|
|
8942
|
|
8943 @smallexample
|
|
8944 (setq example-list '("here is a clause" "another clause"))
|
|
8945 @end smallexample
|
|
8946
|
|
8947 @need 1200
|
|
8948 @noindent
|
|
8949 After evaluating this expression with @kbd{C-x C-e}, you can evaluate
|
|
8950 @code{example-list} and see what it returns:
|
|
8951
|
|
8952 @smallexample
|
|
8953 @group
|
|
8954 example-list
|
|
8955 @result{} ("here is a clause" "another clause")
|
|
8956 @end group
|
|
8957 @end smallexample
|
|
8958
|
|
8959 @need 1200
|
|
8960 @noindent
|
|
8961 Now, we can add a new element on to this list by evaluating the
|
|
8962 following expression:
|
|
8963 @findex push, @r{example}
|
|
8964
|
|
8965 @smallexample
|
|
8966 (push "a third clause" example-list)
|
|
8967 @end smallexample
|
|
8968
|
|
8969 @need 800
|
|
8970 @noindent
|
|
8971 When we evaluate @code{example-list}, we find its value is:
|
|
8972
|
|
8973 @smallexample
|
|
8974 @group
|
|
8975 example-list
|
|
8976 @result{} ("a third clause" "here is a clause" "another clause")
|
|
8977 @end group
|
|
8978 @end smallexample
|
|
8979
|
|
8980 @noindent
|
|
8981 Thus, the third clause is added to the list by @code{push}.
|
|
8982
|
|
8983 @need 1200
|
|
8984 Now for the second part of the @code{if} clause. This expression
|
|
8985 keeps the kill ring from growing too long. It looks like this:
|
|
8986
|
|
8987 @smallexample
|
|
8988 @group
|
|
8989 (if (> (length kill-ring) kill-ring-max)
|
|
8990 (setcdr (nthcdr (1- kill-ring-max) kill-ring) nil))
|
|
8991 @end group
|
|
8992 @end smallexample
|
|
8993
|
|
8994 The code checks whether the length of the kill ring is greater than
|
|
8995 the maximum permitted length. This is the value of
|
|
8996 @code{kill-ring-max} (which is 60, by default). If the length of the
|
|
8997 kill ring is too long, then this code sets the last element of the
|
|
8998 kill ring to @code{nil}. It does this by using two functions,
|
|
8999 @code{nthcdr} and @code{setcdr}.
|
|
9000
|
|
9001 We looked at @code{setcdr} earlier (@pxref{setcdr, , @code{setcdr}}).
|
|
9002 It sets the @sc{cdr} of a list, just as @code{setcar} sets the
|
|
9003 @sc{car} of a list. In this case, however, @code{setcdr} will not be
|
|
9004 setting the @sc{cdr} of the whole kill ring; the @code{nthcdr}
|
|
9005 function is used to cause it to set the @sc{cdr} of the next to last
|
|
9006 element of the kill ring---this means that since the @sc{cdr} of the
|
|
9007 next to last element is the last element of the kill ring, it will set
|
|
9008 the last element of the kill ring.
|
|
9009
|
|
9010 @findex nthcdr, @r{example}
|
|
9011 The @code{nthcdr} function works by repeatedly taking the @sc{cdr} of a
|
|
9012 list---it takes the @sc{cdr} of the @sc{cdr} of the @sc{cdr}
|
|
9013 @dots{} It does this @var{N} times and returns the results.
|
|
9014 (@xref{nthcdr, , @code{nthcdr}}.)
|
|
9015
|
|
9016 @findex setcdr, @r{example}
|
|
9017 Thus, if we had a four element list that was supposed to be three
|
|
9018 elements long, we could set the @sc{cdr} of the next to last element
|
|
9019 to @code{nil}, and thereby shorten the list. (If you set the last
|
|
9020 element to some other value than @code{nil}, which you could do, then
|
|
9021 you would not have shortened the list. @xref{setcdr, ,
|
|
9022 @code{setcdr}}.)
|
|
9023
|
|
9024 You can see shortening by evaluating the following three expressions
|
|
9025 in turn. First set the value of @code{trees} to @code{(maple oak pine
|
|
9026 birch)}, then set the @sc{cdr} of its second @sc{cdr} to @code{nil}
|
|
9027 and then find the value of @code{trees}:
|
|
9028
|
|
9029 @smallexample
|
|
9030 @group
|
|
9031 (setq trees '(maple oak pine birch))
|
|
9032 @result{} (maple oak pine birch)
|
|
9033 @end group
|
|
9034
|
|
9035 @group
|
|
9036 (setcdr (nthcdr 2 trees) nil)
|
|
9037 @result{} nil
|
|
9038
|
|
9039 trees
|
|
9040 @result{} (maple oak pine)
|
|
9041 @end group
|
|
9042 @end smallexample
|
|
9043
|
|
9044 @noindent
|
|
9045 (The value returned by the @code{setcdr} expression is @code{nil} since
|
|
9046 that is what the @sc{cdr} is set to.)
|
|
9047
|
|
9048 To repeat, in @code{kill-new}, the @code{nthcdr} function takes the
|
|
9049 @sc{cdr} a number of times that is one less than the maximum permitted
|
|
9050 size of the kill ring and @code{setcdr} sets the @sc{cdr} of that
|
|
9051 element (which will be the rest of the elements in the kill ring) to
|
|
9052 @code{nil}. This prevents the kill ring from growing too long.
|
|
9053
|
|
9054 @need 800
|
|
9055 The next to last expression in the @code{kill-new} function is
|
|
9056
|
|
9057 @smallexample
|
|
9058 (setq kill-ring-yank-pointer kill-ring)
|
|
9059 @end smallexample
|
|
9060
|
|
9061 The @code{kill-ring-yank-pointer} is a global variable that is set to be
|
|
9062 the @code{kill-ring}.
|
|
9063
|
|
9064 Even though the @code{kill-ring-yank-pointer} is called a
|
|
9065 @samp{pointer}, it is a variable just like the kill ring. However, the
|
|
9066 name has been chosen to help humans understand how the variable is used.
|
|
9067
|
|
9068 @need 1200
|
|
9069 Now, to return to an early expression in the body of the function:
|
|
9070
|
|
9071 @smallexample
|
|
9072 @group
|
|
9073 (if (fboundp 'menu-bar-update-yank-menu)
|
|
9074 (menu-bar-update-yank-menu string (and replace (car kill-ring))))
|
|
9075 @end group
|
|
9076 @end smallexample
|
|
9077
|
|
9078 @noindent
|
|
9079 It starts with an @code{if} expression
|
|
9080
|
|
9081 In this case, the expression tests first to see whether
|
|
9082 @code{menu-bar-update-yank-menu} exists as a function, and if so,
|
|
9083 calls it. The @code{fboundp} function returns true if the symbol it
|
|
9084 is testing has a function definition that `is not void'. If the
|
|
9085 symbol's function definition were void, we would receive an error
|
|
9086 message, as we did when we created errors intentionally (@pxref{Making
|
|
9087 Errors, , Generate an Error Message}).
|
|
9088
|
|
9089 @noindent
|
|
9090 The then-part contains an expression whose first element is the
|
|
9091 function @code{and}.
|
|
9092
|
|
9093 @findex and
|
|
9094 The @code{and} special form evaluates each of its arguments until one
|
|
9095 of the arguments returns a value of @code{nil}, in which case the
|
|
9096 @code{and} expression returns @code{nil}; however, if none of the
|
|
9097 arguments returns a value of @code{nil}, the value resulting from
|
|
9098 evaluating the last argument is returned. (Since such a value is not
|
|
9099 @code{nil}, it is considered true in Emacs Lisp.) In other words, an
|
|
9100 @code{and} expression returns a true value only if all its arguments
|
|
9101 are true. (@xref{Second Buffer Related Review}.)
|
|
9102
|
|
9103 The expression determines whether the second argument to
|
|
9104 @code{menu-bar-update-yank-menu} is true or not.
|
|
9105 @ignore
|
|
9106 ;; If we're supposed to be extending an existing string, and that
|
|
9107 ;; string really is at the front of the menu, then update it in place.
|
|
9108 @end ignore
|
|
9109
|
|
9110 @code{menu-bar-update-yank-menu} is one of the functions that make it
|
|
9111 possible to use the `Select and Paste' menu in the Edit item of a menu
|
|
9112 bar; using a mouse, you can look at the various pieces of text you
|
|
9113 have saved and select one piece to paste.
|
|
9114
|
|
9115 The last expression in the @code{kill-new} function adds the newly
|
|
9116 copied string to whatever facility exists for copying and pasting
|
|
9117 among different programs running in a windowing system. In the X
|
|
9118 Windowing system, for example, the @code{x-select-text} function takes
|
|
9119 the string and stores it in memory operated by X. You can paste the
|
|
9120 string in another program, such as an Xterm.
|
|
9121
|
|
9122 @need 1200
|
|
9123 The expression looks like this:
|
|
9124
|
|
9125 @smallexample
|
|
9126 @group
|
|
9127 (if interprogram-cut-function
|
|
9128 (funcall interprogram-cut-function string (not replace))))
|
|
9129 @end group
|
|
9130 @end smallexample
|
|
9131
|
|
9132 If an @code{interprogram-cut-function} exists, then Emacs executes
|
|
9133 @code{funcall}, which in turn calls its first argument as a function
|
|
9134 and passes the remaining arguments to it. (Incidentally, as far as I
|
|
9135 can see, this @code{if} expression could be replaced by an @code{and}
|
|
9136 expression similar to the one in the first part of the function.)
|
|
9137
|
|
9138 We are not going to discuss windowing systems and other programs
|
|
9139 further, but merely note that this is a mechanism that enables GNU
|
|
9140 Emacs to work easily and well with other programs.
|
|
9141
|
|
9142 This code for placing text in the kill ring, either concatenated with
|
|
9143 an existing element or as a new element, leads us to the code for
|
|
9144 bringing back text that has been cut out of the buffer---the yank
|
|
9145 commands. However, before discussing the yank commands, it is better
|
|
9146 to learn how lists are implemented in a computer. This will make
|
|
9147 clear such mysteries as the use of the term `pointer'. But before
|
|
9148 that, we will digress into C.
|
|
9149
|
|
9150 @ignore
|
|
9151 @c is this true in Emacs 22? Does not seems to be
|
|
9152
|
|
9153 (If the @w{@code{(< end beg))}}
|
|
9154 expression is true, @code{kill-append} prepends the string to the just
|
|
9155 previously clipped text. For a detailed discussion, see
|
|
9156 @ref{kill-append function, , The @code{kill-append} function}.)
|
|
9157
|
|
9158 If you then yank back the text, i.e., `paste' it, you get both
|
|
9159 pieces of text at once. That way, if you delete two words in a row,
|
|
9160 and then yank them back, you get both words, in their proper order,
|
|
9161 with one yank. (The @w{@code{(< end beg))}} expression makes sure the
|
|
9162 order is correct.)
|
|
9163
|
|
9164 On the other hand, if the previous command is not @code{kill-region},
|
|
9165 then the @code{kill-new} function is called, which adds the text to
|
|
9166 the kill ring as the latest item, and sets the
|
|
9167 @code{kill-ring-yank-pointer} variable to point to it.
|
|
9168 @end ignore
|
|
9169 @ignore
|
|
9170
|
|
9171 @c Evidently, changed for Emacs 22. The zap-to-char command does not
|
|
9172 @c use the delete-and-extract-region function
|
|
9173
|
|
9174 2006 Oct 26, the Digression into C is now OK but should come after
|
|
9175 copy-region-as-kill and filter-buffer-substring
|
|
9176
|
|
9177 2006 Oct 24
|
|
9178 In Emacs 22,
|
|
9179 copy-region-as-kill is short, 12 lines, and uses
|
|
9180 filter-buffer-substring, which is longer, 39 lines
|
|
9181 and has delete-and-extract-region in it.
|
|
9182 delete-and-extract-region is written in C.
|
|
9183
|
|
9184 see Initializing a Variable with @code{defvar}
|
|
9185 @end ignore
|
|
9186
|
|
9187 @node Digression into C, defvar, copy-region-as-kill, Cutting & Storing Text
|
|
9188 @comment node-name, next, previous, up
|
|
9189 @section Digression into C
|
|
9190 @findex delete-and-extract-region
|
|
9191 @cindex C, a digression into
|
|
9192 @cindex Digression into C
|
|
9193
|
|
9194 The @code{copy-region-as-kill} function (@pxref{copy-region-as-kill, ,
|
|
9195 @code{copy-region-as-kill}}) uses the @code{filter-buffer-substring}
|
|
9196 function, which in turn uses the @code{delete-and-extract-region}
|
|
9197 function. It removes the contents of a region and you cannot get them
|
|
9198 back.
|
|
9199
|
|
9200 Unlike the other code discussed here, the
|
|
9201 @code{delete-and-extract-region} function is not written in Emacs
|
|
9202 Lisp; it is written in C and is one of the primitives of the GNU Emacs
|
|
9203 system. Since it is very simple, I will digress briefly from Lisp and
|
|
9204 describe it here.
|
|
9205
|
|
9206 @c GNU Emacs 22 in /usr/local/src/emacs/src/editfns.c
|
|
9207 @c the DEFUN for buffer-substring-no-properties
|
|
9208
|
|
9209 @need 1500
|
|
9210 Like many of the other Emacs primitives,
|
|
9211 @code{delete-and-extract-region} is written as an instance of a C
|
|
9212 macro, a macro being a template for code. The complete macro looks
|
|
9213 like this:
|
|
9214
|
|
9215 @smallexample
|
|
9216 @group
|
|
9217 DEFUN ("buffer-substring-no-properties", Fbuffer_substring_no_properties,
|
|
9218 Sbuffer_substring_no_properties, 2, 2, 0,
|
|
9219 doc: /* Return the characters of part of the buffer,
|
|
9220 without the text properties.
|
|
9221 The two arguments START and END are character positions;
|
|
9222 they can be in either order. */)
|
|
9223 (start, end)
|
|
9224 Lisp_Object start, end;
|
|
9225 @{
|
|
9226 register int b, e;
|
|
9227
|
|
9228 validate_region (&start, &end);
|
|
9229 b = XINT (start);
|
|
9230 e = XINT (end);
|
|
9231
|
|
9232 return make_buffer_string (b, e, 0);
|
|
9233 @}
|
|
9234 @end group
|
|
9235 @end smallexample
|
|
9236
|
|
9237 Without going into the details of the macro writing process, let me
|
|
9238 point out that this macro starts with the word @code{DEFUN}. The word
|
|
9239 @code{DEFUN} was chosen since the code serves the same purpose as
|
|
9240 @code{defun} does in Lisp. (The @code{DEFUN} C macro is defined in
|
|
9241 @file{emacs/src/lisp.h}.)
|
|
9242
|
|
9243 The word @code{DEFUN} is followed by seven parts inside of
|
|
9244 parentheses:
|
|
9245
|
|
9246 @itemize @bullet
|
|
9247 @item
|
|
9248 The first part is the name given to the function in Lisp,
|
|
9249 @code{delete-and-extract-region}.
|
|
9250
|
|
9251 @item
|
|
9252 The second part is the name of the function in C,
|
|
9253 @code{Fdelete_and_extract_region}. By convention, it starts with
|
|
9254 @samp{F}. Since C does not use hyphens in names, underscores are used
|
|
9255 instead.
|
|
9256
|
|
9257 @item
|
|
9258 The third part is the name for the C constant structure that records
|
|
9259 information on this function for internal use. It is the name of the
|
|
9260 function in C but begins with an @samp{S} instead of an @samp{F}.
|
|
9261
|
|
9262 @item
|
|
9263 The fourth and fifth parts specify the minimum and maximum number of
|
|
9264 arguments the function can have. This function demands exactly 2
|
|
9265 arguments.
|
|
9266
|
|
9267 @item
|
|
9268 The sixth part is nearly like the argument that follows the
|
|
9269 @code{interactive} declaration in a function written in Lisp: a letter
|
|
9270 followed, perhaps, by a prompt. The only difference from the Lisp is
|
|
9271 when the macro is called with no arguments. Then you write a @code{0}
|
|
9272 (which is a `null string'), as in this macro.
|
|
9273
|
|
9274 If you were to specify arguments, you would place them between
|
|
9275 quotation marks. The C macro for @code{goto-char} includes
|
|
9276 @code{"NGoto char: "} in this position to indicate that the function
|
|
9277 expects a raw prefix, in this case, a numerical location in a buffer,
|
|
9278 and provides a prompt.
|
|
9279
|
|
9280 @item
|
|
9281 The seventh part is a documentation string, just like the one for a
|
|
9282 function written in Emacs Lisp, except that every newline must be
|
|
9283 written explicitly as @samp{\n} followed by a backslash and carriage
|
|
9284 return.
|
|
9285
|
|
9286 @need 1000
|
|
9287 Thus, the first two lines of documentation for @code{goto-char} are
|
|
9288 written like this:
|
|
9289
|
|
9290 @smallexample
|
|
9291 @group
|
|
9292 "Set point to POSITION, a number or marker.\n\
|
|
9293 Beginning of buffer is position (point-min), end is (point-max)."
|
|
9294 @end group
|
|
9295 @end smallexample
|
|
9296 @end itemize
|
|
9297
|
|
9298 @need 1200
|
|
9299 In a C macro, the formal parameters come next, with a statement of
|
|
9300 what kind of object they are, followed by what might be called the `body'
|
|
9301 of the macro. For @code{delete-and-extract-region} the `body'
|
|
9302 consists of the following four lines:
|
|
9303
|
|
9304 @smallexample
|
|
9305 @group
|
|
9306 validate_region (&start, &end);
|
|
9307 if (XINT (start) == XINT (end))
|
|
9308 return build_string ("");
|
|
9309 return del_range_1 (XINT (start), XINT (end), 1, 1);
|
|
9310 @end group
|
|
9311 @end smallexample
|
|
9312
|
|
9313 The @code{validate_region} function checks whether the values
|
|
9314 passed as the beginning and end of the region are the proper type and
|
|
9315 are within range. If the beginning and end positions are the same,
|
|
9316 then return and empty string.
|
|
9317
|
|
9318 The @code{del_range_1} function actually deletes the text. It is a
|
|
9319 complex function we will not look into. It updates the buffer and
|
|
9320 does other things. However, it is worth looking at the two arguments
|
|
9321 passed to @code{del_range}. These are @w{@code{XINT (start)}} and
|
|
9322 @w{@code{XINT (end)}}.
|
|
9323
|
|
9324 As far as the C language is concerned, @code{start} and @code{end} are
|
|
9325 two integers that mark the beginning and end of the region to be
|
|
9326 deleted@footnote{More precisely, and requiring more expert knowledge
|
|
9327 to understand, the two integers are of type `Lisp_Object', which can
|
|
9328 also be a C union instead of an integer type.}.
|
|
9329
|
|
9330 In early versions of Emacs, these two numbers were thirty-two bits
|
|
9331 long, but the code is slowly being generalized to handle other
|
|
9332 lengths. Three of the available bits are used to specify the type of
|
|
9333 information; the remaining bits are used as `content'.
|
|
9334
|
|
9335 @samp{XINT} is a C macro that extracts the relevant number from the
|
|
9336 longer collection of bits; the three other bits are discarded.
|
|
9337
|
|
9338 @need 800
|
|
9339 The command in @code{delete-and-extract-region} looks like this:
|
|
9340
|
|
9341 @smallexample
|
|
9342 del_range_1 (XINT (start), XINT (end), 1, 1);
|
|
9343 @end smallexample
|
|
9344
|
|
9345 @noindent
|
|
9346 It deletes the region between the beginning position, @code{start},
|
|
9347 and the ending position, @code{end}.
|
|
9348
|
|
9349 From the point of view of the person writing Lisp, Emacs is all very
|
|
9350 simple; but hidden underneath is a great deal of complexity to make it
|
|
9351 all work.
|
|
9352
|
|
9353 @node defvar, cons & search-fwd Review, Digression into C, Cutting & Storing Text
|
|
9354 @comment node-name, next, previous, up
|
|
9355 @section Initializing a Variable with @code{defvar}
|
|
9356 @findex defvar
|
|
9357 @cindex Initializing a variable
|
|
9358 @cindex Variable initialization
|
|
9359
|
|
9360 @ignore
|
|
9361 2006 Oct 24
|
|
9362 In Emacs 22,
|
|
9363 copy-region-as-kill is short, 12 lines, and uses
|
|
9364 filter-buffer-substring, which is longer, 39 lines
|
|
9365 and has delete-and-extract-region in it.
|
|
9366 delete-and-extract-region is written in C.
|
|
9367
|
|
9368 see Initializing a Variable with @code{defvar}
|
|
9369
|
|
9370 @end ignore
|
|
9371
|
|
9372 The @code{copy-region-as-kill} function is written in Emacs Lisp. Two
|
|
9373 functions within it, @code{kill-append} and @code{kill-new}, copy a
|
|
9374 region in a buffer and save it in a variable called the
|
|
9375 @code{kill-ring}. This section describes how the @code{kill-ring}
|
|
9376 variable is created and initialized using the @code{defvar} special
|
|
9377 form.
|
|
9378
|
|
9379 (Again we note that the term @code{kill-ring} is a misnomer. The text
|
|
9380 that is clipped out of the buffer can be brought back; it is not a ring
|
|
9381 of corpses, but a ring of resurrectable text.)
|
|
9382
|
|
9383 In Emacs Lisp, a variable such as the @code{kill-ring} is created and
|
|
9384 given an initial value by using the @code{defvar} special form. The
|
|
9385 name comes from ``define variable''.
|
|
9386
|
|
9387 The @code{defvar} special form is similar to @code{setq} in that it sets
|
|
9388 the value of a variable. It is unlike @code{setq} in two ways: first,
|
|
9389 it only sets the value of the variable if the variable does not already
|
|
9390 have a value. If the variable already has a value, @code{defvar} does
|
|
9391 not override the existing value. Second, @code{defvar} has a
|
|
9392 documentation string.
|
|
9393
|
|
9394 (Another special form, @code{defcustom}, is designed for variables
|
|
9395 that people customize. It has more features than @code{defvar}.
|
|
9396 (@xref{defcustom, , Setting Variables with @code{defcustom}}.)
|
|
9397
|
|
9398 @menu
|
|
9399 * See variable current value::
|
|
9400 * defvar and asterisk::
|
|
9401 @end menu
|
|
9402
|
|
9403 @node See variable current value, defvar and asterisk, defvar, defvar
|
|
9404 @ifnottex
|
|
9405 @unnumberedsubsec Seeing the Current Value of a Variable
|
|
9406 @end ifnottex
|
|
9407
|
|
9408 You can see the current value of a variable, any variable, by using
|
|
9409 the @code{describe-variable} function, which is usually invoked by
|
|
9410 typing @kbd{C-h v}. If you type @kbd{C-h v} and then @code{kill-ring}
|
|
9411 (followed by @key{RET}) when prompted, you will see what is in your
|
|
9412 current kill ring---this may be quite a lot! Conversely, if you have
|
|
9413 been doing nothing this Emacs session except read this document, you
|
|
9414 may have nothing in it. Also, you will see the documentation for
|
|
9415 @code{kill-ring}:
|
|
9416
|
|
9417 @smallexample
|
|
9418 @group
|
|
9419 Documentation:
|
|
9420 List of killed text sequences.
|
|
9421 Since the kill ring is supposed to interact nicely with cut-and-paste
|
|
9422 facilities offered by window systems, use of this variable should
|
|
9423 @end group
|
|
9424 @group
|
|
9425 interact nicely with `interprogram-cut-function' and
|
|
9426 `interprogram-paste-function'. The functions `kill-new',
|
|
9427 `kill-append', and `current-kill' are supposed to implement this
|
|
9428 interaction; you may want to use them instead of manipulating the kill
|
|
9429 ring directly.
|
|
9430 @end group
|
|
9431 @end smallexample
|
|
9432
|
|
9433 @need 800
|
|
9434 The kill ring is defined by a @code{defvar} in the following way:
|
|
9435
|
|
9436 @smallexample
|
|
9437 @group
|
|
9438 (defvar kill-ring nil
|
|
9439 "List of killed text sequences.
|
|
9440 @dots{}")
|
|
9441 @end group
|
|
9442 @end smallexample
|
|
9443
|
|
9444 @noindent
|
|
9445 In this variable definition, the variable is given an initial value of
|
|
9446 @code{nil}, which makes sense, since if you have saved nothing, you want
|
|
9447 nothing back if you give a @code{yank} command. The documentation
|
|
9448 string is written just like the documentation string of a @code{defun}.
|
|
9449 As with the documentation string of the @code{defun}, the first line of
|
|
9450 the documentation should be a complete sentence, since some commands,
|
|
9451 like @code{apropos}, print only the first line of documentation.
|
|
9452 Succeeding lines should not be indented; otherwise they look odd when
|
|
9453 you use @kbd{C-h v} (@code{describe-variable}).
|
|
9454
|
|
9455 @node defvar and asterisk, , See variable current value, defvar
|
|
9456 @subsection @code{defvar} and an asterisk
|
|
9457 @findex defvar @r{for a user customizable variable}
|
|
9458 @findex defvar @r{with an asterisk}
|
|
9459
|
|
9460 In the past, Emacs used the @code{defvar} special form both for
|
|
9461 internal variables that you would not expect a user to change and for
|
|
9462 variables that you do expect a user to change. Although you can still
|
|
9463 use @code{defvar} for user customizable variables, please use
|
|
9464 @code{defcustom} instead, since that special form provides a path into
|
|
9465 the Customization commands. (@xref{defcustom, , Specifying Variables
|
|
9466 using @code{defcustom}}.)
|
|
9467
|
|
9468 When you specified a variable using the @code{defvar} special form,
|
103732
|
9469 you could distinguish a variable that a user might want to change from
|
|
9470 others by typing an asterisk, @samp{*}, in the first column of its
|
|
9471 documentation string. For example:
|
83955
|
9472
|
|
9473 @smallexample
|
|
9474 @group
|
|
9475 (defvar shell-command-default-error-buffer nil
|
|
9476 "*Buffer name for `shell-command' @dots{} error output.
|
|
9477 @dots{} ")
|
|
9478 @end group
|
|
9479 @end smallexample
|
|
9480
|
|
9481 @findex set-variable
|
|
9482 @noindent
|
|
9483 You could (and still can) use the @code{set-variable} command to
|
|
9484 change the value of @code{shell-command-default-error-buffer}
|
|
9485 temporarily. However, options set using @code{set-variable} are set
|
|
9486 only for the duration of your editing session. The new values are not
|
|
9487 saved between sessions. Each time Emacs starts, it reads the original
|
|
9488 value, unless you change the value within your @file{.emacs} file,
|
|
9489 either by setting it manually or by using @code{customize}.
|
|
9490 @xref{Emacs Initialization, , Your @file{.emacs} File}.
|
|
9491
|
|
9492 For me, the major use of the @code{set-variable} command is to suggest
|
|
9493 variables that I might want to set in my @file{.emacs} file. There
|
|
9494 are now more than 700 such variables --- far too many to remember
|
|
9495 readily. Fortunately, you can press @key{TAB} after calling the
|
|
9496 @code{M-x set-variable} command to see the list of variables.
|
|
9497 (@xref{Examining, , Examining and Setting Variables, emacs,
|
|
9498 The GNU Emacs Manual}.)
|
|
9499
|
|
9500 @need 1250
|
|
9501 @node cons & search-fwd Review, search Exercises, defvar, Cutting & Storing Text
|
|
9502 @comment node-name, next, previous, up
|
|
9503 @section Review
|
|
9504
|
|
9505 Here is a brief summary of some recently introduced functions.
|
|
9506
|
|
9507 @table @code
|
|
9508 @item car
|
|
9509 @itemx cdr
|
|
9510 @code{car} returns the first element of a list; @code{cdr} returns the
|
|
9511 second and subsequent elements of a list.
|
|
9512
|
|
9513 @need 1250
|
|
9514 For example:
|
|
9515
|
|
9516 @smallexample
|
|
9517 @group
|
|
9518 (car '(1 2 3 4 5 6 7))
|
|
9519 @result{} 1
|
|
9520 (cdr '(1 2 3 4 5 6 7))
|
|
9521 @result{} (2 3 4 5 6 7)
|
|
9522 @end group
|
|
9523 @end smallexample
|
|
9524
|
|
9525 @item cons
|
|
9526 @code{cons} constructs a list by prepending its first argument to its
|
|
9527 second argument.
|
|
9528
|
|
9529 @need 1250
|
|
9530 For example:
|
|
9531
|
|
9532 @smallexample
|
|
9533 @group
|
|
9534 (cons 1 '(2 3 4))
|
|
9535 @result{} (1 2 3 4)
|
|
9536 @end group
|
|
9537 @end smallexample
|
|
9538
|
|
9539 @item funcall
|
|
9540 @code{funcall} evaluates its first argument as a function. It passes
|
|
9541 its remaining arguments to its first argument.
|
|
9542
|
|
9543 @item nthcdr
|
|
9544 Return the result of taking @sc{cdr} `n' times on a list.
|
|
9545 @iftex
|
|
9546 The
|
|
9547 @tex
|
|
9548 $n^{th}$
|
|
9549 @end tex
|
|
9550 @code{cdr}.
|
|
9551 @end iftex
|
|
9552 The `rest of the rest', as it were.
|
|
9553
|
|
9554 @need 1250
|
|
9555 For example:
|
|
9556
|
|
9557 @smallexample
|
|
9558 @group
|
|
9559 (nthcdr 3 '(1 2 3 4 5 6 7))
|
|
9560 @result{} (4 5 6 7)
|
|
9561 @end group
|
|
9562 @end smallexample
|
|
9563
|
|
9564 @item setcar
|
|
9565 @itemx setcdr
|
|
9566 @code{setcar} changes the first element of a list; @code{setcdr}
|
|
9567 changes the second and subsequent elements of a list.
|
|
9568
|
|
9569 @need 1250
|
|
9570 For example:
|
|
9571
|
|
9572 @smallexample
|
|
9573 @group
|
|
9574 (setq triple '(1 2 3))
|
|
9575
|
|
9576 (setcar triple '37)
|
|
9577
|
|
9578 triple
|
|
9579 @result{} (37 2 3)
|
|
9580
|
|
9581 (setcdr triple '("foo" "bar"))
|
|
9582
|
|
9583 triple
|
|
9584 @result{} (37 "foo" "bar")
|
|
9585 @end group
|
|
9586 @end smallexample
|
|
9587
|
|
9588 @item progn
|
|
9589 Evaluate each argument in sequence and then return the value of the
|
|
9590 last.
|
|
9591
|
|
9592 @need 1250
|
|
9593 For example:
|
|
9594
|
|
9595 @smallexample
|
|
9596 @group
|
|
9597 (progn 1 2 3 4)
|
|
9598 @result{} 4
|
|
9599 @end group
|
|
9600 @end smallexample
|
|
9601
|
|
9602 @item save-restriction
|
|
9603 Record whatever narrowing is in effect in the current buffer, if any,
|
|
9604 and restore that narrowing after evaluating the arguments.
|
|
9605
|
|
9606 @item search-forward
|
|
9607 Search for a string, and if the string is found, move point. With a
|
|
9608 regular expression, use the similar @code{re-search-forward}.
|
|
9609 (@xref{Regexp Search, , Regular Expression Searches}, for an
|
|
9610 explanation of regular expression patterns and searches.)
|
|
9611
|
|
9612 @need 1250
|
|
9613 @noindent
|
|
9614 @code{search-forward} and @code{re-search-forward} take four
|
|
9615 arguments:
|
|
9616
|
|
9617 @enumerate
|
|
9618 @item
|
|
9619 The string or regular expression to search for.
|
|
9620
|
|
9621 @item
|
|
9622 Optionally, the limit of the search.
|
|
9623
|
|
9624 @item
|
|
9625 Optionally, what to do if the search fails, return @code{nil} or an
|
|
9626 error message.
|
|
9627
|
|
9628 @item
|
|
9629 Optionally, how many times to repeat the search; if negative, the
|
|
9630 search goes backwards.
|
|
9631 @end enumerate
|
|
9632
|
|
9633 @item kill-region
|
|
9634 @itemx delete-and-extract-region
|
|
9635 @itemx copy-region-as-kill
|
|
9636
|
|
9637 @code{kill-region} cuts the text between point and mark from the
|
|
9638 buffer and stores that text in the kill ring, so you can get it back
|
|
9639 by yanking.
|
|
9640
|
|
9641 @code{copy-region-as-kill} copies the text between point and mark into
|
|
9642 the kill ring, from which you can get it by yanking. The function
|
|
9643 does not cut or remove the text from the buffer.
|
|
9644 @end table
|
|
9645
|
|
9646 @code{delete-and-extract-region} removes the text between point and
|
|
9647 mark from the buffer and throws it away. You cannot get it back.
|
|
9648 (This is not an interactive command.)
|
|
9649
|
|
9650 @need 1500
|
|
9651 @node search Exercises, , cons & search-fwd Review, Cutting & Storing Text
|
|
9652 @section Searching Exercises
|
|
9653
|
|
9654 @itemize @bullet
|
|
9655 @item
|
|
9656 Write an interactive function that searches for a string. If the
|
|
9657 search finds the string, leave point after it and display a message
|
|
9658 that says ``Found!''. (Do not use @code{search-forward} for the name
|
|
9659 of this function; if you do, you will overwrite the existing version of
|
|
9660 @code{search-forward} that comes with Emacs. Use a name such as
|
|
9661 @code{test-search} instead.)
|
|
9662
|
|
9663 @item
|
|
9664 Write a function that prints the third element of the kill ring in the
|
|
9665 echo area, if any; if the kill ring does not contain a third element,
|
|
9666 print an appropriate message.
|
|
9667 @end itemize
|
|
9668
|
|
9669 @node List Implementation, Yanking, Cutting & Storing Text, Top
|
|
9670 @comment node-name, next, previous, up
|
|
9671 @chapter How Lists are Implemented
|
|
9672 @cindex Lists in a computer
|
|
9673
|
|
9674 In Lisp, atoms are recorded in a straightforward fashion; if the
|
|
9675 implementation is not straightforward in practice, it is, nonetheless,
|
|
9676 straightforward in theory. The atom @samp{rose}, for example, is
|
|
9677 recorded as the four contiguous letters @samp{r}, @samp{o}, @samp{s},
|
|
9678 @samp{e}. A list, on the other hand, is kept differently. The mechanism
|
|
9679 is equally simple, but it takes a moment to get used to the idea. A
|
|
9680 list is kept using a series of pairs of pointers. In the series, the
|
|
9681 first pointer in each pair points to an atom or to another list, and the
|
|
9682 second pointer in each pair points to the next pair, or to the symbol
|
|
9683 @code{nil}, which marks the end of the list.
|
|
9684
|
|
9685 A pointer itself is quite simply the electronic address of what is
|
|
9686 pointed to. Hence, a list is kept as a series of electronic addresses.
|
|
9687
|
|
9688 @menu
|
|
9689 * Lists diagrammed::
|
|
9690 * Symbols as Chest:: Exploring a powerful metaphor.
|
|
9691 * List Exercise::
|
|
9692 @end menu
|
|
9693
|
|
9694 @node Lists diagrammed, Symbols as Chest, List Implementation, List Implementation
|
|
9695 @ifnottex
|
|
9696 @unnumberedsec Lists diagrammed
|
|
9697 @end ifnottex
|
|
9698
|
|
9699 For example, the list @code{(rose violet buttercup)} has three elements,
|
|
9700 @samp{rose}, @samp{violet}, and @samp{buttercup}. In the computer, the
|
|
9701 electronic address of @samp{rose} is recorded in a segment of computer
|
|
9702 memory along with the address that gives the electronic address of where
|
|
9703 the atom @samp{violet} is located; and that address (the one that tells
|
|
9704 where @samp{violet} is located) is kept along with an address that tells
|
|
9705 where the address for the atom @samp{buttercup} is located.
|
|
9706
|
|
9707 @need 1200
|
|
9708 This sounds more complicated than it is and is easier seen in a diagram:
|
|
9709
|
|
9710 @c clear print-postscript-figures
|
|
9711 @c !!! cons-cell-diagram #1
|
|
9712 @ifnottex
|
|
9713 @smallexample
|
|
9714 @group
|
|
9715 ___ ___ ___ ___ ___ ___
|
|
9716 |___|___|--> |___|___|--> |___|___|--> nil
|
|
9717 | | |
|
|
9718 | | |
|
|
9719 --> rose --> violet --> buttercup
|
|
9720 @end group
|
|
9721 @end smallexample
|
|
9722 @end ifnottex
|
|
9723 @ifset print-postscript-figures
|
|
9724 @sp 1
|
|
9725 @tex
|
|
9726 @center @image{cons-1}
|
|
9727 %%%% old method of including an image
|
|
9728 % \input /usr/local/lib/tex/inputs/psfig.tex
|
|
9729 % \centerline{\psfig{figure=/usr/local/lib/emacs/man/cons-1.eps}}
|
|
9730 % \catcode`\@=0 %
|
|
9731 @end tex
|
|
9732 @sp 1
|
|
9733 @end ifset
|
|
9734 @ifclear print-postscript-figures
|
|
9735 @iftex
|
|
9736 @smallexample
|
|
9737 @group
|
|
9738 ___ ___ ___ ___ ___ ___
|
|
9739 |___|___|--> |___|___|--> |___|___|--> nil
|
|
9740 | | |
|
|
9741 | | |
|
|
9742 --> rose --> violet --> buttercup
|
|
9743 @end group
|
|
9744 @end smallexample
|
|
9745 @end iftex
|
|
9746 @end ifclear
|
|
9747
|
|
9748 @noindent
|
|
9749 In the diagram, each box represents a word of computer memory that
|
|
9750 holds a Lisp object, usually in the form of a memory address. The boxes,
|
|
9751 i.e.@: the addresses, are in pairs. Each arrow points to what the address
|
|
9752 is the address of, either an atom or another pair of addresses. The
|
|
9753 first box is the electronic address of @samp{rose} and the arrow points
|
|
9754 to @samp{rose}; the second box is the address of the next pair of boxes,
|
|
9755 the first part of which is the address of @samp{violet} and the second
|
|
9756 part of which is the address of the next pair. The very last box
|
|
9757 points to the symbol @code{nil}, which marks the end of the list.
|
|
9758
|
|
9759 @need 1200
|
|
9760 When a variable is set to a list with a function such as @code{setq},
|
|
9761 it stores the address of the first box in the variable. Thus,
|
|
9762 evaluation of the expression
|
|
9763
|
|
9764 @smallexample
|
|
9765 (setq bouquet '(rose violet buttercup))
|
|
9766 @end smallexample
|
|
9767
|
|
9768 @need 1250
|
|
9769 @noindent
|
|
9770 creates a situation like this:
|
|
9771
|
|
9772 @c cons-cell-diagram #2
|
|
9773 @ifnottex
|
|
9774 @smallexample
|
|
9775 @group
|
|
9776 bouquet
|
|
9777 |
|
|
9778 | ___ ___ ___ ___ ___ ___
|
|
9779 --> |___|___|--> |___|___|--> |___|___|--> nil
|
|
9780 | | |
|
|
9781 | | |
|
|
9782 --> rose --> violet --> buttercup
|
|
9783 @end group
|
|
9784 @end smallexample
|
|
9785 @end ifnottex
|
|
9786 @ifset print-postscript-figures
|
|
9787 @sp 1
|
|
9788 @tex
|
|
9789 @center @image{cons-2}
|
|
9790 %%%% old method of including an image
|
|
9791 % \input /usr/local/lib/tex/inputs/psfig.tex
|
|
9792 % \centerline{\psfig{figure=/usr/local/lib/emacs/man/cons-2.eps}}
|
|
9793 % \catcode`\@=0 %
|
|
9794 @end tex
|
|
9795 @sp 1
|
|
9796 @end ifset
|
|
9797 @ifclear print-postscript-figures
|
|
9798 @iftex
|
|
9799 @smallexample
|
|
9800 @group
|
|
9801 bouquet
|
|
9802 |
|
|
9803 | ___ ___ ___ ___ ___ ___
|
|
9804 --> |___|___|--> |___|___|--> |___|___|--> nil
|
|
9805 | | |
|
|
9806 | | |
|
|
9807 --> rose --> violet --> buttercup
|
|
9808 @end group
|
|
9809 @end smallexample
|
|
9810 @end iftex
|
|
9811 @end ifclear
|
|
9812
|
|
9813 @noindent
|
|
9814 In this example, the symbol @code{bouquet} holds the address of the first
|
|
9815 pair of boxes.
|
|
9816
|
|
9817 @need 1200
|
|
9818 This same list can be illustrated in a different sort of box notation
|
|
9819 like this:
|
|
9820
|
|
9821 @c cons-cell-diagram #2a
|
|
9822 @ifnottex
|
|
9823 @smallexample
|
|
9824 @group
|
|
9825 bouquet
|
|
9826 |
|
|
9827 | -------------- --------------- ----------------
|
|
9828 | | car | cdr | | car | cdr | | car | cdr |
|
|
9829 -->| rose | o------->| violet | o------->| butter- | nil |
|
|
9830 | | | | | | | cup | |
|
|
9831 -------------- --------------- ----------------
|
|
9832 @end group
|
|
9833 @end smallexample
|
|
9834 @end ifnottex
|
|
9835 @ifset print-postscript-figures
|
|
9836 @sp 1
|
|
9837 @tex
|
|
9838 @center @image{cons-2a}
|
|
9839 %%%% old method of including an image
|
|
9840 % \input /usr/local/lib/tex/inputs/psfig.tex
|
|
9841 % \centerline{\psfig{figure=/usr/local/lib/emacs/man/cons-2a.eps}}
|
|
9842 % \catcode`\@=0 %
|
|
9843 @end tex
|
|
9844 @sp 1
|
|
9845 @end ifset
|
|
9846 @ifclear print-postscript-figures
|
|
9847 @iftex
|
|
9848 @smallexample
|
|
9849 @group
|
|
9850 bouquet
|
|
9851 |
|
|
9852 | -------------- --------------- ----------------
|
|
9853 | | car | cdr | | car | cdr | | car | cdr |
|
|
9854 -->| rose | o------->| violet | o------->| butter- | nil |
|
|
9855 | | | | | | | cup | |
|
|
9856 -------------- --------------- ----------------
|
|
9857 @end group
|
|
9858 @end smallexample
|
|
9859 @end iftex
|
|
9860 @end ifclear
|
|
9861
|
|
9862 (Symbols consist of more than pairs of addresses, but the structure of
|
|
9863 a symbol is made up of addresses. Indeed, the symbol @code{bouquet}
|
|
9864 consists of a group of address-boxes, one of which is the address of
|
|
9865 the printed word @samp{bouquet}, a second of which is the address of a
|
|
9866 function definition attached to the symbol, if any, a third of which
|
|
9867 is the address of the first pair of address-boxes for the list
|
|
9868 @code{(rose violet buttercup)}, and so on. Here we are showing that
|
|
9869 the symbol's third address-box points to the first pair of
|
|
9870 address-boxes for the list.)
|
|
9871
|
|
9872 If a symbol is set to the @sc{cdr} of a list, the list itself is not
|
|
9873 changed; the symbol simply has an address further down the list. (In
|
|
9874 the jargon, @sc{car} and @sc{cdr} are `non-destructive'.) Thus,
|
|
9875 evaluation of the following expression
|
|
9876
|
|
9877 @smallexample
|
|
9878 (setq flowers (cdr bouquet))
|
|
9879 @end smallexample
|
|
9880
|
|
9881 @need 800
|
|
9882 @noindent
|
|
9883 produces this:
|
|
9884
|
|
9885 @c cons-cell-diagram #3
|
|
9886 @ifnottex
|
|
9887 @sp 1
|
|
9888 @smallexample
|
|
9889 @group
|
|
9890 bouquet flowers
|
|
9891 | |
|
|
9892 | ___ ___ | ___ ___ ___ ___
|
|
9893 --> | | | --> | | | | | |
|
|
9894 |___|___|----> |___|___|--> |___|___|--> nil
|
|
9895 | | |
|
|
9896 | | |
|
|
9897 --> rose --> violet --> buttercup
|
|
9898 @end group
|
|
9899 @end smallexample
|
|
9900 @sp 1
|
|
9901 @end ifnottex
|
|
9902 @ifset print-postscript-figures
|
|
9903 @sp 1
|
|
9904 @tex
|
|
9905 @center @image{cons-3}
|
|
9906 %%%% old method of including an image
|
|
9907 % \input /usr/local/lib/tex/inputs/psfig.tex
|
|
9908 % \centerline{\psfig{figure=/usr/local/lib/emacs/man/cons-3.eps}}
|
|
9909 % \catcode`\@=0 %
|
|
9910 @end tex
|
|
9911 @sp 1
|
|
9912 @end ifset
|
|
9913 @ifclear print-postscript-figures
|
|
9914 @iftex
|
|
9915 @sp 1
|
|
9916 @smallexample
|
|
9917 @group
|
|
9918 bouquet flowers
|
|
9919 | |
|
|
9920 | ___ ___ | ___ ___ ___ ___
|
|
9921 --> | | | --> | | | | | |
|
|
9922 |___|___|----> |___|___|--> |___|___|--> nil
|
|
9923 | | |
|
|
9924 | | |
|
|
9925 --> rose --> violet --> buttercup
|
|
9926 @end group
|
|
9927 @end smallexample
|
|
9928 @sp 1
|
|
9929 @end iftex
|
|
9930 @end ifclear
|
|
9931
|
|
9932 @noindent
|
|
9933 The value of @code{flowers} is @code{(violet buttercup)}, which is
|
|
9934 to say, the symbol @code{flowers} holds the address of the pair of
|
|
9935 address-boxes, the first of which holds the address of @code{violet},
|
|
9936 and the second of which holds the address of @code{buttercup}.
|
|
9937
|
|
9938 A pair of address-boxes is called a @dfn{cons cell} or @dfn{dotted
|
|
9939 pair}. @xref{Cons Cell Type, , Cons Cell and List Types, elisp, The GNU Emacs Lisp
|
|
9940 Reference Manual}, and @ref{Dotted Pair Notation, , Dotted Pair
|
|
9941 Notation, elisp, The GNU Emacs Lisp Reference Manual}, for more
|
|
9942 information about cons cells and dotted pairs.
|
|
9943
|
|
9944 @need 1200
|
|
9945 The function @code{cons} adds a new pair of addresses to the front of
|
|
9946 a series of addresses like that shown above. For example, evaluating
|
|
9947 the expression
|
|
9948
|
|
9949 @smallexample
|
|
9950 (setq bouquet (cons 'lily bouquet))
|
|
9951 @end smallexample
|
|
9952
|
|
9953 @need 1500
|
|
9954 @noindent
|
|
9955 produces:
|
|
9956
|
|
9957 @c cons-cell-diagram #4
|
|
9958 @ifnottex
|
|
9959 @sp 1
|
|
9960 @smallexample
|
|
9961 @group
|
|
9962 bouquet flowers
|
|
9963 | |
|
|
9964 | ___ ___ ___ ___ | ___ ___ ___ ___
|
|
9965 --> | | | | | | --> | | | | | |
|
|
9966 |___|___|----> |___|___|----> |___|___|---->|___|___|--> nil
|
|
9967 | | | |
|
|
9968 | | | |
|
|
9969 --> lily --> rose --> violet --> buttercup
|
|
9970 @end group
|
|
9971 @end smallexample
|
|
9972 @sp 1
|
|
9973 @end ifnottex
|
|
9974 @ifset print-postscript-figures
|
|
9975 @sp 1
|
|
9976 @tex
|
|
9977 @center @image{cons-4}
|
|
9978 %%%% old method of including an image
|
|
9979 % \input /usr/local/lib/tex/inputs/psfig.tex
|
|
9980 % \centerline{\psfig{figure=/usr/local/lib/emacs/man/cons-4.eps}}
|
|
9981 % \catcode`\@=0 %
|
|
9982 @end tex
|
|
9983 @sp 1
|
|
9984 @end ifset
|
|
9985 @ifclear print-postscript-figures
|
|
9986 @iftex
|
|
9987 @sp 1
|
|
9988 @smallexample
|
|
9989 @group
|
|
9990 bouquet flowers
|
|
9991 | |
|
|
9992 | ___ ___ ___ ___ | ___ ___ ___ ___
|
|
9993 --> | | | | | | --> | | | | | |
|
|
9994 |___|___|----> |___|___|----> |___|___|---->|___|___|--> nil
|
|
9995 | | | |
|
|
9996 | | | |
|
|
9997 --> lily --> rose --> violet --> buttercup
|
|
9998 @end group
|
|
9999 @end smallexample
|
|
10000 @sp 1
|
|
10001 @end iftex
|
|
10002 @end ifclear
|
|
10003
|
|
10004 @need 1200
|
|
10005 @noindent
|
|
10006 However, this does not change the value of the symbol
|
|
10007 @code{flowers}, as you can see by evaluating the following,
|
|
10008
|
|
10009 @smallexample
|
|
10010 (eq (cdr (cdr bouquet)) flowers)
|
|
10011 @end smallexample
|
|
10012
|
|
10013 @noindent
|
|
10014 which returns @code{t} for true.
|
|
10015
|
|
10016 Until it is reset, @code{flowers} still has the value
|
|
10017 @code{(violet buttercup)}; that is, it has the address of the cons
|
|
10018 cell whose first address is of @code{violet}. Also, this does not
|
|
10019 alter any of the pre-existing cons cells; they are all still there.
|
|
10020
|
|
10021 Thus, in Lisp, to get the @sc{cdr} of a list, you just get the address
|
|
10022 of the next cons cell in the series; to get the @sc{car} of a list,
|
|
10023 you get the address of the first element of the list; to @code{cons} a
|
|
10024 new element on a list, you add a new cons cell to the front of the list.
|
|
10025 That is all there is to it! The underlying structure of Lisp is
|
|
10026 brilliantly simple!
|
|
10027
|
|
10028 And what does the last address in a series of cons cells refer to? It
|
|
10029 is the address of the empty list, of @code{nil}.
|
|
10030
|
|
10031 In summary, when a Lisp variable is set to a value, it is provided with
|
|
10032 the address of the list to which the variable refers.
|
|
10033
|
|
10034 @node Symbols as Chest, List Exercise, Lists diagrammed, List Implementation
|
|
10035 @section Symbols as a Chest of Drawers
|
|
10036 @cindex Symbols as a Chest of Drawers
|
|
10037 @cindex Chest of Drawers, metaphor for a symbol
|
|
10038 @cindex Drawers, Chest of, metaphor for a symbol
|
|
10039
|
|
10040 In an earlier section, I suggested that you might imagine a symbol as
|
|
10041 being a chest of drawers. The function definition is put in one
|
|
10042 drawer, the value in another, and so on. What is put in the drawer
|
|
10043 holding the value can be changed without affecting the contents of the
|
|
10044 drawer holding the function definition, and vice-verse.
|
|
10045
|
|
10046 Actually, what is put in each drawer is the address of the value or
|
|
10047 function definition. It is as if you found an old chest in the attic,
|
|
10048 and in one of its drawers you found a map giving you directions to
|
|
10049 where the buried treasure lies.
|
|
10050
|
|
10051 (In addition to its name, symbol definition, and variable value, a
|
|
10052 symbol has a `drawer' for a @dfn{property list} which can be used to
|
|
10053 record other information. Property lists are not discussed here; see
|
|
10054 @ref{Property Lists, , Property Lists, elisp, The GNU Emacs Lisp
|
|
10055 Reference Manual}.)
|
|
10056
|
|
10057 @need 1500
|
|
10058 Here is a fanciful representation:
|
|
10059
|
|
10060 @c chest-of-drawers diagram
|
|
10061 @ifnottex
|
|
10062 @sp 1
|
|
10063 @smallexample
|
|
10064 @group
|
|
10065 Chest of Drawers Contents of Drawers
|
|
10066
|
|
10067 __ o0O0o __
|
|
10068 / \
|
|
10069 ---------------------
|
|
10070 | directions to | [map to]
|
|
10071 | symbol name | bouquet
|
|
10072 | |
|
|
10073 +---------------------+
|
|
10074 | directions to |
|
|
10075 | symbol definition | [none]
|
|
10076 | |
|
|
10077 +---------------------+
|
|
10078 | directions to | [map to]
|
|
10079 | variable value | (rose violet buttercup)
|
|
10080 | |
|
|
10081 +---------------------+
|
|
10082 | directions to |
|
|
10083 | property list | [not described here]
|
|
10084 | |
|
|
10085 +---------------------+
|
|
10086 |/ \|
|
|
10087 @end group
|
|
10088 @end smallexample
|
|
10089 @sp 1
|
|
10090 @end ifnottex
|
|
10091 @ifset print-postscript-figures
|
|
10092 @sp 1
|
|
10093 @tex
|
|
10094 @center @image{drawers}
|
|
10095 %%%% old method of including an image
|
|
10096 % \input /usr/local/lib/tex/inputs/psfig.tex
|
|
10097 % \centerline{\psfig{figure=/usr/local/lib/emacs/man/drawers.eps}}
|
|
10098 % \catcode`\@=0 %
|
|
10099 @end tex
|
|
10100 @sp 1
|
|
10101 @end ifset
|
|
10102 @ifclear print-postscript-figures
|
|
10103 @iftex
|
|
10104 @sp 1
|
|
10105 @smallexample
|
|
10106 @group
|
|
10107 Chest of Drawers Contents of Drawers
|
|
10108
|
|
10109 __ o0O0o __
|
|
10110 / \
|
|
10111 ---------------------
|
|
10112 | directions to | [map to]
|
|
10113 | symbol name | bouquet
|
|
10114 | |
|
|
10115 +---------------------+
|
|
10116 | directions to |
|
|
10117 | symbol definition | [none]
|
|
10118 | |
|
|
10119 +---------------------+
|
|
10120 | directions to | [map to]
|
|
10121 | variable value | (rose violet buttercup)
|
|
10122 | |
|
|
10123 +---------------------+
|
|
10124 | directions to |
|
|
10125 | property list | [not described here]
|
|
10126 | |
|
|
10127 +---------------------+
|
|
10128 |/ \|
|
|
10129 @end group
|
|
10130 @end smallexample
|
|
10131 @sp 1
|
|
10132 @end iftex
|
|
10133 @end ifclear
|
|
10134
|
|
10135 @node List Exercise, , Symbols as Chest, List Implementation
|
|
10136 @section Exercise
|
|
10137
|
|
10138 Set @code{flowers} to @code{violet} and @code{buttercup}. Cons two
|
|
10139 more flowers on to this list and set this new list to
|
|
10140 @code{more-flowers}. Set the @sc{car} of @code{flowers} to a fish.
|
|
10141 What does the @code{more-flowers} list now contain?
|
|
10142
|
|
10143 @node Yanking, Loops & Recursion, List Implementation, Top
|
|
10144 @comment node-name, next, previous, up
|
|
10145 @chapter Yanking Text Back
|
|
10146 @findex yank
|
|
10147 @cindex Text retrieval
|
|
10148 @cindex Retrieving text
|
|
10149 @cindex Pasting text
|
|
10150
|
|
10151 Whenever you cut text out of a buffer with a `kill' command in GNU Emacs,
|
|
10152 you can bring it back with a `yank' command. The text that is cut out of
|
|
10153 the buffer is put in the kill ring and the yank commands insert the
|
|
10154 appropriate contents of the kill ring back into a buffer (not necessarily
|
|
10155 the original buffer).
|
|
10156
|
|
10157 A simple @kbd{C-y} (@code{yank}) command inserts the first item from
|
|
10158 the kill ring into the current buffer. If the @kbd{C-y} command is
|
|
10159 followed immediately by @kbd{M-y}, the first element is replaced by
|
|
10160 the second element. Successive @kbd{M-y} commands replace the second
|
|
10161 element with the third, fourth, or fifth element, and so on. When the
|
|
10162 last element in the kill ring is reached, it is replaced by the first
|
|
10163 element and the cycle is repeated. (Thus the kill ring is called a
|
|
10164 `ring' rather than just a `list'. However, the actual data structure
|
|
10165 that holds the text is a list.
|
|
10166 @xref{Kill Ring, , Handling the Kill Ring}, for the details of how the
|
|
10167 list is handled as a ring.)
|
|
10168
|
|
10169 @menu
|
|
10170 * Kill Ring Overview::
|
|
10171 * kill-ring-yank-pointer:: The kill ring is a list.
|
|
10172 * yank nthcdr Exercises:: The @code{kill-ring-yank-pointer} variable.
|
|
10173 @end menu
|
|
10174
|
|
10175 @node Kill Ring Overview, kill-ring-yank-pointer, Yanking, Yanking
|
|
10176 @comment node-name, next, previous, up
|
|
10177 @section Kill Ring Overview
|
|
10178 @cindex Kill ring overview
|
|
10179
|
|
10180 The kill ring is a list of textual strings. This is what it looks like:
|
|
10181
|
|
10182 @smallexample
|
|
10183 ("some text" "a different piece of text" "yet more text")
|
|
10184 @end smallexample
|
|
10185
|
|
10186 If this were the contents of my kill ring and I pressed @kbd{C-y}, the
|
|
10187 string of characters saying @samp{some text} would be inserted in this
|
|
10188 buffer where my cursor is located.
|
|
10189
|
|
10190 The @code{yank} command is also used for duplicating text by copying it.
|
|
10191 The copied text is not cut from the buffer, but a copy of it is put on the
|
|
10192 kill ring and is inserted by yanking it back.
|
|
10193
|
|
10194 Three functions are used for bringing text back from the kill ring:
|
|
10195 @code{yank}, which is usually bound to @kbd{C-y}; @code{yank-pop},
|
|
10196 which is usually bound to @kbd{M-y}; and @code{rotate-yank-pointer},
|
|
10197 which is used by the two other functions.
|
|
10198
|
|
10199 These functions refer to the kill ring through a variable called the
|
|
10200 @code{kill-ring-yank-pointer}. Indeed, the insertion code for both the
|
|
10201 @code{yank} and @code{yank-pop} functions is:
|
|
10202
|
|
10203 @smallexample
|
|
10204 (insert (car kill-ring-yank-pointer))
|
|
10205 @end smallexample
|
|
10206
|
|
10207 @noindent
|
|
10208 (Well, no more. In GNU Emacs 22, the function has been replaced by
|
|
10209 @code{insert-for-yank} which calls @code{insert-for-yank-1}
|
|
10210 repetitively for each @code{yank-handler} segment. In turn,
|
|
10211 @code{insert-for-yank-1} strips text properties from the inserted text
|
|
10212 according to @code{yank-excluded-properties}. Otherwise, it is just
|
|
10213 like @code{insert}. We will stick with plain @code{insert} since it
|
|
10214 is easier to understand.)
|
|
10215
|
|
10216 To begin to understand how @code{yank} and @code{yank-pop} work, it is
|
|
10217 first necessary to look at the @code{kill-ring-yank-pointer} variable.
|
|
10218
|
|
10219 @node kill-ring-yank-pointer, yank nthcdr Exercises, Kill Ring Overview, Yanking
|
|
10220 @comment node-name, next, previous, up
|
|
10221 @section The @code{kill-ring-yank-pointer} Variable
|
|
10222
|
|
10223 @code{kill-ring-yank-pointer} is a variable, just as @code{kill-ring} is
|
|
10224 a variable. It points to something by being bound to the value of what
|
|
10225 it points to, like any other Lisp variable.
|
|
10226
|
|
10227 @need 1000
|
|
10228 Thus, if the value of the kill ring is:
|
|
10229
|
|
10230 @smallexample
|
|
10231 ("some text" "a different piece of text" "yet more text")
|
|
10232 @end smallexample
|
|
10233
|
|
10234 @need 1250
|
|
10235 @noindent
|
|
10236 and the @code{kill-ring-yank-pointer} points to the second clause, the
|
|
10237 value of @code{kill-ring-yank-pointer} is:
|
|
10238
|
|
10239 @smallexample
|
|
10240 ("a different piece of text" "yet more text")
|
|
10241 @end smallexample
|
|
10242
|
|
10243 As explained in the previous chapter (@pxref{List Implementation}), the
|
|
10244 computer does not keep two different copies of the text being pointed to
|
|
10245 by both the @code{kill-ring} and the @code{kill-ring-yank-pointer}. The
|
|
10246 words ``a different piece of text'' and ``yet more text'' are not
|
|
10247 duplicated. Instead, the two Lisp variables point to the same pieces of
|
|
10248 text. Here is a diagram:
|
|
10249
|
|
10250 @c cons-cell-diagram #5
|
|
10251 @ifnottex
|
|
10252 @smallexample
|
|
10253 @group
|
|
10254 kill-ring kill-ring-yank-pointer
|
|
10255 | |
|
|
10256 | ___ ___ | ___ ___ ___ ___
|
|
10257 ---> | | | --> | | | | | |
|
|
10258 |___|___|----> |___|___|--> |___|___|--> nil
|
|
10259 | | |
|
|
10260 | | |
|
|
10261 | | --> "yet more text"
|
|
10262 | |
|
|
10263 | --> "a different piece of text"
|
|
10264 |
|
|
10265 --> "some text"
|
|
10266 @end group
|
|
10267 @end smallexample
|
|
10268 @sp 1
|
|
10269 @end ifnottex
|
|
10270 @ifset print-postscript-figures
|
|
10271 @sp 1
|
|
10272 @tex
|
|
10273 @center @image{cons-5}
|
|
10274 %%%% old method of including an image
|
|
10275 % \input /usr/local/lib/tex/inputs/psfig.tex
|
|
10276 % \centerline{\psfig{figure=/usr/local/lib/emacs/man/cons-5.eps}}
|
|
10277 % \catcode`\@=0 %
|
|
10278 @end tex
|
|
10279 @sp 1
|
|
10280 @end ifset
|
|
10281 @ifclear print-postscript-figures
|
|
10282 @iftex
|
|
10283 @smallexample
|
|
10284 @group
|
|
10285 kill-ring kill-ring-yank-pointer
|
|
10286 | |
|
|
10287 | ___ ___ | ___ ___ ___ ___
|
|
10288 ---> | | | --> | | | | | |
|
|
10289 |___|___|----> |___|___|--> |___|___|--> nil
|
|
10290 | | |
|
|
10291 | | |
|
|
10292 | | --> "yet more text"
|
|
10293 | |
|
|
10294 | --> "a different piece of text
|
|
10295 |
|
|
10296 --> "some text"
|
|
10297 @end group
|
|
10298 @end smallexample
|
|
10299 @sp 1
|
|
10300 @end iftex
|
|
10301 @end ifclear
|
|
10302
|
|
10303 Both the variable @code{kill-ring} and the variable
|
|
10304 @code{kill-ring-yank-pointer} are pointers. But the kill ring itself is
|
|
10305 usually described as if it were actually what it is composed of. The
|
|
10306 @code{kill-ring} is spoken of as if it were the list rather than that it
|
|
10307 points to the list. Conversely, the @code{kill-ring-yank-pointer} is
|
|
10308 spoken of as pointing to a list.
|
|
10309
|
|
10310 These two ways of talking about the same thing sound confusing at first but
|
|
10311 make sense on reflection. The kill ring is generally thought of as the
|
|
10312 complete structure of data that holds the information of what has recently
|
|
10313 been cut out of the Emacs buffers. The @code{kill-ring-yank-pointer}
|
|
10314 on the other hand, serves to indicate---that is, to `point to'---that part
|
|
10315 of the kill ring of which the first element (the @sc{car}) will be
|
|
10316 inserted.
|
|
10317
|
|
10318 @ignore
|
|
10319 In GNU Emacs 22, the @code{kill-new} function calls
|
|
10320
|
|
10321 @code{(setq kill-ring-yank-pointer kill-ring)}
|
|
10322
|
|
10323 (defun rotate-yank-pointer (arg)
|
|
10324 "Rotate the yanking point in the kill ring.
|
|
10325 With argument, rotate that many kills forward (or backward, if negative)."
|
|
10326 (interactive "p")
|
|
10327 (current-kill arg))
|
|
10328
|
|
10329 (defun current-kill (n &optional do-not-move)
|
|
10330 "Rotate the yanking point by N places, and then return that kill.
|
|
10331 If N is zero, `interprogram-paste-function' is set, and calling it
|
|
10332 returns a string, then that string is added to the front of the
|
|
10333 kill ring and returned as the latest kill.
|
|
10334 If optional arg DO-NOT-MOVE is non-nil, then don't actually move the
|
|
10335 yanking point; just return the Nth kill forward."
|
|
10336 (let ((interprogram-paste (and (= n 0)
|
|
10337 interprogram-paste-function
|
|
10338 (funcall interprogram-paste-function))))
|
|
10339 (if interprogram-paste
|
|
10340 (progn
|
|
10341 ;; Disable the interprogram cut function when we add the new
|
|
10342 ;; text to the kill ring, so Emacs doesn't try to own the
|
|
10343 ;; selection, with identical text.
|
|
10344 (let ((interprogram-cut-function nil))
|
|
10345 (kill-new interprogram-paste))
|
|
10346 interprogram-paste)
|
|
10347 (or kill-ring (error "Kill ring is empty"))
|
|
10348 (let ((ARGth-kill-element
|
|
10349 (nthcdr (mod (- n (length kill-ring-yank-pointer))
|
|
10350 (length kill-ring))
|
|
10351 kill-ring)))
|
|
10352 (or do-not-move
|
|
10353 (setq kill-ring-yank-pointer ARGth-kill-element))
|
|
10354 (car ARGth-kill-element)))))
|
|
10355
|
|
10356 @end ignore
|
|
10357
|
|
10358 @need 1500
|
|
10359 @node yank nthcdr Exercises, , kill-ring-yank-pointer, Yanking
|
|
10360 @section Exercises with @code{yank} and @code{nthcdr}
|
|
10361
|
|
10362 @itemize @bullet
|
|
10363 @item
|
|
10364 Using @kbd{C-h v} (@code{describe-variable}), look at the value of
|
|
10365 your kill ring. Add several items to your kill ring; look at its
|
|
10366 value again. Using @kbd{M-y} (@code{yank-pop)}, move all the way
|
|
10367 around the kill ring. How many items were in your kill ring? Find
|
|
10368 the value of @code{kill-ring-max}. Was your kill ring full, or could
|
|
10369 you have kept more blocks of text within it?
|
|
10370
|
|
10371 @item
|
|
10372 Using @code{nthcdr} and @code{car}, construct a series of expressions
|
|
10373 to return the first, second, third, and fourth elements of a list.
|
|
10374 @end itemize
|
|
10375
|
|
10376 @node Loops & Recursion, Regexp Search, Yanking, Top
|
|
10377 @comment node-name, next, previous, up
|
|
10378 @chapter Loops and Recursion
|
|
10379 @cindex Loops and recursion
|
|
10380 @cindex Recursion and loops
|
|
10381 @cindex Repetition (loops)
|
|
10382
|
|
10383 Emacs Lisp has two primary ways to cause an expression, or a series of
|
|
10384 expressions, to be evaluated repeatedly: one uses a @code{while}
|
|
10385 loop, and the other uses @dfn{recursion}.
|
|
10386
|
|
10387 Repetition can be very valuable. For example, to move forward four
|
|
10388 sentences, you need only write a program that will move forward one
|
|
10389 sentence and then repeat the process four times. Since a computer does
|
|
10390 not get bored or tired, such repetitive action does not have the
|
|
10391 deleterious effects that excessive or the wrong kinds of repetition can
|
|
10392 have on humans.
|
|
10393
|
|
10394 People mostly write Emacs Lisp functions using @code{while} loops and
|
|
10395 their kin; but you can use recursion, which provides a very powerful
|
|
10396 way to think about and then to solve problems@footnote{You can write
|
|
10397 recursive functions to be frugal or wasteful of mental or computer
|
|
10398 resources; as it happens, methods that people find easy---that are
|
|
10399 frugal of `mental resources'---sometimes use considerable computer
|
|
10400 resources. Emacs was designed to run on machines that we now consider
|
|
10401 limited and its default settings are conservative. You may want to
|
|
10402 increase the values of @code{max-specpdl-size} and
|
|
10403 @code{max-lisp-eval-depth}. In my @file{.emacs} file, I set them to
|
|
10404 15 and 30 times their default value.}.
|
|
10405
|
|
10406 @menu
|
|
10407 * while:: Causing a stretch of code to repeat.
|
|
10408 * dolist dotimes::
|
|
10409 * Recursion:: Causing a function to call itself.
|
|
10410 * Looping exercise::
|
|
10411 @end menu
|
|
10412
|
|
10413 @node while, dolist dotimes, Loops & Recursion, Loops & Recursion
|
|
10414 @comment node-name, next, previous, up
|
|
10415 @section @code{while}
|
|
10416 @cindex Loops
|
|
10417 @findex while
|
|
10418
|
|
10419 The @code{while} special form tests whether the value returned by
|
|
10420 evaluating its first argument is true or false. This is similar to what
|
|
10421 the Lisp interpreter does with an @code{if}; what the interpreter does
|
|
10422 next, however, is different.
|
|
10423
|
|
10424 In a @code{while} expression, if the value returned by evaluating the
|
|
10425 first argument is false, the Lisp interpreter skips the rest of the
|
|
10426 expression (the @dfn{body} of the expression) and does not evaluate it.
|
|
10427 However, if the value is true, the Lisp interpreter evaluates the body
|
|
10428 of the expression and then again tests whether the first argument to
|
|
10429 @code{while} is true or false. If the value returned by evaluating the
|
|
10430 first argument is again true, the Lisp interpreter again evaluates the
|
|
10431 body of the expression.
|
|
10432
|
|
10433 @need 1200
|
|
10434 The template for a @code{while} expression looks like this:
|
|
10435
|
|
10436 @smallexample
|
|
10437 @group
|
|
10438 (while @var{true-or-false-test}
|
|
10439 @var{body}@dots{})
|
|
10440 @end group
|
|
10441 @end smallexample
|
|
10442
|
|
10443 @menu
|
|
10444 * Looping with while:: Repeat so long as test returns true.
|
|
10445 * Loop Example:: A @code{while} loop that uses a list.
|
|
10446 * print-elements-of-list:: Uses @code{while}, @code{car}, @code{cdr}.
|
|
10447 * Incrementing Loop:: A loop with an incrementing counter.
|
|
10448 * Incrementing Loop Details::
|
|
10449 * Decrementing Loop:: A loop with a decrementing counter.
|
|
10450 @end menu
|
|
10451
|
|
10452 @node Looping with while, Loop Example, while, while
|
|
10453 @ifnottex
|
|
10454 @unnumberedsubsec Looping with @code{while}
|
|
10455 @end ifnottex
|
|
10456
|
|
10457 So long as the true-or-false-test of the @code{while} expression
|
|
10458 returns a true value when it is evaluated, the body is repeatedly
|
|
10459 evaluated. This process is called a loop since the Lisp interpreter
|
|
10460 repeats the same thing again and again, like an airplane doing a loop.
|
|
10461 When the result of evaluating the true-or-false-test is false, the
|
|
10462 Lisp interpreter does not evaluate the rest of the @code{while}
|
|
10463 expression and `exits the loop'.
|
|
10464
|
|
10465 Clearly, if the value returned by evaluating the first argument to
|
|
10466 @code{while} is always true, the body following will be evaluated
|
|
10467 again and again @dots{} and again @dots{} forever. Conversely, if the
|
|
10468 value returned is never true, the expressions in the body will never
|
|
10469 be evaluated. The craft of writing a @code{while} loop consists of
|
|
10470 choosing a mechanism such that the true-or-false-test returns true
|
|
10471 just the number of times that you want the subsequent expressions to
|
|
10472 be evaluated, and then have the test return false.
|
|
10473
|
|
10474 The value returned by evaluating a @code{while} is the value of the
|
|
10475 true-or-false-test. An interesting consequence of this is that a
|
|
10476 @code{while} loop that evaluates without error will return @code{nil}
|
|
10477 or false regardless of whether it has looped 1 or 100 times or none at
|
|
10478 all. A @code{while} expression that evaluates successfully never
|
|
10479 returns a true value! What this means is that @code{while} is always
|
|
10480 evaluated for its side effects, which is to say, the consequences of
|
|
10481 evaluating the expressions within the body of the @code{while} loop.
|
|
10482 This makes sense. It is not the mere act of looping that is desired,
|
|
10483 but the consequences of what happens when the expressions in the loop
|
|
10484 are repeatedly evaluated.
|
|
10485
|
|
10486 @node Loop Example, print-elements-of-list, Looping with while, while
|
|
10487 @comment node-name, next, previous, up
|
|
10488 @subsection A @code{while} Loop and a List
|
|
10489
|
|
10490 A common way to control a @code{while} loop is to test whether a list
|
|
10491 has any elements. If it does, the loop is repeated; but if it does not,
|
|
10492 the repetition is ended. Since this is an important technique, we will
|
|
10493 create a short example to illustrate it.
|
|
10494
|
|
10495 A simple way to test whether a list has elements is to evaluate the
|
|
10496 list: if it has no elements, it is an empty list and will return the
|
|
10497 empty list, @code{()}, which is a synonym for @code{nil} or false. On
|
|
10498 the other hand, a list with elements will return those elements when it
|
|
10499 is evaluated. Since Emacs Lisp considers as true any value that is not
|
|
10500 @code{nil}, a list that returns elements will test true in a
|
|
10501 @code{while} loop.
|
|
10502
|
|
10503 @need 1200
|
|
10504 For example, you can set the variable @code{empty-list} to @code{nil} by
|
|
10505 evaluating the following @code{setq} expression:
|
|
10506
|
|
10507 @smallexample
|
|
10508 (setq empty-list ())
|
|
10509 @end smallexample
|
|
10510
|
|
10511 @noindent
|
|
10512 After evaluating the @code{setq} expression, you can evaluate the
|
|
10513 variable @code{empty-list} in the usual way, by placing the cursor after
|
|
10514 the symbol and typing @kbd{C-x C-e}; @code{nil} will appear in your
|
|
10515 echo area:
|
|
10516
|
|
10517 @smallexample
|
|
10518 empty-list
|
|
10519 @end smallexample
|
|
10520
|
|
10521 On the other hand, if you set a variable to be a list with elements, the
|
|
10522 list will appear when you evaluate the variable, as you can see by
|
|
10523 evaluating the following two expressions:
|
|
10524
|
|
10525 @smallexample
|
|
10526 @group
|
|
10527 (setq animals '(gazelle giraffe lion tiger))
|
|
10528
|
|
10529 animals
|
|
10530 @end group
|
|
10531 @end smallexample
|
|
10532
|
|
10533 Thus, to create a @code{while} loop that tests whether there are any
|
|
10534 items in the list @code{animals}, the first part of the loop will be
|
|
10535 written like this:
|
|
10536
|
|
10537 @smallexample
|
|
10538 @group
|
|
10539 (while animals
|
|
10540 @dots{}
|
|
10541 @end group
|
|
10542 @end smallexample
|
|
10543
|
|
10544 @noindent
|
|
10545 When the @code{while} tests its first argument, the variable
|
|
10546 @code{animals} is evaluated. It returns a list. So long as the list
|
|
10547 has elements, the @code{while} considers the results of the test to be
|
|
10548 true; but when the list is empty, it considers the results of the test
|
|
10549 to be false.
|
|
10550
|
|
10551 To prevent the @code{while} loop from running forever, some mechanism
|
|
10552 needs to be provided to empty the list eventually. An oft-used
|
|
10553 technique is to have one of the subsequent forms in the @code{while}
|
|
10554 expression set the value of the list to be the @sc{cdr} of the list.
|
|
10555 Each time the @code{cdr} function is evaluated, the list will be made
|
|
10556 shorter, until eventually only the empty list will be left. At this
|
|
10557 point, the test of the @code{while} loop will return false, and the
|
|
10558 arguments to the @code{while} will no longer be evaluated.
|
|
10559
|
|
10560 For example, the list of animals bound to the variable @code{animals}
|
|
10561 can be set to be the @sc{cdr} of the original list with the
|
|
10562 following expression:
|
|
10563
|
|
10564 @smallexample
|
|
10565 (setq animals (cdr animals))
|
|
10566 @end smallexample
|
|
10567
|
|
10568 @noindent
|
|
10569 If you have evaluated the previous expressions and then evaluate this
|
|
10570 expression, you will see @code{(giraffe lion tiger)} appear in the echo
|
|
10571 area. If you evaluate the expression again, @code{(lion tiger)} will
|
|
10572 appear in the echo area. If you evaluate it again and yet again,
|
|
10573 @code{(tiger)} appears and then the empty list, shown by @code{nil}.
|
|
10574
|
|
10575 A template for a @code{while} loop that uses the @code{cdr} function
|
|
10576 repeatedly to cause the true-or-false-test eventually to test false
|
|
10577 looks like this:
|
|
10578
|
|
10579 @smallexample
|
|
10580 @group
|
|
10581 (while @var{test-whether-list-is-empty}
|
|
10582 @var{body}@dots{}
|
|
10583 @var{set-list-to-cdr-of-list})
|
|
10584 @end group
|
|
10585 @end smallexample
|
|
10586
|
|
10587 This test and use of @code{cdr} can be put together in a function that
|
|
10588 goes through a list and prints each element of the list on a line of its
|
|
10589 own.
|
|
10590
|
|
10591 @node print-elements-of-list, Incrementing Loop, Loop Example, while
|
|
10592 @subsection An Example: @code{print-elements-of-list}
|
|
10593 @findex print-elements-of-list
|
|
10594
|
|
10595 The @code{print-elements-of-list} function illustrates a @code{while}
|
|
10596 loop with a list.
|
|
10597
|
|
10598 @cindex @file{*scratch*} buffer
|
|
10599 The function requires several lines for its output. If you are
|
|
10600 reading this in a recent instance of GNU Emacs,
|
|
10601 @c GNU Emacs 21, GNU Emacs 22, or a later version,
|
|
10602 you can evaluate the following expression inside of Info, as usual.
|
|
10603
|
|
10604 If you are using an earlier version of Emacs, you need to copy the
|
|
10605 necessary expressions to your @file{*scratch*} buffer and evaluate
|
|
10606 them there. This is because the echo area had only one line in the
|
|
10607 earlier versions.
|
|
10608
|
|
10609 You can copy the expressions by marking the beginning of the region
|
|
10610 with @kbd{C-@key{SPC}} (@code{set-mark-command}), moving the cursor to
|
|
10611 the end of the region and then copying the region using @kbd{M-w}
|
|
10612 (@code{kill-ring-save}, which calls @code{copy-region-as-kill} and
|
|
10613 then provides visual feedback). In the @file{*scratch*}
|
|
10614 buffer, you can yank the expressions back by typing @kbd{C-y}
|
|
10615 (@code{yank}).
|
|
10616
|
|
10617 After you have copied the expressions to the @file{*scratch*} buffer,
|
|
10618 evaluate each expression in turn. Be sure to evaluate the last
|
|
10619 expression, @code{(print-elements-of-list animals)}, by typing
|
|
10620 @kbd{C-u C-x C-e}, that is, by giving an argument to
|
|
10621 @code{eval-last-sexp}. This will cause the result of the evaluation
|
|
10622 to be printed in the @file{*scratch*} buffer instead of being printed
|
|
10623 in the echo area. (Otherwise you will see something like this in your
|
|
10624 echo area: @code{^Jgazelle^J^Jgiraffe^J^Jlion^J^Jtiger^Jnil}, in which
|
|
10625 each @samp{^J} stands for a `newline'.)
|
|
10626
|
|
10627 @need 1500
|
|
10628 In a recent instance of GNU Emacs, you can evaluate these expressions
|
|
10629 directly in the Info buffer, and the echo area will grow to show the
|
|
10630 results.
|
|
10631
|
|
10632 @smallexample
|
|
10633 @group
|
|
10634 (setq animals '(gazelle giraffe lion tiger))
|
|
10635
|
|
10636 (defun print-elements-of-list (list)
|
|
10637 "Print each element of LIST on a line of its own."
|
|
10638 (while list
|
|
10639 (print (car list))
|
|
10640 (setq list (cdr list))))
|
|
10641
|
|
10642 (print-elements-of-list animals)
|
|
10643 @end group
|
|
10644 @end smallexample
|
|
10645
|
|
10646 @need 1200
|
|
10647 @noindent
|
|
10648 When you evaluate the three expressions in sequence, you will see
|
|
10649 this:
|
|
10650
|
|
10651 @smallexample
|
|
10652 @group
|
|
10653 gazelle
|
|
10654
|
|
10655 giraffe
|
|
10656
|
|
10657 lion
|
|
10658
|
|
10659 tiger
|
|
10660 nil
|
|
10661 @end group
|
|
10662 @end smallexample
|
|
10663
|
|
10664 Each element of the list is printed on a line of its own (that is what
|
|
10665 the function @code{print} does) and then the value returned by the
|
|
10666 function is printed. Since the last expression in the function is the
|
|
10667 @code{while} loop, and since @code{while} loops always return
|
|
10668 @code{nil}, a @code{nil} is printed after the last element of the list.
|
|
10669
|
|
10670 @node Incrementing Loop, Incrementing Loop Details, print-elements-of-list, while
|
|
10671 @comment node-name, next, previous, up
|
|
10672 @subsection A Loop with an Incrementing Counter
|
|
10673
|
|
10674 A loop is not useful unless it stops when it ought. Besides
|
|
10675 controlling a loop with a list, a common way of stopping a loop is to
|
|
10676 write the first argument as a test that returns false when the correct
|
|
10677 number of repetitions are complete. This means that the loop must
|
|
10678 have a counter---an expression that counts how many times the loop
|
|
10679 repeats itself.
|
|
10680
|
|
10681 @node Incrementing Loop Details, Decrementing Loop, Incrementing Loop, while
|
|
10682 @ifnottex
|
|
10683 @unnumberedsubsec Details of an Incrementing Loop
|
|
10684 @end ifnottex
|
|
10685
|
|
10686 The test for a loop with an incrementing counter can be an expression
|
|
10687 such as @code{(< count desired-number)} which returns @code{t} for
|
|
10688 true if the value of @code{count} is less than the
|
|
10689 @code{desired-number} of repetitions and @code{nil} for false if the
|
|
10690 value of @code{count} is equal to or is greater than the
|
|
10691 @code{desired-number}. The expression that increments the count can
|
|
10692 be a simple @code{setq} such as @code{(setq count (1+ count))}, where
|
|
10693 @code{1+} is a built-in function in Emacs Lisp that adds 1 to its
|
|
10694 argument. (The expression @w{@code{(1+ count)}} has the same result
|
|
10695 as @w{@code{(+ count 1)}}, but is easier for a human to read.)
|
|
10696
|
|
10697 @need 1250
|
|
10698 The template for a @code{while} loop controlled by an incrementing
|
|
10699 counter looks like this:
|
|
10700
|
|
10701 @smallexample
|
|
10702 @group
|
|
10703 @var{set-count-to-initial-value}
|
|
10704 (while (< count desired-number) ; @r{true-or-false-test}
|
|
10705 @var{body}@dots{}
|
|
10706 (setq count (1+ count))) ; @r{incrementer}
|
|
10707 @end group
|
|
10708 @end smallexample
|
|
10709
|
|
10710 @noindent
|
|
10711 Note that you need to set the initial value of @code{count}; usually it
|
|
10712 is set to 1.
|
|
10713
|
|
10714 @menu
|
|
10715 * Incrementing Example:: Counting pebbles in a triangle.
|
|
10716 * Inc Example parts:: The parts of the function definition.
|
|
10717 * Inc Example altogether:: Putting the function definition together.
|
|
10718 @end menu
|
|
10719
|
|
10720 @node Incrementing Example, Inc Example parts, Incrementing Loop Details, Incrementing Loop Details
|
|
10721 @unnumberedsubsubsec Example with incrementing counter
|
|
10722
|
|
10723 Suppose you are playing on the beach and decide to make a triangle of
|
|
10724 pebbles, putting one pebble in the first row, two in the second row,
|
|
10725 three in the third row and so on, like this:
|
|
10726
|
|
10727 @sp 1
|
|
10728 @c pebble diagram
|
|
10729 @ifnottex
|
|
10730 @smallexample
|
|
10731 @group
|
|
10732 *
|
|
10733 * *
|
|
10734 * * *
|
|
10735 * * * *
|
|
10736 @end group
|
|
10737 @end smallexample
|
|
10738 @end ifnottex
|
|
10739 @iftex
|
|
10740 @smallexample
|
|
10741 @group
|
|
10742 @bullet{}
|
|
10743 @bullet{} @bullet{}
|
|
10744 @bullet{} @bullet{} @bullet{}
|
|
10745 @bullet{} @bullet{} @bullet{} @bullet{}
|
|
10746 @end group
|
|
10747 @end smallexample
|
|
10748 @end iftex
|
|
10749 @sp 1
|
|
10750
|
|
10751 @noindent
|
|
10752 (About 2500 years ago, Pythagoras and others developed the beginnings of
|
|
10753 number theory by considering questions such as this.)
|
|
10754
|
|
10755 Suppose you want to know how many pebbles you will need to make a
|
|
10756 triangle with 7 rows?
|
|
10757
|
|
10758 Clearly, what you need to do is add up the numbers from 1 to 7. There
|
|
10759 are two ways to do this; start with the smallest number, one, and add up
|
|
10760 the list in sequence, 1, 2, 3, 4 and so on; or start with the largest
|
|
10761 number and add the list going down: 7, 6, 5, 4 and so on. Because both
|
|
10762 mechanisms illustrate common ways of writing @code{while} loops, we will
|
|
10763 create two examples, one counting up and the other counting down. In
|
|
10764 this first example, we will start with 1 and add 2, 3, 4 and so on.
|
|
10765
|
|
10766 If you are just adding up a short list of numbers, the easiest way to do
|
|
10767 it is to add up all the numbers at once. However, if you do not know
|
|
10768 ahead of time how many numbers your list will have, or if you want to be
|
|
10769 prepared for a very long list, then you need to design your addition so
|
|
10770 that what you do is repeat a simple process many times instead of doing
|
|
10771 a more complex process once.
|
|
10772
|
|
10773 For example, instead of adding up all the pebbles all at once, what you
|
|
10774 can do is add the number of pebbles in the first row, 1, to the number
|
|
10775 in the second row, 2, and then add the total of those two rows to the
|
|
10776 third row, 3. Then you can add the number in the fourth row, 4, to the
|
|
10777 total of the first three rows; and so on.
|
|
10778
|
|
10779 The critical characteristic of the process is that each repetitive
|
|
10780 action is simple. In this case, at each step we add only two numbers,
|
|
10781 the number of pebbles in the row and the total already found. This
|
|
10782 process of adding two numbers is repeated again and again until the last
|
|
10783 row has been added to the total of all the preceding rows. In a more
|
|
10784 complex loop the repetitive action might not be so simple, but it will
|
|
10785 be simpler than doing everything all at once.
|
|
10786
|
|
10787 @node Inc Example parts, Inc Example altogether, Incrementing Example, Incrementing Loop Details
|
|
10788 @unnumberedsubsubsec The parts of the function definition
|
|
10789
|
|
10790 The preceding analysis gives us the bones of our function definition:
|
|
10791 first, we will need a variable that we can call @code{total} that will
|
|
10792 be the total number of pebbles. This will be the value returned by
|
|
10793 the function.
|
|
10794
|
|
10795 Second, we know that the function will require an argument: this
|
|
10796 argument will be the total number of rows in the triangle. It can be
|
|
10797 called @code{number-of-rows}.
|
|
10798
|
|
10799 Finally, we need a variable to use as a counter. We could call this
|
|
10800 variable @code{counter}, but a better name is @code{row-number}. That
|
|
10801 is because what the counter does in this function is count rows, and a
|
|
10802 program should be written to be as understandable as possible.
|
|
10803
|
|
10804 When the Lisp interpreter first starts evaluating the expressions in the
|
|
10805 function, the value of @code{total} should be set to zero, since we have
|
|
10806 not added anything to it. Then the function should add the number of
|
|
10807 pebbles in the first row to the total, and then add the number of
|
|
10808 pebbles in the second to the total, and then add the number of
|
|
10809 pebbles in the third row to the total, and so on, until there are no
|
|
10810 more rows left to add.
|
|
10811
|
|
10812 Both @code{total} and @code{row-number} are used only inside the
|
|
10813 function, so they can be declared as local variables with @code{let}
|
|
10814 and given initial values. Clearly, the initial value for @code{total}
|
|
10815 should be 0. The initial value of @code{row-number} should be 1,
|
|
10816 since we start with the first row. This means that the @code{let}
|
|
10817 statement will look like this:
|
|
10818
|
|
10819 @smallexample
|
|
10820 @group
|
|
10821 (let ((total 0)
|
|
10822 (row-number 1))
|
|
10823 @var{body}@dots{})
|
|
10824 @end group
|
|
10825 @end smallexample
|
|
10826
|
|
10827 After the internal variables are declared and bound to their initial
|
|
10828 values, we can begin the @code{while} loop. The expression that serves
|
|
10829 as the test should return a value of @code{t} for true so long as the
|
|
10830 @code{row-number} is less than or equal to the @code{number-of-rows}.
|
|
10831 (If the expression tests true only so long as the row number is less
|
|
10832 than the number of rows in the triangle, the last row will never be
|
|
10833 added to the total; hence the row number has to be either less than or
|
|
10834 equal to the number of rows.)
|
|
10835
|
|
10836 @need 1500
|
|
10837 @findex <= @r{(less than or equal)}
|
|
10838 Lisp provides the @code{<=} function that returns true if the value of
|
|
10839 its first argument is less than or equal to the value of its second
|
|
10840 argument and false otherwise. So the expression that the @code{while}
|
|
10841 will evaluate as its test should look like this:
|
|
10842
|
|
10843 @smallexample
|
|
10844 (<= row-number number-of-rows)
|
|
10845 @end smallexample
|
|
10846
|
|
10847 The total number of pebbles can be found by repeatedly adding the number
|
|
10848 of pebbles in a row to the total already found. Since the number of
|
|
10849 pebbles in the row is equal to the row number, the total can be found by
|
|
10850 adding the row number to the total. (Clearly, in a more complex
|
|
10851 situation, the number of pebbles in the row might be related to the row
|
|
10852 number in a more complicated way; if this were the case, the row number
|
|
10853 would be replaced by the appropriate expression.)
|
|
10854
|
|
10855 @smallexample
|
|
10856 (setq total (+ total row-number))
|
|
10857 @end smallexample
|
|
10858
|
|
10859 @noindent
|
|
10860 What this does is set the new value of @code{total} to be equal to the
|
|
10861 sum of adding the number of pebbles in the row to the previous total.
|
|
10862
|
|
10863 After setting the value of @code{total}, the conditions need to be
|
|
10864 established for the next repetition of the loop, if there is one. This
|
|
10865 is done by incrementing the value of the @code{row-number} variable,
|
|
10866 which serves as a counter. After the @code{row-number} variable has
|
|
10867 been incremented, the true-or-false-test at the beginning of the
|
|
10868 @code{while} loop tests whether its value is still less than or equal to
|
|
10869 the value of the @code{number-of-rows} and if it is, adds the new value
|
|
10870 of the @code{row-number} variable to the @code{total} of the previous
|
|
10871 repetition of the loop.
|
|
10872
|
|
10873 @need 1200
|
|
10874 The built-in Emacs Lisp function @code{1+} adds 1 to a number, so the
|
|
10875 @code{row-number} variable can be incremented with this expression:
|
|
10876
|
|
10877 @smallexample
|
|
10878 (setq row-number (1+ row-number))
|
|
10879 @end smallexample
|
|
10880
|
|
10881 @node Inc Example altogether, , Inc Example parts, Incrementing Loop Details
|
|
10882 @unnumberedsubsubsec Putting the function definition together
|
|
10883
|
|
10884 We have created the parts for the function definition; now we need to
|
|
10885 put them together.
|
|
10886
|
|
10887 @need 800
|
|
10888 First, the contents of the @code{while} expression:
|
|
10889
|
|
10890 @smallexample
|
|
10891 @group
|
|
10892 (while (<= row-number number-of-rows) ; @r{true-or-false-test}
|
|
10893 (setq total (+ total row-number))
|
|
10894 (setq row-number (1+ row-number))) ; @r{incrementer}
|
|
10895 @end group
|
|
10896 @end smallexample
|
|
10897
|
|
10898 Along with the @code{let} expression varlist, this very nearly
|
|
10899 completes the body of the function definition. However, it requires
|
|
10900 one final element, the need for which is somewhat subtle.
|
|
10901
|
|
10902 The final touch is to place the variable @code{total} on a line by
|
|
10903 itself after the @code{while} expression. Otherwise, the value returned
|
|
10904 by the whole function is the value of the last expression that is
|
|
10905 evaluated in the body of the @code{let}, and this is the value
|
|
10906 returned by the @code{while}, which is always @code{nil}.
|
|
10907
|
|
10908 This may not be evident at first sight. It almost looks as if the
|
|
10909 incrementing expression is the last expression of the whole function.
|
|
10910 But that expression is part of the body of the @code{while}; it is the
|
|
10911 last element of the list that starts with the symbol @code{while}.
|
|
10912 Moreover, the whole of the @code{while} loop is a list within the body
|
|
10913 of the @code{let}.
|
|
10914
|
|
10915 @need 1250
|
|
10916 In outline, the function will look like this:
|
|
10917
|
|
10918 @smallexample
|
|
10919 @group
|
|
10920 (defun @var{name-of-function} (@var{argument-list})
|
|
10921 "@var{documentation}@dots{}"
|
|
10922 (let (@var{varlist})
|
|
10923 (while (@var{true-or-false-test})
|
|
10924 @var{body-of-while}@dots{} )
|
|
10925 @dots{} )) ; @r{Need final expression here.}
|
|
10926 @end group
|
|
10927 @end smallexample
|
|
10928
|
|
10929 The result of evaluating the @code{let} is what is going to be returned
|
|
10930 by the @code{defun} since the @code{let} is not embedded within any
|
|
10931 containing list, except for the @code{defun} as a whole. However, if
|
|
10932 the @code{while} is the last element of the @code{let} expression, the
|
|
10933 function will always return @code{nil}. This is not what we want!
|
|
10934 Instead, what we want is the value of the variable @code{total}. This
|
|
10935 is returned by simply placing the symbol as the last element of the list
|
|
10936 starting with @code{let}. It gets evaluated after the preceding
|
|
10937 elements of the list are evaluated, which means it gets evaluated after
|
|
10938 it has been assigned the correct value for the total.
|
|
10939
|
|
10940 It may be easier to see this by printing the list starting with
|
|
10941 @code{let} all on one line. This format makes it evident that the
|
|
10942 @var{varlist} and @code{while} expressions are the second and third
|
|
10943 elements of the list starting with @code{let}, and the @code{total} is
|
|
10944 the last element:
|
|
10945
|
|
10946 @smallexample
|
|
10947 @group
|
|
10948 (let (@var{varlist}) (while (@var{true-or-false-test}) @var{body-of-while}@dots{} ) total)
|
|
10949 @end group
|
|
10950 @end smallexample
|
|
10951
|
|
10952 @need 1200
|
|
10953 Putting everything together, the @code{triangle} function definition
|
|
10954 looks like this:
|
|
10955
|
|
10956 @smallexample
|
|
10957 @group
|
|
10958 (defun triangle (number-of-rows) ; @r{Version with}
|
|
10959 ; @r{ incrementing counter.}
|
|
10960 "Add up the number of pebbles in a triangle.
|
|
10961 The first row has one pebble, the second row two pebbles,
|
|
10962 the third row three pebbles, and so on.
|
|
10963 The argument is NUMBER-OF-ROWS."
|
|
10964 @end group
|
|
10965 @group
|
|
10966 (let ((total 0)
|
|
10967 (row-number 1))
|
|
10968 (while (<= row-number number-of-rows)
|
|
10969 (setq total (+ total row-number))
|
|
10970 (setq row-number (1+ row-number)))
|
|
10971 total))
|
|
10972 @end group
|
|
10973 @end smallexample
|
|
10974
|
|
10975 @need 1200
|
|
10976 After you have installed @code{triangle} by evaluating the function, you
|
|
10977 can try it out. Here are two examples:
|
|
10978
|
|
10979 @smallexample
|
|
10980 @group
|
|
10981 (triangle 4)
|
|
10982
|
|
10983 (triangle 7)
|
|
10984 @end group
|
|
10985 @end smallexample
|
|
10986
|
|
10987 @noindent
|
|
10988 The sum of the first four numbers is 10 and the sum of the first seven
|
|
10989 numbers is 28.
|
|
10990
|
|
10991 @node Decrementing Loop, , Incrementing Loop Details, while
|
|
10992 @comment node-name, next, previous, up
|
|
10993 @subsection Loop with a Decrementing Counter
|
|
10994
|
|
10995 Another common way to write a @code{while} loop is to write the test
|
|
10996 so that it determines whether a counter is greater than zero. So long
|
|
10997 as the counter is greater than zero, the loop is repeated. But when
|
|
10998 the counter is equal to or less than zero, the loop is stopped. For
|
|
10999 this to work, the counter has to start out greater than zero and then
|
|
11000 be made smaller and smaller by a form that is evaluated
|
|
11001 repeatedly.
|
|
11002
|
|
11003 The test will be an expression such as @code{(> counter 0)} which
|
|
11004 returns @code{t} for true if the value of @code{counter} is greater
|
|
11005 than zero, and @code{nil} for false if the value of @code{counter} is
|
|
11006 equal to or less than zero. The expression that makes the number
|
|
11007 smaller and smaller can be a simple @code{setq} such as @code{(setq
|
|
11008 counter (1- counter))}, where @code{1-} is a built-in function in
|
|
11009 Emacs Lisp that subtracts 1 from its argument.
|
|
11010
|
|
11011 @need 1250
|
|
11012 The template for a decrementing @code{while} loop looks like this:
|
|
11013
|
|
11014 @smallexample
|
|
11015 @group
|
|
11016 (while (> counter 0) ; @r{true-or-false-test}
|
|
11017 @var{body}@dots{}
|
|
11018 (setq counter (1- counter))) ; @r{decrementer}
|
|
11019 @end group
|
|
11020 @end smallexample
|
|
11021
|
|
11022 @menu
|
|
11023 * Decrementing Example:: More pebbles on the beach.
|
|
11024 * Dec Example parts:: The parts of the function definition.
|
|
11025 * Dec Example altogether:: Putting the function definition together.
|
|
11026 @end menu
|
|
11027
|
|
11028 @node Decrementing Example, Dec Example parts, Decrementing Loop, Decrementing Loop
|
|
11029 @unnumberedsubsubsec Example with decrementing counter
|
|
11030
|
|
11031 To illustrate a loop with a decrementing counter, we will rewrite the
|
|
11032 @code{triangle} function so the counter decreases to zero.
|
|
11033
|
|
11034 This is the reverse of the earlier version of the function. In this
|
|
11035 case, to find out how many pebbles are needed to make a triangle with
|
|
11036 3 rows, add the number of pebbles in the third row, 3, to the number
|
|
11037 in the preceding row, 2, and then add the total of those two rows to
|
|
11038 the row that precedes them, which is 1.
|
|
11039
|
|
11040 Likewise, to find the number of pebbles in a triangle with 7 rows, add
|
|
11041 the number of pebbles in the seventh row, 7, to the number in the
|
|
11042 preceding row, which is 6, and then add the total of those two rows to
|
|
11043 the row that precedes them, which is 5, and so on. As in the previous
|
|
11044 example, each addition only involves adding two numbers, the total of
|
|
11045 the rows already added up and the number of pebbles in the row that is
|
|
11046 being added to the total. This process of adding two numbers is
|
|
11047 repeated again and again until there are no more pebbles to add.
|
|
11048
|
|
11049 We know how many pebbles to start with: the number of pebbles in the
|
|
11050 last row is equal to the number of rows. If the triangle has seven
|
|
11051 rows, the number of pebbles in the last row is 7. Likewise, we know how
|
|
11052 many pebbles are in the preceding row: it is one less than the number in
|
|
11053 the row.
|
|
11054
|
|
11055 @node Dec Example parts, Dec Example altogether, Decrementing Example, Decrementing Loop
|
|
11056 @unnumberedsubsubsec The parts of the function definition
|
|
11057
|
|
11058 We start with three variables: the total number of rows in the
|
|
11059 triangle; the number of pebbles in a row; and the total number of
|
|
11060 pebbles, which is what we want to calculate. These variables can be
|
|
11061 named @code{number-of-rows}, @code{number-of-pebbles-in-row}, and
|
|
11062 @code{total}, respectively.
|
|
11063
|
|
11064 Both @code{total} and @code{number-of-pebbles-in-row} are used only
|
|
11065 inside the function and are declared with @code{let}. The initial
|
|
11066 value of @code{total} should, of course, be zero. However, the
|
|
11067 initial value of @code{number-of-pebbles-in-row} should be equal to
|
|
11068 the number of rows in the triangle, since the addition will start with
|
|
11069 the longest row.
|
|
11070
|
|
11071 @need 1250
|
|
11072 This means that the beginning of the @code{let} expression will look
|
|
11073 like this:
|
|
11074
|
|
11075 @smallexample
|
|
11076 @group
|
|
11077 (let ((total 0)
|
|
11078 (number-of-pebbles-in-row number-of-rows))
|
|
11079 @var{body}@dots{})
|
|
11080 @end group
|
|
11081 @end smallexample
|
|
11082
|
|
11083 The total number of pebbles can be found by repeatedly adding the number
|
|
11084 of pebbles in a row to the total already found, that is, by repeatedly
|
|
11085 evaluating the following expression:
|
|
11086
|
|
11087 @smallexample
|
|
11088 (setq total (+ total number-of-pebbles-in-row))
|
|
11089 @end smallexample
|
|
11090
|
|
11091 @noindent
|
|
11092 After the @code{number-of-pebbles-in-row} is added to the @code{total},
|
|
11093 the @code{number-of-pebbles-in-row} should be decremented by one, since
|
|
11094 the next time the loop repeats, the preceding row will be
|
|
11095 added to the total.
|
|
11096
|
|
11097 The number of pebbles in a preceding row is one less than the number of
|
|
11098 pebbles in a row, so the built-in Emacs Lisp function @code{1-} can be
|
|
11099 used to compute the number of pebbles in the preceding row. This can be
|
|
11100 done with the following expression:
|
|
11101
|
|
11102 @smallexample
|
|
11103 @group
|
|
11104 (setq number-of-pebbles-in-row
|
|
11105 (1- number-of-pebbles-in-row))
|
|
11106 @end group
|
|
11107 @end smallexample
|
|
11108
|
|
11109 Finally, we know that the @code{while} loop should stop making repeated
|
|
11110 additions when there are no pebbles in a row. So the test for
|
|
11111 the @code{while} loop is simply:
|
|
11112
|
|
11113 @smallexample
|
|
11114 (while (> number-of-pebbles-in-row 0)
|
|
11115 @end smallexample
|
|
11116
|
|
11117 @node Dec Example altogether, , Dec Example parts, Decrementing Loop
|
|
11118 @unnumberedsubsubsec Putting the function definition together
|
|
11119
|
|
11120 We can put these expressions together to create a function definition
|
|
11121 that works. However, on examination, we find that one of the local
|
|
11122 variables is unneeded!
|
|
11123
|
|
11124 @need 1250
|
|
11125 The function definition looks like this:
|
|
11126
|
|
11127 @smallexample
|
|
11128 @group
|
|
11129 ;;; @r{First subtractive version.}
|
|
11130 (defun triangle (number-of-rows)
|
|
11131 "Add up the number of pebbles in a triangle."
|
|
11132 (let ((total 0)
|
|
11133 (number-of-pebbles-in-row number-of-rows))
|
|
11134 (while (> number-of-pebbles-in-row 0)
|
|
11135 (setq total (+ total number-of-pebbles-in-row))
|
|
11136 (setq number-of-pebbles-in-row
|
|
11137 (1- number-of-pebbles-in-row)))
|
|
11138 total))
|
|
11139 @end group
|
|
11140 @end smallexample
|
|
11141
|
|
11142 As written, this function works.
|
|
11143
|
|
11144 However, we do not need @code{number-of-pebbles-in-row}.
|
|
11145
|
|
11146 @cindex Argument as local variable
|
|
11147 When the @code{triangle} function is evaluated, the symbol
|
|
11148 @code{number-of-rows} will be bound to a number, giving it an initial
|
|
11149 value. That number can be changed in the body of the function as if
|
|
11150 it were a local variable, without any fear that such a change will
|
|
11151 effect the value of the variable outside of the function. This is a
|
|
11152 very useful characteristic of Lisp; it means that the variable
|
|
11153 @code{number-of-rows} can be used anywhere in the function where
|
|
11154 @code{number-of-pebbles-in-row} is used.
|
|
11155
|
|
11156 @need 800
|
|
11157 Here is a second version of the function written a bit more cleanly:
|
|
11158
|
|
11159 @smallexample
|
|
11160 @group
|
|
11161 (defun triangle (number) ; @r{Second version.}
|
|
11162 "Return sum of numbers 1 through NUMBER inclusive."
|
|
11163 (let ((total 0))
|
|
11164 (while (> number 0)
|
|
11165 (setq total (+ total number))
|
|
11166 (setq number (1- number)))
|
|
11167 total))
|
|
11168 @end group
|
|
11169 @end smallexample
|
|
11170
|
|
11171 In brief, a properly written @code{while} loop will consist of three parts:
|
|
11172
|
|
11173 @enumerate
|
|
11174 @item
|
|
11175 A test that will return false after the loop has repeated itself the
|
|
11176 correct number of times.
|
|
11177
|
|
11178 @item
|
|
11179 An expression the evaluation of which will return the value desired
|
|
11180 after being repeatedly evaluated.
|
|
11181
|
|
11182 @item
|
|
11183 An expression to change the value passed to the true-or-false-test so
|
|
11184 that the test returns false after the loop has repeated itself the right
|
|
11185 number of times.
|
|
11186 @end enumerate
|
|
11187
|
|
11188 @node dolist dotimes, Recursion, while, Loops & Recursion
|
|
11189 @comment node-name, next, previous, up
|
|
11190 @section Save your time: @code{dolist} and @code{dotimes}
|
|
11191
|
|
11192 In addition to @code{while}, both @code{dolist} and @code{dotimes}
|
|
11193 provide for looping. Sometimes these are quicker to write than the
|
|
11194 equivalent @code{while} loop. Both are Lisp macros. (@xref{Macros, ,
|
|
11195 Macros, elisp, The GNU Emacs Lisp Reference Manual}. )
|
|
11196
|
|
11197 @code{dolist} works like a @code{while} loop that `@sc{cdr}s down a
|
|
11198 list': @code{dolist} automatically shortens the list each time it
|
|
11199 loops---takes the @sc{cdr} of the list---and binds the @sc{car} of
|
|
11200 each shorter version of the list to the first of its arguments.
|
|
11201
|
|
11202 @code{dotimes} loops a specific number of times: you specify the number.
|
|
11203
|
|
11204 @menu
|
|
11205 * dolist::
|
|
11206 * dotimes::
|
|
11207 @end menu
|
|
11208
|
|
11209 @node dolist, dotimes, dolist dotimes, dolist dotimes
|
|
11210 @unnumberedsubsubsec The @code{dolist} Macro
|
|
11211 @findex dolist
|
|
11212
|
|
11213 Suppose, for example, you want to reverse a list, so that
|
|
11214 ``first'' ``second'' ``third'' becomes ``third'' ``second'' ``first''.
|
|
11215
|
|
11216 @need 1250
|
|
11217 In practice, you would use the @code{reverse} function, like this:
|
|
11218
|
|
11219 @smallexample
|
|
11220 @group
|
|
11221 (setq animals '(gazelle giraffe lion tiger))
|
|
11222
|
|
11223 (reverse animals)
|
|
11224 @end group
|
|
11225 @end smallexample
|
|
11226
|
|
11227 @need 800
|
|
11228 @noindent
|
|
11229 Here is how you could reverse the list using a @code{while} loop:
|
|
11230
|
|
11231 @smallexample
|
|
11232 @group
|
|
11233 (setq animals '(gazelle giraffe lion tiger))
|
|
11234
|
|
11235 (defun reverse-list-with-while (list)
|
|
11236 "Using while, reverse the order of LIST."
|
|
11237 (let (value) ; make sure list starts empty
|
|
11238 (while list
|
|
11239 (setq value (cons (car list) value))
|
|
11240 (setq list (cdr list)))
|
|
11241 value))
|
|
11242
|
|
11243 (reverse-list-with-while animals)
|
|
11244 @end group
|
|
11245 @end smallexample
|
|
11246
|
|
11247 @need 800
|
|
11248 @noindent
|
|
11249 And here is how you could use the @code{dolist} macro:
|
|
11250
|
|
11251 @smallexample
|
|
11252 @group
|
|
11253 (setq animals '(gazelle giraffe lion tiger))
|
|
11254
|
|
11255 (defun reverse-list-with-dolist (list)
|
|
11256 "Using dolist, reverse the order of LIST."
|
|
11257 (let (value) ; make sure list starts empty
|
|
11258 (dolist (element list value)
|
|
11259 (setq value (cons element value)))))
|
|
11260
|
|
11261 (reverse-list-with-dolist animals)
|
|
11262 @end group
|
|
11263 @end smallexample
|
|
11264
|
|
11265 @need 1250
|
|
11266 @noindent
|
|
11267 In Info, you can place your cursor after the closing parenthesis of
|
|
11268 each expression and type @kbd{C-x C-e}; in each case, you should see
|
|
11269
|
|
11270 @smallexample
|
|
11271 (tiger lion giraffe gazelle)
|
|
11272 @end smallexample
|
|
11273
|
|
11274 @noindent
|
|
11275 in the echo area.
|
|
11276
|
|
11277 For this example, the existing @code{reverse} function is obviously best.
|
|
11278 The @code{while} loop is just like our first example (@pxref{Loop
|
|
11279 Example, , A @code{while} Loop and a List}). The @code{while} first
|
|
11280 checks whether the list has elements; if so, it constructs a new list
|
|
11281 by adding the first element of the list to the existing list (which in
|
|
11282 the first iteration of the loop is @code{nil}). Since the second
|
|
11283 element is prepended in front of the first element, and the third
|
|
11284 element is prepended in front of the second element, the list is reversed.
|
|
11285
|
|
11286 In the expression using a @code{while} loop,
|
|
11287 the @w{@code{(setq list (cdr list))}}
|
|
11288 expression shortens the list, so the @code{while} loop eventually
|
|
11289 stops. In addition, it provides the @code{cons} expression with a new
|
|
11290 first element by creating a new and shorter list at each repetition of
|
|
11291 the loop.
|
|
11292
|
|
11293 The @code{dolist} expression does very much the same as the
|
|
11294 @code{while} expression, except that the @code{dolist} macro does some
|
|
11295 of the work you have to do when writing a @code{while} expression.
|
|
11296
|
|
11297 Like a @code{while} loop, a @code{dolist} loops. What is different is
|
|
11298 that it automatically shortens the list each time it loops --- it
|
|
11299 `@sc{cdr}s down the list' on its own --- and it automatically binds
|
|
11300 the @sc{car} of each shorter version of the list to the first of its
|
|
11301 arguments.
|
|
11302
|
|
11303 In the example, the @sc{car} of each shorter version of the list is
|
|
11304 referred to using the symbol @samp{element}, the list itself is called
|
|
11305 @samp{list}, and the value returned is called @samp{value}. The
|
|
11306 remainder of the @code{dolist} expression is the body.
|
|
11307
|
|
11308 The @code{dolist} expression binds the @sc{car} of each shorter
|
|
11309 version of the list to @code{element} and then evaluates the body of
|
|
11310 the expression; and repeats the loop. The result is returned in
|
|
11311 @code{value}.
|
|
11312
|
|
11313 @node dotimes, , dolist, dolist dotimes
|
|
11314 @unnumberedsubsubsec The @code{dotimes} Macro
|
|
11315 @findex dotimes
|
|
11316
|
|
11317 The @code{dotimes} macro is similar to @code{dolist}, except that it
|
|
11318 loops a specific number of times.
|
|
11319
|
|
11320 The first argument to @code{dotimes} is assigned the numbers 0, 1, 2
|
|
11321 and so forth each time around the loop, and the value of the third
|
|
11322 argument is returned. You need to provide the value of the second
|
|
11323 argument, which is how many times the macro loops.
|
|
11324
|
|
11325 @need 1250
|
|
11326 For example, the following binds the numbers from 0 up to, but not
|
|
11327 including, the number 3 to the first argument, @var{number}, and then
|
|
11328 constructs a list of the three numbers. (The first number is 0, the
|
|
11329 second number is 1, and the third number is 2; this makes a total of
|
|
11330 three numbers in all, starting with zero as the first number.)
|
|
11331
|
|
11332 @smallexample
|
|
11333 @group
|
|
11334 (let (value) ; otherwise a value is a void variable
|
|
11335 (dotimes (number 3 value)
|
|
11336 (setq value (cons number value))))
|
|
11337
|
|
11338 @result{} (2 1 0)
|
|
11339 @end group
|
|
11340 @end smallexample
|
|
11341
|
|
11342 @noindent
|
|
11343 @code{dotimes} returns @code{value}, so the way to use
|
|
11344 @code{dotimes} is to operate on some expression @var{number} number of
|
|
11345 times and then return the result, either as a list or an atom.
|
|
11346
|
|
11347 @need 1250
|
|
11348 Here is an example of a @code{defun} that uses @code{dotimes} to add
|
|
11349 up the number of pebbles in a triangle.
|
|
11350
|
|
11351 @smallexample
|
|
11352 @group
|
|
11353 (defun triangle-using-dotimes (number-of-rows)
|
|
11354 "Using dotimes, add up the number of pebbles in a triangle."
|
|
11355 (let ((total 0)) ; otherwise a total is a void variable
|
|
11356 (dotimes (number number-of-rows total)
|
|
11357 (setq total (+ total (1+ number))))))
|
|
11358
|
|
11359 (triangle-using-dotimes 4)
|
|
11360 @end group
|
|
11361 @end smallexample
|
|
11362
|
|
11363 @node Recursion, Looping exercise, dolist dotimes, Loops & Recursion
|
|
11364 @comment node-name, next, previous, up
|
|
11365 @section Recursion
|
|
11366 @cindex Recursion
|
|
11367
|
|
11368 A recursive function contains code that tells the Lisp interpreter to
|
|
11369 call a program that runs exactly like itself, but with slightly
|
|
11370 different arguments. The code runs exactly the same because it has
|
|
11371 the same name. However, even though the program has the same name, it
|
|
11372 is not the same entity. It is different. In the jargon, it is a
|
|
11373 different `instance'.
|
|
11374
|
|
11375 Eventually, if the program is written correctly, the `slightly
|
|
11376 different arguments' will become sufficiently different from the first
|
|
11377 arguments that the final instance will stop.
|
|
11378
|
|
11379 @menu
|
|
11380 * Building Robots:: Same model, different serial number ...
|
|
11381 * Recursive Definition Parts:: Walk until you stop ...
|
|
11382 * Recursion with list:: Using a list as the test whether to recurse.
|
|
11383 * Recursive triangle function::
|
|
11384 * Recursion with cond::
|
|
11385 * Recursive Patterns:: Often used templates.
|
|
11386 * No Deferment:: Don't store up work ...
|
|
11387 * No deferment solution::
|
|
11388 @end menu
|
|
11389
|
|
11390 @node Building Robots, Recursive Definition Parts, Recursion, Recursion
|
|
11391 @comment node-name, next, previous, up
|
|
11392 @subsection Building Robots: Extending the Metaphor
|
|
11393 @cindex Building robots
|
|
11394 @cindex Robots, building
|
|
11395
|
|
11396 It is sometimes helpful to think of a running program as a robot that
|
|
11397 does a job. In doing its job, a recursive function calls on a second
|
|
11398 robot to help it. The second robot is identical to the first in every
|
|
11399 way, except that the second robot helps the first and has been
|
|
11400 passed different arguments than the first.
|
|
11401
|
|
11402 In a recursive function, the second robot may call a third; and the
|
|
11403 third may call a fourth, and so on. Each of these is a different
|
|
11404 entity; but all are clones.
|
|
11405
|
|
11406 Since each robot has slightly different instructions---the arguments
|
|
11407 will differ from one robot to the next---the last robot should know
|
|
11408 when to stop.
|
|
11409
|
|
11410 Let's expand on the metaphor in which a computer program is a robot.
|
|
11411
|
|
11412 A function definition provides the blueprints for a robot. When you
|
|
11413 install a function definition, that is, when you evaluate a
|
|
11414 @code{defun} special form, you install the necessary equipment to
|
|
11415 build robots. It is as if you were in a factory, setting up an
|
|
11416 assembly line. Robots with the same name are built according to the
|
|
11417 same blueprints. So they have, as it were, the same `model number',
|
|
11418 but a different `serial number'.
|
|
11419
|
|
11420 We often say that a recursive function `calls itself'. What we mean
|
|
11421 is that the instructions in a recursive function cause the Lisp
|
|
11422 interpreter to run a different function that has the same name and
|
|
11423 does the same job as the first, but with different arguments.
|
|
11424
|
|
11425 It is important that the arguments differ from one instance to the
|
|
11426 next; otherwise, the process will never stop.
|
|
11427
|
|
11428 @node Recursive Definition Parts, Recursion with list, Building Robots, Recursion
|
|
11429 @comment node-name, next, previous, up
|
|
11430 @subsection The Parts of a Recursive Definition
|
|
11431 @cindex Parts of a Recursive Definition
|
|
11432 @cindex Recursive Definition Parts
|
|
11433
|
|
11434 A recursive function typically contains a conditional expression which
|
|
11435 has three parts:
|
|
11436
|
|
11437 @enumerate
|
|
11438 @item
|
|
11439 A true-or-false-test that determines whether the function is called
|
|
11440 again, here called the @dfn{do-again-test}.
|
|
11441
|
|
11442 @item
|
|
11443 The name of the function. When this name is called, a new instance of
|
|
11444 the function---a new robot, as it were---is created and told what to do.
|
|
11445
|
|
11446 @item
|
|
11447 An expression that returns a different value each time the function is
|
|
11448 called, here called the @dfn{next-step-expression}. Consequently, the
|
|
11449 argument (or arguments) passed to the new instance of the function
|
|
11450 will be different from that passed to the previous instance. This
|
|
11451 causes the conditional expression, the @dfn{do-again-test}, to test
|
|
11452 false after the correct number of repetitions.
|
|
11453 @end enumerate
|
|
11454
|
|
11455 Recursive functions can be much simpler than any other kind of
|
|
11456 function. Indeed, when people first start to use them, they often look
|
|
11457 so mysteriously simple as to be incomprehensible. Like riding a
|
|
11458 bicycle, reading a recursive function definition takes a certain knack
|
|
11459 which is hard at first but then seems simple.
|
|
11460
|
|
11461 @need 1200
|
|
11462 There are several different common recursive patterns. A very simple
|
|
11463 pattern looks like this:
|
|
11464
|
|
11465 @smallexample
|
|
11466 @group
|
|
11467 (defun @var{name-of-recursive-function} (@var{argument-list})
|
|
11468 "@var{documentation}@dots{}"
|
|
11469 (if @var{do-again-test}
|
|
11470 @var{body}@dots{}
|
|
11471 (@var{name-of-recursive-function}
|
|
11472 @var{next-step-expression})))
|
|
11473 @end group
|
|
11474 @end smallexample
|
|
11475
|
|
11476 Each time a recursive function is evaluated, a new instance of it is
|
|
11477 created and told what to do. The arguments tell the instance what to do.
|
|
11478
|
|
11479 An argument is bound to the value of the next-step-expression. Each
|
|
11480 instance runs with a different value of the next-step-expression.
|
|
11481
|
|
11482 The value in the next-step-expression is used in the do-again-test.
|
|
11483
|
|
11484 The value returned by the next-step-expression is passed to the new
|
|
11485 instance of the function, which evaluates it (or some
|
|
11486 transmogrification of it) to determine whether to continue or stop.
|
|
11487 The next-step-expression is designed so that the do-again-test returns
|
|
11488 false when the function should no longer be repeated.
|
|
11489
|
|
11490 The do-again-test is sometimes called the @dfn{stop condition},
|
|
11491 since it stops the repetitions when it tests false.
|
|
11492
|
|
11493 @node Recursion with list, Recursive triangle function, Recursive Definition Parts, Recursion
|
|
11494 @comment node-name, next, previous, up
|
|
11495 @subsection Recursion with a List
|
|
11496
|
|
11497 The example of a @code{while} loop that printed the elements of a list
|
|
11498 of numbers can be written recursively. Here is the code, including
|
|
11499 an expression to set the value of the variable @code{animals} to a list.
|
|
11500
|
|
11501 If you are using GNU Emacs 20 or before, this example must be copied
|
|
11502 to the @file{*scratch*} buffer and each expression must be evaluated
|
|
11503 there. Use @kbd{C-u C-x C-e} to evaluate the
|
|
11504 @code{(print-elements-recursively animals)} expression so that the
|
|
11505 results are printed in the buffer; otherwise the Lisp interpreter will
|
|
11506 try to squeeze the results into the one line of the echo area.
|
|
11507
|
|
11508 Also, place your cursor immediately after the last closing parenthesis
|
|
11509 of the @code{print-elements-recursively} function, before the comment.
|
|
11510 Otherwise, the Lisp interpreter will try to evaluate the comment.
|
|
11511
|
|
11512 If you are using a more recent version of Emacs, you can evaluate this
|
|
11513 expression directly in Info.
|
|
11514
|
|
11515 @findex print-elements-recursively
|
|
11516 @smallexample
|
|
11517 @group
|
|
11518 (setq animals '(gazelle giraffe lion tiger))
|
|
11519
|
|
11520 (defun print-elements-recursively (list)
|
|
11521 "Print each element of LIST on a line of its own.
|
|
11522 Uses recursion."
|
|
11523 (when list ; @r{do-again-test}
|
|
11524 (print (car list)) ; @r{body}
|
|
11525 (print-elements-recursively ; @r{recursive call}
|
|
11526 (cdr list)))) ; @r{next-step-expression}
|
|
11527
|
|
11528 (print-elements-recursively animals)
|
|
11529 @end group
|
|
11530 @end smallexample
|
|
11531
|
|
11532 The @code{print-elements-recursively} function first tests whether
|
|
11533 there is any content in the list; if there is, the function prints the
|
|
11534 first element of the list, the @sc{car} of the list. Then the
|
|
11535 function `invokes itself', but gives itself as its argument, not the
|
|
11536 whole list, but the second and subsequent elements of the list, the
|
|
11537 @sc{cdr} of the list.
|
|
11538
|
|
11539 Put another way, if the list is not empty, the function invokes
|
|
11540 another instance of code that is similar to the initial code, but is a
|
|
11541 different thread of execution, with different arguments than the first
|
|
11542 instance.
|
|
11543
|
|
11544 Put in yet another way, if the list is not empty, the first robot
|
98770
|
11545 assembles a second robot and tells it what to do; the second robot is
|
83955
|
11546 a different individual from the first, but is the same model.
|
|
11547
|
|
11548 When the second evaluation occurs, the @code{when} expression is
|
|
11549 evaluated and if true, prints the first element of the list it
|
|
11550 receives as its argument (which is the second element of the original
|
|
11551 list). Then the function `calls itself' with the @sc{cdr} of the list
|
|
11552 it is invoked with, which (the second time around) is the @sc{cdr} of
|
|
11553 the @sc{cdr} of the original list.
|
|
11554
|
|
11555 Note that although we say that the function `calls itself', what we
|
|
11556 mean is that the Lisp interpreter assembles and instructs a new
|
|
11557 instance of the program. The new instance is a clone of the first,
|
|
11558 but is a separate individual.
|
|
11559
|
|
11560 Each time the function `invokes itself', it invokes itself on a
|
|
11561 shorter version of the original list. It creates a new instance that
|
|
11562 works on a shorter list.
|
|
11563
|
|
11564 Eventually, the function invokes itself on an empty list. It creates
|
|
11565 a new instance whose argument is @code{nil}. The conditional expression
|
|
11566 tests the value of @code{list}. Since the value of @code{list} is
|
|
11567 @code{nil}, the @code{when} expression tests false so the then-part is
|
|
11568 not evaluated. The function as a whole then returns @code{nil}.
|
|
11569
|
|
11570 @need 1200
|
98525
|
11571 When you evaluate the expression @code{(print-elements-recursively
|
|
11572 animals)} in the @file{*scratch*} buffer, you see this result:
|
83955
|
11573
|
|
11574 @smallexample
|
|
11575 @group
|
|
11576 gazelle
|
|
11577
|
|
11578 giraffe
|
|
11579
|
|
11580 lion
|
|
11581
|
|
11582 tiger
|
|
11583 nil
|
|
11584 @end group
|
|
11585 @end smallexample
|
|
11586
|
|
11587 @need 2000
|
|
11588 @node Recursive triangle function, Recursion with cond, Recursion with list, Recursion
|
|
11589 @comment node-name, next, previous, up
|
|
11590 @subsection Recursion in Place of a Counter
|
|
11591 @findex triangle-recursively
|
|
11592
|
|
11593 @need 1200
|
|
11594 The @code{triangle} function described in a previous section can also
|
|
11595 be written recursively. It looks like this:
|
|
11596
|
|
11597 @smallexample
|
|
11598 @group
|
|
11599 (defun triangle-recursively (number)
|
|
11600 "Return the sum of the numbers 1 through NUMBER inclusive.
|
|
11601 Uses recursion."
|
|
11602 (if (= number 1) ; @r{do-again-test}
|
|
11603 1 ; @r{then-part}
|
|
11604 (+ number ; @r{else-part}
|
|
11605 (triangle-recursively ; @r{recursive call}
|
|
11606 (1- number))))) ; @r{next-step-expression}
|
|
11607
|
|
11608 (triangle-recursively 7)
|
|
11609 @end group
|
|
11610 @end smallexample
|
|
11611
|
|
11612 @noindent
|
|
11613 You can install this function by evaluating it and then try it by
|
|
11614 evaluating @code{(triangle-recursively 7)}. (Remember to put your
|
|
11615 cursor immediately after the last parenthesis of the function
|
|
11616 definition, before the comment.) The function evaluates to 28.
|
|
11617
|
|
11618 To understand how this function works, let's consider what happens in the
|
|
11619 various cases when the function is passed 1, 2, 3, or 4 as the value of
|
|
11620 its argument.
|
|
11621
|
|
11622 @menu
|
|
11623 * Recursive Example arg of 1 or 2::
|
|
11624 * Recursive Example arg of 3 or 4::
|
|
11625 @end menu
|
|
11626
|
|
11627 @node Recursive Example arg of 1 or 2, Recursive Example arg of 3 or 4, Recursive triangle function, Recursive triangle function
|
|
11628 @ifnottex
|
|
11629 @unnumberedsubsubsec An argument of 1 or 2
|
|
11630 @end ifnottex
|
|
11631
|
|
11632 First, what happens if the value of the argument is 1?
|
|
11633
|
|
11634 The function has an @code{if} expression after the documentation
|
|
11635 string. It tests whether the value of @code{number} is equal to 1; if
|
|
11636 so, Emacs evaluates the then-part of the @code{if} expression, which
|
|
11637 returns the number 1 as the value of the function. (A triangle with
|
|
11638 one row has one pebble in it.)
|
|
11639
|
|
11640 Suppose, however, that the value of the argument is 2. In this case,
|
|
11641 Emacs evaluates the else-part of the @code{if} expression.
|
|
11642
|
|
11643 @need 1200
|
|
11644 The else-part consists of an addition, the recursive call to
|
|
11645 @code{triangle-recursively} and a decrementing action; and it looks like
|
|
11646 this:
|
|
11647
|
|
11648 @smallexample
|
|
11649 (+ number (triangle-recursively (1- number)))
|
|
11650 @end smallexample
|
|
11651
|
|
11652 When Emacs evaluates this expression, the innermost expression is
|
|
11653 evaluated first; then the other parts in sequence. Here are the steps
|
|
11654 in detail:
|
|
11655
|
|
11656 @table @i
|
|
11657 @item Step 1 @w{ } Evaluate the innermost expression.
|
|
11658
|
|
11659 The innermost expression is @code{(1- number)} so Emacs decrements the
|
|
11660 value of @code{number} from 2 to 1.
|
|
11661
|
|
11662 @item Step 2 @w{ } Evaluate the @code{triangle-recursively} function.
|
|
11663
|
|
11664 The Lisp interpreter creates an individual instance of
|
|
11665 @code{triangle-recursively}. It does not matter that this function is
|
|
11666 contained within itself. Emacs passes the result Step 1 as the
|
|
11667 argument used by this instance of the @code{triangle-recursively}
|
|
11668 function
|
|
11669
|
|
11670 In this case, Emacs evaluates @code{triangle-recursively} with an
|
|
11671 argument of 1. This means that this evaluation of
|
|
11672 @code{triangle-recursively} returns 1.
|
|
11673
|
|
11674 @item Step 3 @w{ } Evaluate the value of @code{number}.
|
|
11675
|
|
11676 The variable @code{number} is the second element of the list that
|
|
11677 starts with @code{+}; its value is 2.
|
|
11678
|
|
11679 @item Step 4 @w{ } Evaluate the @code{+} expression.
|
|
11680
|
|
11681 The @code{+} expression receives two arguments, the first
|
|
11682 from the evaluation of @code{number} (Step 3) and the second from the
|
|
11683 evaluation of @code{triangle-recursively} (Step 2).
|
|
11684
|
|
11685 The result of the addition is the sum of 2 plus 1, and the number 3 is
|
|
11686 returned, which is correct. A triangle with two rows has three
|
|
11687 pebbles in it.
|
|
11688 @end table
|
|
11689
|
|
11690 @node Recursive Example arg of 3 or 4, , Recursive Example arg of 1 or 2, Recursive triangle function
|
|
11691 @unnumberedsubsubsec An argument of 3 or 4
|
|
11692
|
|
11693 Suppose that @code{triangle-recursively} is called with an argument of
|
|
11694 3.
|
|
11695
|
|
11696 @table @i
|
|
11697 @item Step 1 @w{ } Evaluate the do-again-test.
|
|
11698
|
|
11699 The @code{if} expression is evaluated first. This is the do-again
|
|
11700 test and returns false, so the else-part of the @code{if} expression
|
|
11701 is evaluated. (Note that in this example, the do-again-test causes
|
|
11702 the function to call itself when it tests false, not when it tests
|
|
11703 true.)
|
|
11704
|
|
11705 @item Step 2 @w{ } Evaluate the innermost expression of the else-part.
|
|
11706
|
|
11707 The innermost expression of the else-part is evaluated, which decrements
|
|
11708 3 to 2. This is the next-step-expression.
|
|
11709
|
|
11710 @item Step 3 @w{ } Evaluate the @code{triangle-recursively} function.
|
|
11711
|
|
11712 The number 2 is passed to the @code{triangle-recursively} function.
|
|
11713
|
98525
|
11714 We already know what happens when Emacs evaluates @code{triangle-recursively} with
|
83955
|
11715 an argument of 2. After going through the sequence of actions described
|
|
11716 earlier, it returns a value of 3. So that is what will happen here.
|
|
11717
|
|
11718 @item Step 4 @w{ } Evaluate the addition.
|
|
11719
|
|
11720 3 will be passed as an argument to the addition and will be added to the
|
|
11721 number with which the function was called, which is 3.
|
|
11722 @end table
|
|
11723
|
|
11724 @noindent
|
|
11725 The value returned by the function as a whole will be 6.
|
|
11726
|
|
11727 Now that we know what will happen when @code{triangle-recursively} is
|
|
11728 called with an argument of 3, it is evident what will happen if it is
|
|
11729 called with an argument of 4:
|
|
11730
|
|
11731 @quotation
|
|
11732 @need 800
|
|
11733 In the recursive call, the evaluation of
|
|
11734
|
|
11735 @smallexample
|
|
11736 (triangle-recursively (1- 4))
|
|
11737 @end smallexample
|
|
11738
|
|
11739 @need 800
|
|
11740 @noindent
|
|
11741 will return the value of evaluating
|
|
11742
|
|
11743 @smallexample
|
|
11744 (triangle-recursively 3)
|
|
11745 @end smallexample
|
|
11746
|
|
11747 @noindent
|
|
11748 which is 6 and this value will be added to 4 by the addition in the
|
|
11749 third line.
|
|
11750 @end quotation
|
|
11751
|
|
11752 @noindent
|
|
11753 The value returned by the function as a whole will be 10.
|
|
11754
|
|
11755 Each time @code{triangle-recursively} is evaluated, it evaluates a
|
|
11756 version of itself---a different instance of itself---with a smaller
|
|
11757 argument, until the argument is small enough so that it does not
|
|
11758 evaluate itself.
|
|
11759
|
|
11760 Note that this particular design for a recursive function
|
|
11761 requires that operations be deferred.
|
|
11762
|
|
11763 Before @code{(triangle-recursively 7)} can calculate its answer, it
|
|
11764 must call @code{(triangle-recursively 6)}; and before
|
|
11765 @code{(triangle-recursively 6)} can calculate its answer, it must call
|
|
11766 @code{(triangle-recursively 5)}; and so on. That is to say, the
|
|
11767 calculation that @code{(triangle-recursively 7)} makes must be
|
|
11768 deferred until @code{(triangle-recursively 6)} makes its calculation;
|
|
11769 and @code{(triangle-recursively 6)} must defer until
|
|
11770 @code{(triangle-recursively 5)} completes; and so on.
|
|
11771
|
|
11772 If each of these instances of @code{triangle-recursively} are thought
|
|
11773 of as different robots, the first robot must wait for the second to
|
|
11774 complete its job, which must wait until the third completes, and so
|
|
11775 on.
|
|
11776
|
|
11777 There is a way around this kind of waiting, which we will discuss in
|
|
11778 @ref{No Deferment, , Recursion without Deferments}.
|
|
11779
|
|
11780 @node Recursion with cond, Recursive Patterns, Recursive triangle function, Recursion
|
|
11781 @comment node-name, next, previous, up
|
|
11782 @subsection Recursion Example Using @code{cond}
|
|
11783 @findex cond
|
|
11784
|
|
11785 The version of @code{triangle-recursively} described earlier is written
|
|
11786 with the @code{if} special form. It can also be written using another
|
|
11787 special form called @code{cond}. The name of the special form
|
|
11788 @code{cond} is an abbreviation of the word @samp{conditional}.
|
|
11789
|
|
11790 Although the @code{cond} special form is not used as often in the
|
|
11791 Emacs Lisp sources as @code{if}, it is used often enough to justify
|
|
11792 explaining it.
|
|
11793
|
|
11794 @need 800
|
|
11795 The template for a @code{cond} expression looks like this:
|
|
11796
|
|
11797 @smallexample
|
|
11798 @group
|
|
11799 (cond
|
|
11800 @var{body}@dots{})
|
|
11801 @end group
|
|
11802 @end smallexample
|
|
11803
|
|
11804 @noindent
|
|
11805 where the @var{body} is a series of lists.
|
|
11806
|
|
11807 @need 800
|
|
11808 Written out more fully, the template looks like this:
|
|
11809
|
|
11810 @smallexample
|
|
11811 @group
|
|
11812 (cond
|
|
11813 (@var{first-true-or-false-test} @var{first-consequent})
|
|
11814 (@var{second-true-or-false-test} @var{second-consequent})
|
|
11815 (@var{third-true-or-false-test} @var{third-consequent})
|
|
11816 @dots{})
|
|
11817 @end group
|
|
11818 @end smallexample
|
|
11819
|
|
11820 When the Lisp interpreter evaluates the @code{cond} expression, it
|
|
11821 evaluates the first element (the @sc{car} or true-or-false-test) of
|
|
11822 the first expression in a series of expressions within the body of the
|
|
11823 @code{cond}.
|
|
11824
|
|
11825 If the true-or-false-test returns @code{nil} the rest of that
|
|
11826 expression, the consequent, is skipped and the true-or-false-test of the
|
|
11827 next expression is evaluated. When an expression is found whose
|
|
11828 true-or-false-test returns a value that is not @code{nil}, the
|
|
11829 consequent of that expression is evaluated. The consequent can be one
|
|
11830 or more expressions. If the consequent consists of more than one
|
|
11831 expression, the expressions are evaluated in sequence and the value of
|
|
11832 the last one is returned. If the expression does not have a consequent,
|
|
11833 the value of the true-or-false-test is returned.
|
|
11834
|
|
11835 If none of the true-or-false-tests test true, the @code{cond} expression
|
|
11836 returns @code{nil}.
|
|
11837
|
|
11838 @need 1250
|
|
11839 Written using @code{cond}, the @code{triangle} function looks like this:
|
|
11840
|
|
11841 @smallexample
|
|
11842 @group
|
|
11843 (defun triangle-using-cond (number)
|
|
11844 (cond ((<= number 0) 0)
|
|
11845 ((= number 1) 1)
|
|
11846 ((> number 1)
|
|
11847 (+ number (triangle-using-cond (1- number))))))
|
|
11848 @end group
|
|
11849 @end smallexample
|
|
11850
|
|
11851 @noindent
|
|
11852 In this example, the @code{cond} returns 0 if the number is less than or
|
|
11853 equal to 0, it returns 1 if the number is 1 and it evaluates @code{(+
|
|
11854 number (triangle-using-cond (1- number)))} if the number is greater than
|
|
11855 1.
|
|
11856
|
|
11857 @node Recursive Patterns, No Deferment, Recursion with cond, Recursion
|
|
11858 @comment node-name, next, previous, up
|
|
11859 @subsection Recursive Patterns
|
|
11860 @cindex Recursive Patterns
|
|
11861
|
|
11862 Here are three common recursive patterns. Each involves a list.
|
|
11863 Recursion does not need to involve lists, but Lisp is designed for lists
|
|
11864 and this provides a sense of its primal capabilities.
|
|
11865
|
|
11866 @menu
|
|
11867 * Every::
|
|
11868 * Accumulate::
|
|
11869 * Keep::
|
|
11870 @end menu
|
|
11871
|
|
11872 @node Every, Accumulate, Recursive Patterns, Recursive Patterns
|
|
11873 @comment node-name, next, previous, up
|
|
11874 @unnumberedsubsubsec Recursive Pattern: @emph{every}
|
|
11875 @cindex Every, type of recursive pattern
|
|
11876 @cindex Recursive pattern: every
|
|
11877
|
|
11878 In the @code{every} recursive pattern, an action is performed on every
|
|
11879 element of a list.
|
|
11880
|
|
11881 @need 1500
|
|
11882 The basic pattern is:
|
|
11883
|
|
11884 @itemize @bullet
|
|
11885 @item
|
|
11886 If a list be empty, return @code{nil}.
|
|
11887 @item
|
|
11888 Else, act on the beginning of the list (the @sc{car} of the list)
|
|
11889 @itemize @minus
|
|
11890 @item
|
|
11891 through a recursive call by the function on the rest (the
|
|
11892 @sc{cdr}) of the list,
|
|
11893 @item
|
|
11894 and, optionally, combine the acted-on element, using @code{cons},
|
|
11895 with the results of acting on the rest.
|
|
11896 @end itemize
|
|
11897 @end itemize
|
|
11898
|
|
11899 @need 1500
|
|
11900 Here is example:
|
|
11901
|
|
11902 @smallexample
|
|
11903 @group
|
|
11904 (defun square-each (numbers-list)
|
|
11905 "Square each of a NUMBERS LIST, recursively."
|
|
11906 (if (not numbers-list) ; do-again-test
|
|
11907 nil
|
|
11908 (cons
|
|
11909 (* (car numbers-list) (car numbers-list))
|
|
11910 (square-each (cdr numbers-list))))) ; next-step-expression
|
|
11911 @end group
|
|
11912
|
|
11913 @group
|
|
11914 (square-each '(1 2 3))
|
|
11915 @result{} (1 4 9)
|
|
11916 @end group
|
|
11917 @end smallexample
|
|
11918
|
|
11919 @need 1200
|
|
11920 @noindent
|
|
11921 If @code{numbers-list} is empty, do nothing. But if it has content,
|
|
11922 construct a list combining the square of the first number in the list
|
|
11923 with the result of the recursive call.
|
|
11924
|
|
11925 (The example follows the pattern exactly: @code{nil} is returned if
|
|
11926 the numbers' list is empty. In practice, you would write the
|
|
11927 conditional so it carries out the action when the numbers' list is not
|
|
11928 empty.)
|
|
11929
|
|
11930 The @code{print-elements-recursively} function (@pxref{Recursion with
|
|
11931 list, , Recursion with a List}) is another example of an @code{every}
|
|
11932 pattern, except in this case, rather than bring the results together
|
|
11933 using @code{cons}, we print each element of output.
|
|
11934
|
|
11935 @need 1250
|
|
11936 The @code{print-elements-recursively} function looks like this:
|
|
11937
|
|
11938 @smallexample
|
|
11939 @group
|
|
11940 (setq animals '(gazelle giraffe lion tiger))
|
|
11941 @end group
|
|
11942
|
|
11943 @group
|
|
11944 (defun print-elements-recursively (list)
|
|
11945 "Print each element of LIST on a line of its own.
|
|
11946 Uses recursion."
|
|
11947 (when list ; @r{do-again-test}
|
|
11948 (print (car list)) ; @r{body}
|
|
11949 (print-elements-recursively ; @r{recursive call}
|
|
11950 (cdr list)))) ; @r{next-step-expression}
|
|
11951
|
|
11952 (print-elements-recursively animals)
|
|
11953 @end group
|
|
11954 @end smallexample
|
|
11955
|
|
11956 @need 1500
|
|
11957 The pattern for @code{print-elements-recursively} is:
|
|
11958
|
|
11959 @itemize @bullet
|
|
11960 @item
|
|
11961 When the list is empty, do nothing.
|
|
11962 @item
|
|
11963 But when the list has at least one element,
|
|
11964 @itemize @minus
|
|
11965 @item
|
|
11966 act on the beginning of the list (the @sc{car} of the list),
|
|
11967 @item
|
|
11968 and make a recursive call on the rest (the @sc{cdr}) of the list.
|
|
11969 @end itemize
|
|
11970 @end itemize
|
|
11971
|
|
11972 @node Accumulate, Keep, Every, Recursive Patterns
|
|
11973 @comment node-name, next, previous, up
|
|
11974 @unnumberedsubsubsec Recursive Pattern: @emph{accumulate}
|
|
11975 @cindex Accumulate, type of recursive pattern
|
|
11976 @cindex Recursive pattern: accumulate
|
|
11977
|
|
11978 Another recursive pattern is called the @code{accumulate} pattern. In
|
|
11979 the @code{accumulate} recursive pattern, an action is performed on
|
|
11980 every element of a list and the result of that action is accumulated
|
|
11981 with the results of performing the action on the other elements.
|
|
11982
|
|
11983 This is very like the `every' pattern using @code{cons}, except that
|
|
11984 @code{cons} is not used, but some other combiner.
|
|
11985
|
|
11986 @need 1500
|
|
11987 The pattern is:
|
|
11988
|
|
11989 @itemize @bullet
|
|
11990 @item
|
|
11991 If a list be empty, return zero or some other constant.
|
|
11992 @item
|
|
11993 Else, act on the beginning of the list (the @sc{car} of the list),
|
|
11994 @itemize @minus
|
|
11995 @item
|
|
11996 and combine that acted-on element, using @code{+} or
|
|
11997 some other combining function, with
|
|
11998 @item
|
|
11999 a recursive call by the function on the rest (the @sc{cdr}) of the list.
|
|
12000 @end itemize
|
|
12001 @end itemize
|
|
12002
|
|
12003 @need 1500
|
|
12004 Here is an example:
|
|
12005
|
|
12006 @smallexample
|
|
12007 @group
|
|
12008 (defun add-elements (numbers-list)
|
|
12009 "Add the elements of NUMBERS-LIST together."
|
|
12010 (if (not numbers-list)
|
|
12011 0
|
|
12012 (+ (car numbers-list) (add-elements (cdr numbers-list)))))
|
|
12013 @end group
|
|
12014
|
|
12015 @group
|
|
12016 (add-elements '(1 2 3 4))
|
|
12017 @result{} 10
|
|
12018 @end group
|
|
12019 @end smallexample
|
|
12020
|
|
12021 @xref{Files List, , Making a List of Files}, for an example of the
|
|
12022 accumulate pattern.
|
|
12023
|
|
12024 @node Keep, , Accumulate, Recursive Patterns
|
|
12025 @comment node-name, next, previous, up
|
|
12026 @unnumberedsubsubsec Recursive Pattern: @emph{keep}
|
|
12027 @cindex Keep, type of recursive pattern
|
|
12028 @cindex Recursive pattern: keep
|
|
12029
|
|
12030 A third recursive pattern is called the @code{keep} pattern.
|
|
12031 In the @code{keep} recursive pattern, each element of a list is tested;
|
|
12032 the element is acted on and the results are kept only if the element
|
|
12033 meets a criterion.
|
|
12034
|
|
12035 Again, this is very like the `every' pattern, except the element is
|
|
12036 skipped unless it meets a criterion.
|
|
12037
|
|
12038 @need 1500
|
|
12039 The pattern has three parts:
|
|
12040
|
|
12041 @itemize @bullet
|
|
12042 @item
|
|
12043 If a list be empty, return @code{nil}.
|
|
12044 @item
|
|
12045 Else, if the beginning of the list (the @sc{car} of the list) passes
|
|
12046 a test
|
|
12047 @itemize @minus
|
|
12048 @item
|
|
12049 act on that element and combine it, using @code{cons} with
|
|
12050 @item
|
|
12051 a recursive call by the function on the rest (the @sc{cdr}) of the list.
|
|
12052 @end itemize
|
|
12053 @item
|
|
12054 Otherwise, if the beginning of the list (the @sc{car} of the list) fails
|
|
12055 the test
|
|
12056 @itemize @minus
|
|
12057 @item
|
|
12058 skip on that element,
|
|
12059 @item
|
|
12060 and, recursively call the function on the rest (the @sc{cdr}) of the list.
|
|
12061 @end itemize
|
|
12062 @end itemize
|
|
12063
|
|
12064 @need 1500
|
|
12065 Here is an example that uses @code{cond}:
|
|
12066
|
|
12067 @smallexample
|
|
12068 @group
|
|
12069 (defun keep-three-letter-words (word-list)
|
|
12070 "Keep three letter words in WORD-LIST."
|
|
12071 (cond
|
|
12072 ;; First do-again-test: stop-condition
|
|
12073 ((not word-list) nil)
|
|
12074
|
|
12075 ;; Second do-again-test: when to act
|
|
12076 ((eq 3 (length (symbol-name (car word-list))))
|
|
12077 ;; combine acted-on element with recursive call on shorter list
|
|
12078 (cons (car word-list) (keep-three-letter-words (cdr word-list))))
|
|
12079
|
|
12080 ;; Third do-again-test: when to skip element;
|
|
12081 ;; recursively call shorter list with next-step expression
|
|
12082 (t (keep-three-letter-words (cdr word-list)))))
|
|
12083 @end group
|
|
12084
|
|
12085 @group
|
|
12086 (keep-three-letter-words '(one two three four five six))
|
|
12087 @result{} (one two six)
|
|
12088 @end group
|
|
12089 @end smallexample
|
|
12090
|
|
12091 It goes without saying that you need not use @code{nil} as the test for
|
|
12092 when to stop; and you can, of course, combine these patterns.
|
|
12093
|
|
12094 @node No Deferment, No deferment solution, Recursive Patterns, Recursion
|
|
12095 @subsection Recursion without Deferments
|
|
12096 @cindex Deferment in recursion
|
|
12097 @cindex Recursion without Deferments
|
|
12098
|
|
12099 Let's consider again what happens with the @code{triangle-recursively}
|
|
12100 function. We will find that the intermediate calculations are
|
|
12101 deferred until all can be done.
|
|
12102
|
|
12103 @need 800
|
|
12104 Here is the function definition:
|
|
12105
|
|
12106 @smallexample
|
|
12107 @group
|
|
12108 (defun triangle-recursively (number)
|
|
12109 "Return the sum of the numbers 1 through NUMBER inclusive.
|
|
12110 Uses recursion."
|
|
12111 (if (= number 1) ; @r{do-again-test}
|
|
12112 1 ; @r{then-part}
|
|
12113 (+ number ; @r{else-part}
|
|
12114 (triangle-recursively ; @r{recursive call}
|
|
12115 (1- number))))) ; @r{next-step-expression}
|
|
12116 @end group
|
|
12117 @end smallexample
|
|
12118
|
|
12119 What happens when we call this function with a argument of 7?
|
|
12120
|
|
12121 The first instance of the @code{triangle-recursively} function adds
|
|
12122 the number 7 to the value returned by a second instance of
|
|
12123 @code{triangle-recursively}, an instance that has been passed an
|
|
12124 argument of 6. That is to say, the first calculation is:
|
|
12125
|
|
12126 @smallexample
|
|
12127 (+ 7 (triangle-recursively 6))
|
|
12128 @end smallexample
|
|
12129
|
|
12130 @noindent
|
|
12131 The first instance of @code{triangle-recursively}---you may want to
|
|
12132 think of it as a little robot---cannot complete its job. It must hand
|
|
12133 off the calculation for @code{(triangle-recursively 6)} to a second
|
|
12134 instance of the program, to a second robot. This second individual is
|
|
12135 completely different from the first one; it is, in the jargon, a
|
|
12136 `different instantiation'. Or, put another way, it is a different
|
|
12137 robot. It is the same model as the first; it calculates triangle
|
|
12138 numbers recursively; but it has a different serial number.
|
|
12139
|
|
12140 And what does @code{(triangle-recursively 6)} return? It returns the
|
|
12141 number 6 added to the value returned by evaluating
|
|
12142 @code{triangle-recursively} with an argument of 5. Using the robot
|
|
12143 metaphor, it asks yet another robot to help it.
|
|
12144
|
|
12145 @need 800
|
|
12146 Now the total is:
|
|
12147
|
|
12148 @smallexample
|
|
12149 (+ 7 6 (triangle-recursively 5))
|
|
12150 @end smallexample
|
|
12151
|
|
12152 @need 800
|
|
12153 And what happens next?
|
|
12154
|
|
12155 @smallexample
|
|
12156 (+ 7 6 5 (triangle-recursively 4))
|
|
12157 @end smallexample
|
|
12158
|
|
12159 Each time @code{triangle-recursively} is called, except for the last
|
|
12160 time, it creates another instance of the program---another robot---and
|
|
12161 asks it to make a calculation.
|
|
12162
|
|
12163 @need 800
|
|
12164 Eventually, the full addition is set up and performed:
|
|
12165
|
|
12166 @smallexample
|
|
12167 (+ 7 6 5 4 3 2 1)
|
|
12168 @end smallexample
|
|
12169
|
|
12170 This design for the function defers the calculation of the first step
|
|
12171 until the second can be done, and defers that until the third can be
|
|
12172 done, and so on. Each deferment means the computer must remember what
|
|
12173 is being waited on. This is not a problem when there are only a few
|
|
12174 steps, as in this example. But it can be a problem when there are
|
|
12175 more steps.
|
|
12176
|
|
12177 @node No deferment solution, , No Deferment, Recursion
|
|
12178 @subsection No Deferment Solution
|
|
12179 @cindex No deferment solution
|
|
12180 @cindex Defermentless solution
|
|
12181 @cindex Solution without deferment
|
|
12182
|
|
12183 The solution to the problem of deferred operations is to write in a
|
|
12184 manner that does not defer operations@footnote{The phrase @dfn{tail
|
|
12185 recursive} is used to describe such a process, one that uses
|
|
12186 `constant space'.}. This requires
|
|
12187 writing to a different pattern, often one that involves writing two
|
|
12188 function definitions, an `initialization' function and a `helper'
|
|
12189 function.
|
|
12190
|
|
12191 The `initialization' function sets up the job; the `helper' function
|
|
12192 does the work.
|
|
12193
|
|
12194 @need 1200
|
|
12195 Here are the two function definitions for adding up numbers. They are
|
|
12196 so simple, I find them hard to understand.
|
|
12197
|
|
12198 @smallexample
|
|
12199 @group
|
|
12200 (defun triangle-initialization (number)
|
|
12201 "Return the sum of the numbers 1 through NUMBER inclusive.
|
|
12202 This is the `initialization' component of a two function
|
|
12203 duo that uses recursion."
|
|
12204 (triangle-recursive-helper 0 0 number))
|
|
12205 @end group
|
|
12206 @end smallexample
|
|
12207
|
|
12208 @smallexample
|
|
12209 @group
|
|
12210 (defun triangle-recursive-helper (sum counter number)
|
|
12211 "Return SUM, using COUNTER, through NUMBER inclusive.
|
|
12212 This is the `helper' component of a two function duo
|
|
12213 that uses recursion."
|
|
12214 (if (> counter number)
|
|
12215 sum
|
|
12216 (triangle-recursive-helper (+ sum counter) ; @r{sum}
|
|
12217 (1+ counter) ; @r{counter}
|
|
12218 number))) ; @r{number}
|
|
12219 @end group
|
|
12220 @end smallexample
|
|
12221
|
|
12222 @need 1250
|
|
12223 Install both function definitions by evaluating them, then call
|
|
12224 @code{triangle-initialization} with 2 rows:
|
|
12225
|
|
12226 @smallexample
|
|
12227 @group
|
|
12228 (triangle-initialization 2)
|
|
12229 @result{} 3
|
|
12230 @end group
|
|
12231 @end smallexample
|
|
12232
|
|
12233 The `initialization' function calls the first instance of the `helper'
|
|
12234 function with three arguments: zero, zero, and a number which is the
|
|
12235 number of rows in the triangle.
|
|
12236
|
|
12237 The first two arguments passed to the `helper' function are
|
|
12238 initialization values. These values are changed when
|
|
12239 @code{triangle-recursive-helper} invokes new instances.@footnote{The
|
|
12240 jargon is mildly confusing: @code{triangle-recursive-helper} uses a
|
|
12241 process that is iterative in a procedure that is recursive. The
|
|
12242 process is called iterative because the computer need only record the
|
|
12243 three values, @code{sum}, @code{counter}, and @code{number}; the
|
|
12244 procedure is recursive because the function `calls itself'. On the
|
|
12245 other hand, both the process and the procedure used by
|
|
12246 @code{triangle-recursively} are called recursive. The word
|
|
12247 `recursive' has different meanings in the two contexts.}
|
|
12248
|
|
12249 Let's see what happens when we have a triangle that has one row. (This
|
|
12250 triangle will have one pebble in it!)
|
|
12251
|
|
12252 @need 1200
|
|
12253 @code{triangle-initialization} will call its helper with
|
|
12254 the arguments @w{@code{0 0 1}}. That function will run the conditional
|
|
12255 test whether @code{(> counter number)}:
|
|
12256
|
|
12257 @smallexample
|
|
12258 (> 0 1)
|
|
12259 @end smallexample
|
|
12260
|
|
12261 @need 1200
|
|
12262 @noindent
|
|
12263 and find that the result is false, so it will invoke
|
|
12264 the else-part of the @code{if} clause:
|
|
12265
|
|
12266 @smallexample
|
|
12267 @group
|
|
12268 (triangle-recursive-helper
|
|
12269 (+ sum counter) ; @r{sum plus counter} @result{} @r{sum}
|
|
12270 (1+ counter) ; @r{increment counter} @result{} @r{counter}
|
|
12271 number) ; @r{number stays the same}
|
|
12272 @end group
|
|
12273 @end smallexample
|
|
12274
|
|
12275 @need 800
|
|
12276 @noindent
|
|
12277 which will first compute:
|
|
12278
|
|
12279 @smallexample
|
|
12280 @group
|
|
12281 (triangle-recursive-helper (+ 0 0) ; @r{sum}
|
|
12282 (1+ 0) ; @r{counter}
|
|
12283 1) ; @r{number}
|
|
12284 @exdent which is:
|
|
12285
|
|
12286 (triangle-recursive-helper 0 1 1)
|
|
12287 @end group
|
|
12288 @end smallexample
|
|
12289
|
|
12290 Again, @code{(> counter number)} will be false, so again, the Lisp
|
|
12291 interpreter will evaluate @code{triangle-recursive-helper}, creating a
|
|
12292 new instance with new arguments.
|
|
12293
|
|
12294 @need 800
|
|
12295 This new instance will be;
|
|
12296
|
|
12297 @smallexample
|
|
12298 @group
|
|
12299 (triangle-recursive-helper
|
|
12300 (+ sum counter) ; @r{sum plus counter} @result{} @r{sum}
|
|
12301 (1+ counter) ; @r{increment counter} @result{} @r{counter}
|
|
12302 number) ; @r{number stays the same}
|
|
12303
|
|
12304 @exdent which is:
|
|
12305
|
|
12306 (triangle-recursive-helper 1 2 1)
|
|
12307 @end group
|
|
12308 @end smallexample
|
|
12309
|
|
12310 In this case, the @code{(> counter number)} test will be true! So the
|
|
12311 instance will return the value of the sum, which will be 1, as
|
|
12312 expected.
|
|
12313
|
|
12314 Now, let's pass @code{triangle-initialization} an argument
|
|
12315 of 2, to find out how many pebbles there are in a triangle with two rows.
|
|
12316
|
|
12317 That function calls @code{(triangle-recursive-helper 0 0 2)}.
|
|
12318
|
|
12319 @need 800
|
|
12320 In stages, the instances called will be:
|
|
12321
|
|
12322 @smallexample
|
|
12323 @group
|
|
12324 @r{sum counter number}
|
|
12325 (triangle-recursive-helper 0 1 2)
|
|
12326
|
|
12327 (triangle-recursive-helper 1 2 2)
|
|
12328
|
|
12329 (triangle-recursive-helper 3 3 2)
|
|
12330 @end group
|
|
12331 @end smallexample
|
|
12332
|
|
12333 When the last instance is called, the @code{(> counter number)} test
|
|
12334 will be true, so the instance will return the value of @code{sum},
|
|
12335 which will be 3.
|
|
12336
|
|
12337 This kind of pattern helps when you are writing functions that can use
|
|
12338 many resources in a computer.
|
|
12339
|
|
12340 @need 1500
|
|
12341 @node Looping exercise, , Recursion, Loops & Recursion
|
|
12342 @section Looping Exercise
|
|
12343
|
|
12344 @itemize @bullet
|
|
12345 @item
|
|
12346 Write a function similar to @code{triangle} in which each row has a
|
|
12347 value which is the square of the row number. Use a @code{while} loop.
|
|
12348
|
|
12349 @item
|
|
12350 Write a function similar to @code{triangle} that multiplies instead of
|
|
12351 adds the values.
|
|
12352
|
|
12353 @item
|
|
12354 Rewrite these two functions recursively. Rewrite these functions
|
|
12355 using @code{cond}.
|
|
12356
|
|
12357 @c comma in printed title causes problem in Info cross reference
|
|
12358 @item
|
|
12359 Write a function for Texinfo mode that creates an index entry at the
|
|
12360 beginning of a paragraph for every @samp{@@dfn} within the paragraph.
|
|
12361 (In a Texinfo file, @samp{@@dfn} marks a definition. This book is
|
|
12362 written in Texinfo.)
|
|
12363
|
|
12364 Many of the functions you will need are described in two of the
|
|
12365 previous chapters, @ref{Cutting & Storing Text, , Cutting and Storing
|
|
12366 Text}, and @ref{Yanking, , Yanking Text Back}. If you use
|
|
12367 @code{forward-paragraph} to put the index entry at the beginning of
|
|
12368 the paragraph, you will have to use @w{@kbd{C-h f}}
|
|
12369 (@code{describe-function}) to find out how to make the command go
|
|
12370 backwards.
|
|
12371
|
|
12372 For more information, see
|
|
12373 @ifinfo
|
|
12374 @ref{Indicating, , Indicating Definitions, texinfo}.
|
|
12375 @end ifinfo
|
|
12376 @ifhtml
|
|
12377 @ref{Indicating, , Indicating, texinfo, Texinfo Manual}, which goes to
|
|
12378 a Texinfo manual in the current directory. Or, if you are on the
|
|
12379 Internet, see
|
|
12380 @uref{http://www.gnu.org/software/texinfo/manual/texinfo/}
|
|
12381 @end ifhtml
|
|
12382 @iftex
|
|
12383 ``Indicating Definitions, Commands, etc.'' in @cite{Texinfo, The GNU
|
|
12384 Documentation Format}.
|
|
12385 @end iftex
|
|
12386 @end itemize
|
|
12387
|
|
12388 @node Regexp Search, Counting Words, Loops & Recursion, Top
|
|
12389 @comment node-name, next, previous, up
|
|
12390 @chapter Regular Expression Searches
|
|
12391 @cindex Searches, illustrating
|
|
12392 @cindex Regular expression searches
|
|
12393 @cindex Patterns, searching for
|
|
12394 @cindex Motion by sentence and paragraph
|
|
12395 @cindex Sentences, movement by
|
|
12396 @cindex Paragraphs, movement by
|
|
12397
|
|
12398 Regular expression searches are used extensively in GNU Emacs. The
|
|
12399 two functions, @code{forward-sentence} and @code{forward-paragraph},
|
|
12400 illustrate these searches well. They use regular expressions to find
|
|
12401 where to move point. The phrase `regular expression' is often written
|
|
12402 as `regexp'.
|
|
12403
|
|
12404 Regular expression searches are described in @ref{Regexp Search, ,
|
|
12405 Regular Expression Search, emacs, The GNU Emacs Manual}, as well as in
|
|
12406 @ref{Regular Expressions, , , elisp, The GNU Emacs Lisp Reference
|
|
12407 Manual}. In writing this chapter, I am presuming that you have at
|
|
12408 least a mild acquaintance with them. The major point to remember is
|
|
12409 that regular expressions permit you to search for patterns as well as
|
|
12410 for literal strings of characters. For example, the code in
|
|
12411 @code{forward-sentence} searches for the pattern of possible
|
|
12412 characters that could mark the end of a sentence, and moves point to
|
|
12413 that spot.
|
|
12414
|
|
12415 Before looking at the code for the @code{forward-sentence} function, it
|
|
12416 is worth considering what the pattern that marks the end of a sentence
|
|
12417 must be. The pattern is discussed in the next section; following that
|
|
12418 is a description of the regular expression search function,
|
|
12419 @code{re-search-forward}. The @code{forward-sentence} function
|
|
12420 is described in the section following. Finally, the
|
|
12421 @code{forward-paragraph} function is described in the last section of
|
|
12422 this chapter. @code{forward-paragraph} is a complex function that
|
|
12423 introduces several new features.
|
|
12424
|
|
12425 @menu
|
|
12426 * sentence-end:: The regular expression for @code{sentence-end}.
|
|
12427 * re-search-forward:: Very similar to @code{search-forward}.
|
|
12428 * forward-sentence:: A straightforward example of regexp search.
|
|
12429 * forward-paragraph:: A somewhat complex example.
|
|
12430 * etags:: How to create your own @file{TAGS} table.
|
|
12431 * Regexp Review::
|
|
12432 * re-search Exercises::
|
|
12433 @end menu
|
|
12434
|
|
12435 @node sentence-end, re-search-forward, Regexp Search, Regexp Search
|
|
12436 @comment node-name, next, previous, up
|
|
12437 @section The Regular Expression for @code{sentence-end}
|
|
12438 @findex sentence-end
|
|
12439
|
|
12440 The symbol @code{sentence-end} is bound to the pattern that marks the
|
|
12441 end of a sentence. What should this regular expression be?
|
|
12442
|
|
12443 Clearly, a sentence may be ended by a period, a question mark, or an
|
|
12444 exclamation mark. Indeed, in English, only clauses that end with one
|
|
12445 of those three characters should be considered the end of a sentence.
|
|
12446 This means that the pattern should include the character set:
|
|
12447
|
|
12448 @smallexample
|
|
12449 [.?!]
|
|
12450 @end smallexample
|
|
12451
|
|
12452 However, we do not want @code{forward-sentence} merely to jump to a
|
|
12453 period, a question mark, or an exclamation mark, because such a character
|
|
12454 might be used in the middle of a sentence. A period, for example, is
|
|
12455 used after abbreviations. So other information is needed.
|
|
12456
|
|
12457 According to convention, you type two spaces after every sentence, but
|
|
12458 only one space after a period, a question mark, or an exclamation mark in
|
|
12459 the body of a sentence. So a period, a question mark, or an exclamation
|
|
12460 mark followed by two spaces is a good indicator of an end of sentence.
|
|
12461 However, in a file, the two spaces may instead be a tab or the end of a
|
|
12462 line. This means that the regular expression should include these three
|
|
12463 items as alternatives.
|
|
12464
|
|
12465 @need 800
|
|
12466 This group of alternatives will look like this:
|
|
12467
|
|
12468 @smallexample
|
|
12469 @group
|
|
12470 \\($\\| \\| \\)
|
|
12471 ^ ^^
|
|
12472 TAB SPC
|
|
12473 @end group
|
|
12474 @end smallexample
|
|
12475
|
|
12476 @noindent
|
|
12477 Here, @samp{$} indicates the end of the line, and I have pointed out
|
|
12478 where the tab and two spaces are inserted in the expression. Both are
|
|
12479 inserted by putting the actual characters into the expression.
|
|
12480
|
|
12481 Two backslashes, @samp{\\}, are required before the parentheses and
|
|
12482 vertical bars: the first backslash quotes the following backslash in
|
|
12483 Emacs; and the second indicates that the following character, the
|
|
12484 parenthesis or the vertical bar, is special.
|
|
12485
|
|
12486 @need 1000
|
|
12487 Also, a sentence may be followed by one or more carriage returns, like
|
|
12488 this:
|
|
12489
|
|
12490 @smallexample
|
|
12491 @group
|
|
12492 [
|
|
12493 ]*
|
|
12494 @end group
|
|
12495 @end smallexample
|
|
12496
|
|
12497 @noindent
|
|
12498 Like tabs and spaces, a carriage return is inserted into a regular
|
|
12499 expression by inserting it literally. The asterisk indicates that the
|
|
12500 @key{RET} is repeated zero or more times.
|
|
12501
|
|
12502 But a sentence end does not consist only of a period, a question mark or
|
|
12503 an exclamation mark followed by appropriate space: a closing quotation
|
|
12504 mark or a closing brace of some kind may precede the space. Indeed more
|
|
12505 than one such mark or brace may precede the space. These require a
|
|
12506 expression that looks like this:
|
|
12507
|
|
12508 @smallexample
|
|
12509 []\"')@}]*
|
|
12510 @end smallexample
|
|
12511
|
|
12512 In this expression, the first @samp{]} is the first character in the
|
|
12513 expression; the second character is @samp{"}, which is preceded by a
|
|
12514 @samp{\} to tell Emacs the @samp{"} is @emph{not} special. The last
|
|
12515 three characters are @samp{'}, @samp{)}, and @samp{@}}.
|
|
12516
|
|
12517 All this suggests what the regular expression pattern for matching the
|
|
12518 end of a sentence should be; and, indeed, if we evaluate
|
|
12519 @code{sentence-end} we find that it returns the following value:
|
|
12520
|
|
12521 @smallexample
|
|
12522 @group
|
|
12523 sentence-end
|
|
12524 @result{} "[.?!][]\"')@}]*\\($\\| \\| \\)[
|
|
12525 ]*"
|
|
12526 @end group
|
|
12527 @end smallexample
|
|
12528
|
|
12529 @noindent
|
|
12530 (Well, not in GNU Emacs 22; that is because of an effort to make the
|
|
12531 process simpler and to handle more glyphs and languages. When the
|
|
12532 value of @code{sentence-end} is @code{nil}, then use the value defined
|
|
12533 by the function @code{sentence-end}. (Here is a use of the difference
|
|
12534 between a value and a function in Emacs Lisp.) The function returns a
|
|
12535 value constructed from the variables @code{sentence-end-base},
|
|
12536 @code{sentence-end-double-space}, @code{sentence-end-without-period},
|
|
12537 and @code{sentence-end-without-space}. The critical variable is
|
|
12538 @code{sentence-end-base}; its global value is similar to the one
|
|
12539 described above but it also contains two additional quotation marks.
|
|
12540 These have differing degrees of curliness. The
|
|
12541 @code{sentence-end-without-period} variable, when true, tells Emacs
|
|
12542 that a sentence may end without a period, such as text in Thai.)
|
|
12543
|
|
12544 @ignore
|
|
12545 @noindent
|
|
12546 (Note that here the @key{TAB}, two spaces, and @key{RET} are shown
|
|
12547 literally in the pattern.)
|
|
12548
|
|
12549 This regular expression can be deciphered as follows:
|
|
12550
|
|
12551 @table @code
|
|
12552 @item [.?!]
|
|
12553 The first part of the pattern is the three characters, a period, a question
|
|
12554 mark and an exclamation mark, within square brackets. The pattern must
|
|
12555 begin with one or other of these characters.
|
|
12556
|
|
12557 @item []\"')@}]*
|
|
12558 The second part of the pattern is the group of closing braces and
|
|
12559 quotation marks, which can appear zero or more times. These may follow
|
|
12560 the period, question mark or exclamation mark. In a regular expression,
|
|
12561 the backslash, @samp{\}, followed by the double quotation mark,
|
|
12562 @samp{"}, indicates the class of string-quote characters. Usually, the
|
|
12563 double quotation mark is the only character in this class. The
|
|
12564 asterisk, @samp{*}, indicates that the items in the previous group (the
|
|
12565 group surrounded by square brackets, @samp{[]}) may be repeated zero or
|
|
12566 more times.
|
|
12567
|
|
12568 @item \\($\\| \\| \\)
|
|
12569 The third part of the pattern is one or other of: either the end of a
|
|
12570 line, or two blank spaces, or a tab. The double back-slashes are used
|
|
12571 to prevent Emacs from reading the parentheses and vertical bars as part
|
|
12572 of the search pattern; the parentheses are used to mark the group and
|
|
12573 the vertical bars are used to indicated that the patterns to either side
|
|
12574 of them are alternatives. The dollar sign is used to indicate the end
|
|
12575 of a line and both the two spaces and the tab are each inserted as is to
|
|
12576 indicate what they are.
|
|
12577
|
|
12578 @item [@key{RET}]*
|
|
12579 Finally, the last part of the pattern indicates that the end of the line
|
|
12580 or the whitespace following the period, question mark or exclamation
|
|
12581 mark may, but need not, be followed by one or more carriage returns. In
|
|
12582 the pattern, the carriage return is inserted as an actual carriage
|
|
12583 return between square brackets but here it is shown as @key{RET}.
|
|
12584 @end table
|
|
12585 @end ignore
|
|
12586
|
|
12587 @node re-search-forward, forward-sentence, sentence-end, Regexp Search
|
|
12588 @comment node-name, next, previous, up
|
|
12589 @section The @code{re-search-forward} Function
|
|
12590 @findex re-search-forward
|
|
12591
|
|
12592 The @code{re-search-forward} function is very like the
|
|
12593 @code{search-forward} function. (@xref{search-forward, , The
|
|
12594 @code{search-forward} Function}.)
|
|
12595
|
|
12596 @code{re-search-forward} searches for a regular expression. If the
|
|
12597 search is successful, it leaves point immediately after the last
|
|
12598 character in the target. If the search is backwards, it leaves point
|
|
12599 just before the first character in the target. You may tell
|
|
12600 @code{re-search-forward} to return @code{t} for true. (Moving point
|
|
12601 is therefore a `side effect'.)
|
|
12602
|
|
12603 Like @code{search-forward}, the @code{re-search-forward} function takes
|
|
12604 four arguments:
|
|
12605
|
|
12606 @enumerate
|
|
12607 @item
|
|
12608 The first argument is the regular expression that the function searches
|
|
12609 for. The regular expression will be a string between quotations marks.
|
|
12610
|
|
12611 @item
|
|
12612 The optional second argument limits how far the function will search; it is a
|
|
12613 bound, which is specified as a position in the buffer.
|
|
12614
|
|
12615 @item
|
|
12616 The optional third argument specifies how the function responds to
|
|
12617 failure: @code{nil} as the third argument causes the function to
|
|
12618 signal an error (and print a message) when the search fails; any other
|
|
12619 value causes it to return @code{nil} if the search fails and @code{t}
|
|
12620 if the search succeeds.
|
|
12621
|
|
12622 @item
|
|
12623 The optional fourth argument is the repeat count. A negative repeat
|
|
12624 count causes @code{re-search-forward} to search backwards.
|
|
12625 @end enumerate
|
|
12626
|
|
12627 @need 800
|
|
12628 The template for @code{re-search-forward} looks like this:
|
|
12629
|
|
12630 @smallexample
|
|
12631 @group
|
|
12632 (re-search-forward "@var{regular-expression}"
|
|
12633 @var{limit-of-search}
|
|
12634 @var{what-to-do-if-search-fails}
|
|
12635 @var{repeat-count})
|
|
12636 @end group
|
|
12637 @end smallexample
|
|
12638
|
|
12639 The second, third, and fourth arguments are optional. However, if you
|
|
12640 want to pass a value to either or both of the last two arguments, you
|
|
12641 must also pass a value to all the preceding arguments. Otherwise, the
|
|
12642 Lisp interpreter will mistake which argument you are passing the value
|
|
12643 to.
|
|
12644
|
|
12645 @need 1200
|
|
12646 In the @code{forward-sentence} function, the regular expression will be
|
|
12647 the value of the variable @code{sentence-end}. In simple form, that is:
|
|
12648
|
|
12649 @smallexample
|
|
12650 @group
|
|
12651 "[.?!][]\"')@}]*\\($\\| \\| \\)[
|
|
12652 ]*"
|
|
12653 @end group
|
|
12654 @end smallexample
|
|
12655
|
|
12656 @noindent
|
|
12657 The limit of the search will be the end of the paragraph (since a
|
|
12658 sentence cannot go beyond a paragraph). If the search fails, the
|
|
12659 function will return @code{nil}; and the repeat count will be provided
|
|
12660 by the argument to the @code{forward-sentence} function.
|
|
12661
|
|
12662 @node forward-sentence, forward-paragraph, re-search-forward, Regexp Search
|
|
12663 @comment node-name, next, previous, up
|
|
12664 @section @code{forward-sentence}
|
|
12665 @findex forward-sentence
|
|
12666
|
|
12667 The command to move the cursor forward a sentence is a straightforward
|
|
12668 illustration of how to use regular expression searches in Emacs Lisp.
|
|
12669 Indeed, the function looks longer and more complicated than it is; this
|
|
12670 is because the function is designed to go backwards as well as forwards;
|
|
12671 and, optionally, over more than one sentence. The function is usually
|
|
12672 bound to the key command @kbd{M-e}.
|
|
12673
|
|
12674 @menu
|
|
12675 * Complete forward-sentence::
|
|
12676 * fwd-sentence while loops:: Two @code{while} loops.
|
|
12677 * fwd-sentence re-search:: A regular expression search.
|
|
12678 @end menu
|
|
12679
|
|
12680 @node Complete forward-sentence, fwd-sentence while loops, forward-sentence, forward-sentence
|
|
12681 @ifnottex
|
|
12682 @unnumberedsubsec Complete @code{forward-sentence} function definition
|
|
12683 @end ifnottex
|
|
12684
|
|
12685 @need 1250
|
|
12686 Here is the code for @code{forward-sentence}:
|
|
12687
|
|
12688 @c in GNU Emacs 22
|
|
12689 @smallexample
|
|
12690 @group
|
|
12691 (defun forward-sentence (&optional arg)
|
|
12692 "Move forward to next `sentence-end'. With argument, repeat.
|
|
12693 With negative argument, move backward repeatedly to `sentence-beginning'.
|
|
12694
|
|
12695 The variable `sentence-end' is a regular expression that matches ends of
|
|
12696 sentences. Also, every paragraph boundary terminates sentences as well."
|
|
12697 @end group
|
|
12698 @group
|
|
12699 (interactive "p")
|
|
12700 (or arg (setq arg 1))
|
|
12701 (let ((opoint (point))
|
|
12702 (sentence-end (sentence-end)))
|
|
12703 (while (< arg 0)
|
|
12704 (let ((pos (point))
|
|
12705 (par-beg (save-excursion (start-of-paragraph-text) (point))))
|
|
12706 (if (and (re-search-backward sentence-end par-beg t)
|
|
12707 (or (< (match-end 0) pos)
|
|
12708 (re-search-backward sentence-end par-beg t)))
|
|
12709 (goto-char (match-end 0))
|
|
12710 (goto-char par-beg)))
|
|
12711 (setq arg (1+ arg)))
|
|
12712 @end group
|
|
12713 @group
|
|
12714 (while (> arg 0)
|
|
12715 (let ((par-end (save-excursion (end-of-paragraph-text) (point))))
|
|
12716 (if (re-search-forward sentence-end par-end t)
|
|
12717 (skip-chars-backward " \t\n")
|
|
12718 (goto-char par-end)))
|
|
12719 (setq arg (1- arg)))
|
|
12720 (constrain-to-field nil opoint t)))
|
|
12721 @end group
|
|
12722 @end smallexample
|
|
12723
|
|
12724 @ignore
|
|
12725 GNU Emacs 21
|
|
12726 @smallexample
|
|
12727 @group
|
|
12728 (defun forward-sentence (&optional arg)
|
|
12729 "Move forward to next sentence-end. With argument, repeat.
|
|
12730 With negative argument, move backward repeatedly to sentence-beginning.
|
|
12731 Sentence ends are identified by the value of sentence-end
|
|
12732 treated as a regular expression. Also, every paragraph boundary
|
|
12733 terminates sentences as well."
|
|
12734 @end group
|
|
12735 @group
|
|
12736 (interactive "p")
|
|
12737 (or arg (setq arg 1))
|
|
12738 (while (< arg 0)
|
|
12739 (let ((par-beg
|
|
12740 (save-excursion (start-of-paragraph-text) (point))))
|
|
12741 (if (re-search-backward
|
|
12742 (concat sentence-end "[^ \t\n]") par-beg t)
|
|
12743 (goto-char (1- (match-end 0)))
|
|
12744 (goto-char par-beg)))
|
|
12745 (setq arg (1+ arg)))
|
|
12746 (while (> arg 0)
|
|
12747 (let ((par-end
|
|
12748 (save-excursion (end-of-paragraph-text) (point))))
|
|
12749 (if (re-search-forward sentence-end par-end t)
|
|
12750 (skip-chars-backward " \t\n")
|
|
12751 (goto-char par-end)))
|
|
12752 (setq arg (1- arg))))
|
|
12753 @end group
|
|
12754 @end smallexample
|
|
12755 @end ignore
|
|
12756
|
|
12757 The function looks long at first sight and it is best to look at its
|
|
12758 skeleton first, and then its muscle. The way to see the skeleton is to
|
|
12759 look at the expressions that start in the left-most columns:
|
|
12760
|
|
12761 @smallexample
|
|
12762 @group
|
|
12763 (defun forward-sentence (&optional arg)
|
|
12764 "@var{documentation}@dots{}"
|
|
12765 (interactive "p")
|
|
12766 (or arg (setq arg 1))
|
|
12767 (let ((opoint (point)) (sentence-end (sentence-end)))
|
|
12768 (while (< arg 0)
|
|
12769 (let ((pos (point))
|
|
12770 (par-beg (save-excursion (start-of-paragraph-text) (point))))
|
|
12771 @var{rest-of-body-of-while-loop-when-going-backwards}
|
|
12772 (while (> arg 0)
|
|
12773 (let ((par-end (save-excursion (end-of-paragraph-text) (point))))
|
|
12774 @var{rest-of-body-of-while-loop-when-going-forwards}
|
|
12775 @var{handle-forms-and-equivalent}
|
|
12776 @end group
|
|
12777 @end smallexample
|
|
12778
|
|
12779 This looks much simpler! The function definition consists of
|
|
12780 documentation, an @code{interactive} expression, an @code{or}
|
|
12781 expression, a @code{let} expression, and @code{while} loops.
|
|
12782
|
|
12783 Let's look at each of these parts in turn.
|
|
12784
|
|
12785 We note that the documentation is thorough and understandable.
|
|
12786
|
|
12787 The function has an @code{interactive "p"} declaration. This means
|
|
12788 that the processed prefix argument, if any, is passed to the
|
|
12789 function as its argument. (This will be a number.) If the function
|
|
12790 is not passed an argument (it is optional) then the argument
|
|
12791 @code{arg} will be bound to 1.
|
|
12792
|
|
12793 When @code{forward-sentence} is called non-interactively without an
|
|
12794 argument, @code{arg} is bound to @code{nil}. The @code{or} expression
|
|
12795 handles this. What it does is either leave the value of @code{arg} as
|
|
12796 it is, but only if @code{arg} is bound to a value; or it sets the
|
|
12797 value of @code{arg} to 1, in the case when @code{arg} is bound to
|
|
12798 @code{nil}.
|
|
12799
|
|
12800 Next is a @code{let}. That specifies the values of two local
|
|
12801 variables, @code{point} and @code{sentence-end}. The local value of
|
|
12802 point, from before the search, is used in the
|
|
12803 @code{constrain-to-field} function which handles forms and
|
|
12804 equivalents. The @code{sentence-end} variable is set by the
|
|
12805 @code{sentence-end} function.
|
|
12806
|
|
12807 @node fwd-sentence while loops, fwd-sentence re-search, Complete forward-sentence, forward-sentence
|
|
12808 @unnumberedsubsec The @code{while} loops
|
|
12809
|
|
12810 Two @code{while} loops follow. The first @code{while} has a
|
|
12811 true-or-false-test that tests true if the prefix argument for
|
|
12812 @code{forward-sentence} is a negative number. This is for going
|
|
12813 backwards. The body of this loop is similar to the body of the second
|
|
12814 @code{while} clause, but it is not exactly the same. We will skip
|
|
12815 this @code{while} loop and concentrate on the second @code{while}
|
|
12816 loop.
|
|
12817
|
|
12818 @need 1500
|
|
12819 The second @code{while} loop is for moving point forward. Its skeleton
|
|
12820 looks like this:
|
|
12821
|
|
12822 @smallexample
|
|
12823 @group
|
|
12824 (while (> arg 0) ; @r{true-or-false-test}
|
|
12825 (let @var{varlist}
|
|
12826 (if (@var{true-or-false-test})
|
|
12827 @var{then-part}
|
|
12828 @var{else-part}
|
|
12829 (setq arg (1- arg)))) ; @code{while} @r{loop decrementer}
|
|
12830 @end group
|
|
12831 @end smallexample
|
|
12832
|
|
12833 The @code{while} loop is of the decrementing kind.
|
|
12834 (@xref{Decrementing Loop, , A Loop with a Decrementing Counter}.) It
|
|
12835 has a true-or-false-test that tests true so long as the counter (in
|
|
12836 this case, the variable @code{arg}) is greater than zero; and it has a
|
|
12837 decrementer that subtracts 1 from the value of the counter every time
|
|
12838 the loop repeats.
|
|
12839
|
|
12840 If no prefix argument is given to @code{forward-sentence}, which is
|
|
12841 the most common way the command is used, this @code{while} loop will
|
|
12842 run once, since the value of @code{arg} will be 1.
|
|
12843
|
|
12844 The body of the @code{while} loop consists of a @code{let} expression,
|
|
12845 which creates and binds a local variable, and has, as its body, an
|
|
12846 @code{if} expression.
|
|
12847
|
|
12848 @need 1250
|
|
12849 The body of the @code{while} loop looks like this:
|
|
12850
|
|
12851 @smallexample
|
|
12852 @group
|
|
12853 (let ((par-end
|
|
12854 (save-excursion (end-of-paragraph-text) (point))))
|
|
12855 (if (re-search-forward sentence-end par-end t)
|
|
12856 (skip-chars-backward " \t\n")
|
|
12857 (goto-char par-end)))
|
|
12858 @end group
|
|
12859 @end smallexample
|
|
12860
|
|
12861 The @code{let} expression creates and binds the local variable
|
|
12862 @code{par-end}. As we shall see, this local variable is designed to
|
|
12863 provide a bound or limit to the regular expression search. If the
|
|
12864 search fails to find a proper sentence ending in the paragraph, it will
|
|
12865 stop on reaching the end of the paragraph.
|
|
12866
|
|
12867 But first, let us examine how @code{par-end} is bound to the value of
|
|
12868 the end of the paragraph. What happens is that the @code{let} sets the
|
|
12869 value of @code{par-end} to the value returned when the Lisp interpreter
|
|
12870 evaluates the expression
|
|
12871
|
|
12872 @smallexample
|
|
12873 @group
|
|
12874 (save-excursion (end-of-paragraph-text) (point))
|
|
12875 @end group
|
|
12876 @end smallexample
|
|
12877
|
|
12878 @noindent
|
|
12879 In this expression, @code{(end-of-paragraph-text)} moves point to the
|
|
12880 end of the paragraph, @code{(point)} returns the value of point, and then
|
|
12881 @code{save-excursion} restores point to its original position. Thus,
|
|
12882 the @code{let} binds @code{par-end} to the value returned by the
|
|
12883 @code{save-excursion} expression, which is the position of the end of
|
|
12884 the paragraph. (The @code{end-of-paragraph-text} function uses
|
|
12885 @code{forward-paragraph}, which we will discuss shortly.)
|
|
12886
|
|
12887 @need 1200
|
|
12888 Emacs next evaluates the body of the @code{let}, which is an @code{if}
|
|
12889 expression that looks like this:
|
|
12890
|
|
12891 @smallexample
|
|
12892 @group
|
|
12893 (if (re-search-forward sentence-end par-end t) ; @r{if-part}
|
|
12894 (skip-chars-backward " \t\n") ; @r{then-part}
|
|
12895 (goto-char par-end))) ; @r{else-part}
|
|
12896 @end group
|
|
12897 @end smallexample
|
|
12898
|
|
12899 The @code{if} tests whether its first argument is true and if so,
|
|
12900 evaluates its then-part; otherwise, the Emacs Lisp interpreter
|
|
12901 evaluates the else-part. The true-or-false-test of the @code{if}
|
|
12902 expression is the regular expression search.
|
|
12903
|
|
12904 It may seem odd to have what looks like the `real work' of
|
|
12905 the @code{forward-sentence} function buried here, but this is a common
|
|
12906 way this kind of operation is carried out in Lisp.
|
|
12907
|
|
12908 @node fwd-sentence re-search, , fwd-sentence while loops, forward-sentence
|
|
12909 @unnumberedsubsec The regular expression search
|
|
12910
|
|
12911 The @code{re-search-forward} function searches for the end of the
|
|
12912 sentence, that is, for the pattern defined by the @code{sentence-end}
|
|
12913 regular expression. If the pattern is found---if the end of the sentence is
|
|
12914 found---then the @code{re-search-forward} function does two things:
|
|
12915
|
|
12916 @enumerate
|
|
12917 @item
|
|
12918 The @code{re-search-forward} function carries out a side effect, which
|
|
12919 is to move point to the end of the occurrence found.
|
|
12920
|
|
12921 @item
|
|
12922 The @code{re-search-forward} function returns a value of true. This is
|
|
12923 the value received by the @code{if}, and means that the search was
|
|
12924 successful.
|
|
12925 @end enumerate
|
|
12926
|
|
12927 @noindent
|
|
12928 The side effect, the movement of point, is completed before the
|
|
12929 @code{if} function is handed the value returned by the successful
|
|
12930 conclusion of the search.
|
|
12931
|
|
12932 When the @code{if} function receives the value of true from a successful
|
|
12933 call to @code{re-search-forward}, the @code{if} evaluates the then-part,
|
|
12934 which is the expression @code{(skip-chars-backward " \t\n")}. This
|
|
12935 expression moves backwards over any blank spaces, tabs or carriage
|
|
12936 returns until a printed character is found and then leaves point after
|
|
12937 the character. Since point has already been moved to the end of the
|
|
12938 pattern that marks the end of the sentence, this action leaves point
|
|
12939 right after the closing printed character of the sentence, which is
|
|
12940 usually a period.
|
|
12941
|
|
12942 On the other hand, if the @code{re-search-forward} function fails to
|
|
12943 find a pattern marking the end of the sentence, the function returns
|
|
12944 false. The false then causes the @code{if} to evaluate its third
|
|
12945 argument, which is @code{(goto-char par-end)}: it moves point to the
|
|
12946 end of the paragraph.
|
|
12947
|
|
12948 (And if the text is in a form or equivalent, and point may not move
|
|
12949 fully, then the @code{constrain-to-field} function comes into play.)
|
|
12950
|
|
12951 Regular expression searches are exceptionally useful and the pattern
|
|
12952 illustrated by @code{re-search-forward}, in which the search is the
|
|
12953 test of an @code{if} expression, is handy. You will see or write code
|
|
12954 incorporating this pattern often.
|
|
12955
|
|
12956 @node forward-paragraph, etags, forward-sentence, Regexp Search
|
|
12957 @comment node-name, next, previous, up
|
|
12958 @section @code{forward-paragraph}: a Goldmine of Functions
|
|
12959 @findex forward-paragraph
|
|
12960
|
|
12961 @ignore
|
|
12962 @c in GNU Emacs 22
|
|
12963 (defun forward-paragraph (&optional arg)
|
|
12964 "Move forward to end of paragraph.
|
|
12965 With argument ARG, do it ARG times;
|
|
12966 a negative argument ARG = -N means move backward N paragraphs.
|
|
12967
|
|
12968 A line which `paragraph-start' matches either separates paragraphs
|
|
12969 \(if `paragraph-separate' matches it also) or is the first line of a paragraph.
|
|
12970 A paragraph end is the beginning of a line which is not part of the paragraph
|
|
12971 to which the end of the previous line belongs, or the end of the buffer.
|
|
12972 Returns the count of paragraphs left to move."
|
|
12973 (interactive "p")
|
|
12974 (or arg (setq arg 1))
|
|
12975 (let* ((opoint (point))
|
|
12976 (fill-prefix-regexp
|
|
12977 (and fill-prefix (not (equal fill-prefix ""))
|
|
12978 (not paragraph-ignore-fill-prefix)
|
|
12979 (regexp-quote fill-prefix)))
|
|
12980 ;; Remove ^ from paragraph-start and paragraph-sep if they are there.
|
|
12981 ;; These regexps shouldn't be anchored, because we look for them
|
|
12982 ;; starting at the left-margin. This allows paragraph commands to
|
|
12983 ;; work normally with indented text.
|
|
12984 ;; This hack will not find problem cases like "whatever\\|^something".
|
|
12985 (parstart (if (and (not (equal "" paragraph-start))
|
|
12986 (equal ?^ (aref paragraph-start 0)))
|
|
12987 (substring paragraph-start 1)
|
|
12988 paragraph-start))
|
|
12989 (parsep (if (and (not (equal "" paragraph-separate))
|
|
12990 (equal ?^ (aref paragraph-separate 0)))
|
|
12991 (substring paragraph-separate 1)
|
|
12992 paragraph-separate))
|
|
12993 (parsep
|
|
12994 (if fill-prefix-regexp
|
|
12995 (concat parsep "\\|"
|
|
12996 fill-prefix-regexp "[ \t]*$")
|
|
12997 parsep))
|
|
12998 ;; This is used for searching.
|
|
12999 (sp-parstart (concat "^[ \t]*\\(?:" parstart "\\|" parsep "\\)"))
|
|
13000 start found-start)
|
|
13001 (while (and (< arg 0) (not (bobp)))
|
|
13002 (if (and (not (looking-at parsep))
|
|
13003 (re-search-backward "^\n" (max (1- (point)) (point-min)) t)
|
|
13004 (looking-at parsep))
|
|
13005 (setq arg (1+ arg))
|
|
13006 (setq start (point))
|
|
13007 ;; Move back over paragraph-separating lines.
|
|
13008 (forward-char -1) (beginning-of-line)
|
|
13009 (while (and (not (bobp))
|
|
13010 (progn (move-to-left-margin)
|
|
13011 (looking-at parsep)))
|
|
13012 (forward-line -1))
|
|
13013 (if (bobp)
|
|
13014 nil
|
|
13015 (setq arg (1+ arg))
|
|
13016 ;; Go to end of the previous (non-separating) line.
|
|
13017 (end-of-line)
|
|
13018 ;; Search back for line that starts or separates paragraphs.
|
|
13019 (if (if fill-prefix-regexp
|
|
13020 ;; There is a fill prefix; it overrides parstart.
|
|
13021 (let (multiple-lines)
|
|
13022 (while (and (progn (beginning-of-line) (not (bobp)))
|
|
13023 (progn (move-to-left-margin)
|
|
13024 (not (looking-at parsep)))
|
|
13025 (looking-at fill-prefix-regexp))
|
|
13026 (unless (= (point) start)
|
|
13027 (setq multiple-lines t))
|
|
13028 (forward-line -1))
|
|
13029 (move-to-left-margin)
|
|
13030 ;; This deleted code caused a long hanging-indent line
|
|
13031 ;; not to be filled together with the following lines.
|
|
13032 ;; ;; Don't move back over a line before the paragraph
|
|
13033 ;; ;; which doesn't start with fill-prefix
|
|
13034 ;; ;; unless that is the only line we've moved over.
|
|
13035 ;; (and (not (looking-at fill-prefix-regexp))
|
|
13036 ;; multiple-lines
|
|
13037 ;; (forward-line 1))
|
|
13038 (not (bobp)))
|
|
13039 (while (and (re-search-backward sp-parstart nil 1)
|
|
13040 (setq found-start t)
|
|
13041 ;; Found a candidate, but need to check if it is a
|
|
13042 ;; REAL parstart.
|
|
13043 (progn (setq start (point))
|
|
13044 (move-to-left-margin)
|
|
13045 (not (looking-at parsep)))
|
|
13046 (not (and (looking-at parstart)
|
|
13047 (or (not use-hard-newlines)
|
|
13048 (bobp)
|
|
13049 (get-text-property
|
|
13050 (1- start) 'hard)))))
|
|
13051 (setq found-start nil)
|
|
13052 (goto-char start))
|
|
13053 found-start)
|
|
13054 ;; Found one.
|
|
13055 (progn
|
|
13056 ;; Move forward over paragraph separators.
|
|
13057 ;; We know this cannot reach the place we started
|
|
13058 ;; because we know we moved back over a non-separator.
|
|
13059 (while (and (not (eobp))
|
|
13060 (progn (move-to-left-margin)
|
|
13061 (looking-at parsep)))
|
|
13062 (forward-line 1))
|
|
13063 ;; If line before paragraph is just margin, back up to there.
|
|
13064 (end-of-line 0)
|
|
13065 (if (> (current-column) (current-left-margin))
|
|
13066 (forward-char 1)
|
|
13067 (skip-chars-backward " \t")
|
|
13068 (if (not (bolp))
|
|
13069 (forward-line 1))))
|
|
13070 ;; No starter or separator line => use buffer beg.
|
|
13071 (goto-char (point-min))))))
|
|
13072
|
|
13073 (while (and (> arg 0) (not (eobp)))
|
|
13074 ;; Move forward over separator lines...
|
|
13075 (while (and (not (eobp))
|
|
13076 (progn (move-to-left-margin) (not (eobp)))
|
|
13077 (looking-at parsep))
|
|
13078 (forward-line 1))
|
|
13079 (unless (eobp) (setq arg (1- arg)))
|
|
13080 ;; ... and one more line.
|
|
13081 (forward-line 1)
|
|
13082 (if fill-prefix-regexp
|
|
13083 ;; There is a fill prefix; it overrides parstart.
|
|
13084 (while (and (not (eobp))
|
|
13085 (progn (move-to-left-margin) (not (eobp)))
|
|
13086 (not (looking-at parsep))
|
|
13087 (looking-at fill-prefix-regexp))
|
|
13088 (forward-line 1))
|
|
13089 (while (and (re-search-forward sp-parstart nil 1)
|
|
13090 (progn (setq start (match-beginning 0))
|
|
13091 (goto-char start)
|
|
13092 (not (eobp)))
|
|
13093 (progn (move-to-left-margin)
|
|
13094 (not (looking-at parsep)))
|
|
13095 (or (not (looking-at parstart))
|
|
13096 (and use-hard-newlines
|
|
13097 (not (get-text-property (1- start) 'hard)))))
|
|
13098 (forward-char 1))
|
|
13099 (if (< (point) (point-max))
|
|
13100 (goto-char start))))
|
|
13101 (constrain-to-field nil opoint t)
|
|
13102 ;; Return the number of steps that could not be done.
|
|
13103 arg))
|
|
13104 @end ignore
|
|
13105
|
|
13106 The @code{forward-paragraph} function moves point forward to the end
|
|
13107 of the paragraph. It is usually bound to @kbd{M-@}} and makes use of a
|
|
13108 number of functions that are important in themselves, including
|
|
13109 @code{let*}, @code{match-beginning}, and @code{looking-at}.
|
|
13110
|
|
13111 The function definition for @code{forward-paragraph} is considerably
|
|
13112 longer than the function definition for @code{forward-sentence}
|
|
13113 because it works with a paragraph, each line of which may begin with a
|
|
13114 fill prefix.
|
|
13115
|
|
13116 A fill prefix consists of a string of characters that are repeated at
|
|
13117 the beginning of each line. For example, in Lisp code, it is a
|
|
13118 convention to start each line of a paragraph-long comment with
|
|
13119 @samp{;;; }. In Text mode, four blank spaces make up another common
|
|
13120 fill prefix, creating an indented paragraph. (@xref{Fill Prefix, , ,
|
|
13121 emacs, The GNU Emacs Manual}, for more information about fill
|
|
13122 prefixes.)
|
|
13123
|
|
13124 The existence of a fill prefix means that in addition to being able to
|
|
13125 find the end of a paragraph whose lines begin on the left-most
|
|
13126 column, the @code{forward-paragraph} function must be able to find the
|
|
13127 end of a paragraph when all or many of the lines in the buffer begin
|
|
13128 with the fill prefix.
|
|
13129
|
|
13130 Moreover, it is sometimes practical to ignore a fill prefix that
|
|
13131 exists, especially when blank lines separate paragraphs.
|
|
13132 This is an added complication.
|
|
13133
|
|
13134 @menu
|
|
13135 * forward-paragraph in brief:: Key parts of the function definition.
|
|
13136 * fwd-para let:: The @code{let*} expression.
|
|
13137 * fwd-para while:: The forward motion @code{while} loop.
|
|
13138 @end menu
|
|
13139
|
|
13140 @node forward-paragraph in brief, fwd-para let, forward-paragraph, forward-paragraph
|
|
13141 @ifnottex
|
|
13142 @unnumberedsubsec Shortened @code{forward-paragraph} function definition
|
|
13143 @end ifnottex
|
|
13144
|
|
13145 Rather than print all of the @code{forward-paragraph} function, we
|
|
13146 will only print parts of it. Read without preparation, the function
|
|
13147 can be daunting!
|
|
13148
|
|
13149 @need 800
|
|
13150 In outline, the function looks like this:
|
|
13151
|
|
13152 @smallexample
|
|
13153 @group
|
|
13154 (defun forward-paragraph (&optional arg)
|
|
13155 "@var{documentation}@dots{}"
|
|
13156 (interactive "p")
|
|
13157 (or arg (setq arg 1))
|
|
13158 (let*
|
|
13159 @var{varlist}
|
|
13160 (while (and (< arg 0) (not (bobp))) ; @r{backward-moving-code}
|
|
13161 @dots{}
|
|
13162 (while (and (> arg 0) (not (eobp))) ; @r{forward-moving-code}
|
|
13163 @dots{}
|
|
13164 @end group
|
|
13165 @end smallexample
|
|
13166
|
|
13167 The first parts of the function are routine: the function's argument
|
|
13168 list consists of one optional argument. Documentation follows.
|
|
13169
|
|
13170 The lower case @samp{p} in the @code{interactive} declaration means
|
|
13171 that the processed prefix argument, if any, is passed to the function.
|
|
13172 This will be a number, and is the repeat count of how many paragraphs
|
|
13173 point will move. The @code{or} expression in the next line handles
|
|
13174 the common case when no argument is passed to the function, which occurs
|
|
13175 if the function is called from other code rather than interactively.
|
|
13176 This case was described earlier. (@xref{forward-sentence, The
|
|
13177 @code{forward-sentence} function}.) Now we reach the end of the
|
|
13178 familiar part of this function.
|
|
13179
|
|
13180 @node fwd-para let, fwd-para while, forward-paragraph in brief, forward-paragraph
|
|
13181 @unnumberedsubsec The @code{let*} expression
|
|
13182
|
|
13183 The next line of the @code{forward-paragraph} function begins a
|
|
13184 @code{let*} expression. This is a different than @code{let}. The
|
|
13185 symbol is @code{let*} not @code{let}.
|
|
13186
|
|
13187 The @code{let*} special form is like @code{let} except that Emacs sets
|
|
13188 each variable in sequence, one after another, and variables in the
|
|
13189 latter part of the varlist can make use of the values to which Emacs
|
|
13190 set variables in the earlier part of the varlist.
|
|
13191
|
|
13192 @ignore
|
|
13193 ( refappend save-excursion, , code save-excursion in code append-to-buffer .)
|
|
13194 @end ignore
|
|
13195
|
|
13196 (@ref{append save-excursion, , @code{save-excursion} in @code{append-to-buffer}}.)
|
|
13197
|
|
13198 In the @code{let*} expression in this function, Emacs binds a total of
|
|
13199 seven variables: @code{opoint}, @code{fill-prefix-regexp},
|
|
13200 @code{parstart}, @code{parsep}, @code{sp-parstart}, @code{start}, and
|
|
13201 @code{found-start}.
|
|
13202
|
|
13203 The variable @code{parsep} appears twice, first, to remove instances
|
|
13204 of @samp{^}, and second, to handle fill prefixes.
|
|
13205
|
|
13206 The variable @code{opoint} is just the value of @code{point}. As you
|
|
13207 can guess, it is used in a @code{constrain-to-field} expression, just
|
|
13208 as in @code{forward-sentence}.
|
|
13209
|
|
13210 The variable @code{fill-prefix-regexp} is set to the value returned by
|
|
13211 evaluating the following list:
|
|
13212
|
|
13213 @smallexample
|
|
13214 @group
|
|
13215 (and fill-prefix
|
|
13216 (not (equal fill-prefix ""))
|
|
13217 (not paragraph-ignore-fill-prefix)
|
|
13218 (regexp-quote fill-prefix))
|
|
13219 @end group
|
|
13220 @end smallexample
|
|
13221
|
|
13222 @noindent
|
|
13223 This is an expression whose first element is the @code{and} special form.
|
|
13224
|
|
13225 As we learned earlier (@pxref{kill-new function, , The @code{kill-new}
|
|
13226 function}), the @code{and} special form evaluates each of its
|
|
13227 arguments until one of the arguments returns a value of @code{nil}, in
|
|
13228 which case the @code{and} expression returns @code{nil}; however, if
|
|
13229 none of the arguments returns a value of @code{nil}, the value
|
|
13230 resulting from evaluating the last argument is returned. (Since such
|
|
13231 a value is not @code{nil}, it is considered true in Lisp.) In other
|
|
13232 words, an @code{and} expression returns a true value only if all its
|
|
13233 arguments are true.
|
|
13234 @findex and
|
|
13235
|
|
13236 In this case, the variable @code{fill-prefix-regexp} is bound to a
|
|
13237 non-@code{nil} value only if the following four expressions produce a
|
|
13238 true (i.e., a non-@code{nil}) value when they are evaluated; otherwise,
|
|
13239 @code{fill-prefix-regexp} is bound to @code{nil}.
|
|
13240
|
|
13241 @table @code
|
|
13242 @item fill-prefix
|
|
13243 When this variable is evaluated, the value of the fill prefix, if any,
|
|
13244 is returned. If there is no fill prefix, this variable returns
|
|
13245 @code{nil}.
|
|
13246
|
|
13247 @item (not (equal fill-prefix "")
|
|
13248 This expression checks whether an existing fill prefix is an empty
|
|
13249 string, that is, a string with no characters in it. An empty string is
|
|
13250 not a useful fill prefix.
|
|
13251
|
|
13252 @item (not paragraph-ignore-fill-prefix)
|
|
13253 This expression returns @code{nil} if the variable
|
|
13254 @code{paragraph-ignore-fill-prefix} has been turned on by being set to a
|
|
13255 true value such as @code{t}.
|
|
13256
|
|
13257 @item (regexp-quote fill-prefix)
|
|
13258 This is the last argument to the @code{and} special form. If all the
|
|
13259 arguments to the @code{and} are true, the value resulting from
|
|
13260 evaluating this expression will be returned by the @code{and} expression
|
|
13261 and bound to the variable @code{fill-prefix-regexp},
|
|
13262 @end table
|
|
13263
|
|
13264 @findex regexp-quote
|
|
13265 @noindent
|
|
13266 The result of evaluating this @code{and} expression successfully is that
|
|
13267 @code{fill-prefix-regexp} will be bound to the value of
|
|
13268 @code{fill-prefix} as modified by the @code{regexp-quote} function.
|
|
13269 What @code{regexp-quote} does is read a string and return a regular
|
|
13270 expression that will exactly match the string and match nothing else.
|
|
13271 This means that @code{fill-prefix-regexp} will be set to a value that
|
|
13272 will exactly match the fill prefix if the fill prefix exists.
|
|
13273 Otherwise, the variable will be set to @code{nil}.
|
|
13274
|
|
13275 The next two local variables in the @code{let*} expression are
|
|
13276 designed to remove instances of @samp{^} from @code{parstart} and
|
|
13277 @code{parsep}, the local variables which indicate the paragraph start
|
|
13278 and the paragraph separator. The next expression sets @code{parsep}
|
|
13279 again. That is to handle fill prefixes.
|
|
13280
|
|
13281 This is the setting that requires the definition call @code{let*}
|
|
13282 rather than @code{let}. The true-or-false-test for the @code{if}
|
|
13283 depends on whether the variable @code{fill-prefix-regexp} evaluates to
|
|
13284 @code{nil} or some other value.
|
|
13285
|
|
13286 If @code{fill-prefix-regexp} does not have a value, Emacs evaluates
|
|
13287 the else-part of the @code{if} expression and binds @code{parsep} to
|
|
13288 its local value. (@code{parsep} is a regular expression that matches
|
|
13289 what separates paragraphs.)
|
|
13290
|
|
13291 But if @code{fill-prefix-regexp} does have a value, Emacs evaluates
|
|
13292 the then-part of the @code{if} expression and binds @code{parsep} to a
|
|
13293 regular expression that includes the @code{fill-prefix-regexp} as part
|
|
13294 of the pattern.
|
|
13295
|
|
13296 Specifically, @code{parsep} is set to the original value of the
|
|
13297 paragraph separate regular expression concatenated with an alternative
|
|
13298 expression that consists of the @code{fill-prefix-regexp} followed by
|
|
13299 optional whitespace to the end of the line. The whitespace is defined
|
|
13300 by @w{@code{"[ \t]*$"}}.) The @samp{\\|} defines this portion of the
|
|
13301 regexp as an alternative to @code{parsep}.
|
|
13302
|
|
13303 According to a comment in the code, the next local variable,
|
|
13304 @code{sp-parstart}, is used for searching, and then the final two,
|
|
13305 @code{start} and @code{found-start}, are set to @code{nil}.
|
|
13306
|
|
13307 Now we get into the body of the @code{let*}. The first part of the body
|
|
13308 of the @code{let*} deals with the case when the function is given a
|
|
13309 negative argument and is therefore moving backwards. We will skip this
|
|
13310 section.
|
|
13311
|
|
13312 @node fwd-para while, , fwd-para let, forward-paragraph
|
|
13313 @unnumberedsubsec The forward motion @code{while} loop
|
|
13314
|
|
13315 The second part of the body of the @code{let*} deals with forward
|
|
13316 motion. It is a @code{while} loop that repeats itself so long as the
|
|
13317 value of @code{arg} is greater than zero. In the most common use of
|
|
13318 the function, the value of the argument is 1, so the body of the
|
|
13319 @code{while} loop is evaluated exactly once, and the cursor moves
|
|
13320 forward one paragraph.
|
|
13321
|
|
13322 @ignore
|
|
13323 (while (and (> arg 0) (not (eobp)))
|
|
13324
|
|
13325 ;; Move forward over separator lines...
|
|
13326 (while (and (not (eobp))
|
|
13327 (progn (move-to-left-margin) (not (eobp)))
|
|
13328 (looking-at parsep))
|
|
13329 (forward-line 1))
|
|
13330 (unless (eobp) (setq arg (1- arg)))
|
|
13331 ;; ... and one more line.
|
|
13332 (forward-line 1)
|
|
13333
|
|
13334 (if fill-prefix-regexp
|
|
13335 ;; There is a fill prefix; it overrides parstart.
|
|
13336 (while (and (not (eobp))
|
|
13337 (progn (move-to-left-margin) (not (eobp)))
|
|
13338 (not (looking-at parsep))
|
|
13339 (looking-at fill-prefix-regexp))
|
|
13340 (forward-line 1))
|
|
13341
|
|
13342 (while (and (re-search-forward sp-parstart nil 1)
|
|
13343 (progn (setq start (match-beginning 0))
|
|
13344 (goto-char start)
|
|
13345 (not (eobp)))
|
|
13346 (progn (move-to-left-margin)
|
|
13347 (not (looking-at parsep)))
|
|
13348 (or (not (looking-at parstart))
|
|
13349 (and use-hard-newlines
|
|
13350 (not (get-text-property (1- start) 'hard)))))
|
|
13351 (forward-char 1))
|
|
13352
|
|
13353 (if (< (point) (point-max))
|
|
13354 (goto-char start))))
|
|
13355 @end ignore
|
|
13356
|
|
13357 This part handles three situations: when point is between paragraphs,
|
|
13358 when there is a fill prefix and when there is no fill prefix.
|
|
13359
|
|
13360 @need 800
|
|
13361 The @code{while} loop looks like this:
|
|
13362
|
|
13363 @smallexample
|
|
13364 @group
|
|
13365 ;; @r{going forwards and not at the end of the buffer}
|
|
13366 (while (and (> arg 0) (not (eobp)))
|
|
13367
|
|
13368 ;; @r{between paragraphs}
|
|
13369 ;; Move forward over separator lines...
|
|
13370 (while (and (not (eobp))
|
|
13371 (progn (move-to-left-margin) (not (eobp)))
|
|
13372 (looking-at parsep))
|
|
13373 (forward-line 1))
|
|
13374 ;; @r{This decrements the loop}
|
|
13375 (unless (eobp) (setq arg (1- arg)))
|
|
13376 ;; ... and one more line.
|
|
13377 (forward-line 1)
|
|
13378 @end group
|
|
13379
|
|
13380 @group
|
|
13381 (if fill-prefix-regexp
|
|
13382 ;; There is a fill prefix; it overrides parstart;
|
|
13383 ;; we go forward line by line
|
|
13384 (while (and (not (eobp))
|
|
13385 (progn (move-to-left-margin) (not (eobp)))
|
|
13386 (not (looking-at parsep))
|
|
13387 (looking-at fill-prefix-regexp))
|
|
13388 (forward-line 1))
|
|
13389 @end group
|
|
13390
|
|
13391 @group
|
|
13392 ;; There is no fill prefix;
|
|
13393 ;; we go forward character by character
|
|
13394 (while (and (re-search-forward sp-parstart nil 1)
|
|
13395 (progn (setq start (match-beginning 0))
|
|
13396 (goto-char start)
|
|
13397 (not (eobp)))
|
|
13398 (progn (move-to-left-margin)
|
|
13399 (not (looking-at parsep)))
|
|
13400 (or (not (looking-at parstart))
|
|
13401 (and use-hard-newlines
|
|
13402 (not (get-text-property (1- start) 'hard)))))
|
|
13403 (forward-char 1))
|
|
13404 @end group
|
|
13405
|
|
13406 @group
|
|
13407 ;; and if there is no fill prefix and if we are not at the end,
|
|
13408 ;; go to whatever was found in the regular expression search
|
|
13409 ;; for sp-parstart
|
|
13410 (if (< (point) (point-max))
|
|
13411 (goto-char start))))
|
|
13412 @end group
|
|
13413 @end smallexample
|
|
13414
|
|
13415 @findex eobp
|
|
13416 We can see that this is a decrementing counter @code{while} loop,
|
|
13417 using the expression @code{(setq arg (1- arg))} as the decrementer.
|
|
13418 That expression is not far from the @code{while}, but is hidden in
|
|
13419 another Lisp macro, an @code{unless} macro. Unless we are at the end
|
|
13420 of the buffer --- that is what the @code{eobp} function determines; it
|
|
13421 is an abbreviation of @samp{End Of Buffer P} --- we decrease the value
|
|
13422 of @code{arg} by one.
|
|
13423
|
|
13424 (If we are at the end of the buffer, we cannot go forward any more and
|
|
13425 the next loop of the @code{while} expression will test false since the
|
|
13426 test is an @code{and} with @code{(not (eobp))}. The @code{not}
|
|
13427 function means exactly as you expect; it is another name for
|
|
13428 @code{null}, a function that returns true when its argument is false.)
|
|
13429
|
|
13430 Interestingly, the loop count is not decremented until we leave the
|
|
13431 space between paragraphs, unless we come to the end of buffer or stop
|
|
13432 seeing the local value of the paragraph separator.
|
|
13433
|
|
13434 That second @code{while} also has a @code{(move-to-left-margin)}
|
|
13435 expression. The function is self-explanatory. It is inside a
|
|
13436 @code{progn} expression and not the last element of its body, so it is
|
|
13437 only invoked for its side effect, which is to move point to the left
|
|
13438 margin of the current line.
|
|
13439
|
|
13440 @findex looking-at
|
|
13441 The @code{looking-at} function is also self-explanatory; it returns
|
|
13442 true if the text after point matches the regular expression given as
|
|
13443 its argument.
|
|
13444
|
|
13445 The rest of the body of the loop looks difficult at first, but makes
|
|
13446 sense as you come to understand it.
|
|
13447
|
|
13448 @need 800
|
|
13449 First consider what happens if there is a fill prefix:
|
|
13450
|
|
13451 @smallexample
|
|
13452 @group
|
|
13453 (if fill-prefix-regexp
|
|
13454 ;; There is a fill prefix; it overrides parstart;
|
|
13455 ;; we go forward line by line
|
|
13456 (while (and (not (eobp))
|
|
13457 (progn (move-to-left-margin) (not (eobp)))
|
|
13458 (not (looking-at parsep))
|
|
13459 (looking-at fill-prefix-regexp))
|
|
13460 (forward-line 1))
|
|
13461 @end group
|
|
13462 @end smallexample
|
|
13463
|
|
13464 @noindent
|
|
13465 This expression moves point forward line by line so long
|
|
13466 as four conditions are true:
|
|
13467
|
|
13468 @enumerate
|
|
13469 @item
|
|
13470 Point is not at the end of the buffer.
|
|
13471
|
|
13472 @item
|
|
13473 We can move to the left margin of the text and are
|
|
13474 not at the end of the buffer.
|
|
13475
|
|
13476 @item
|
|
13477 The text following point does not separate paragraphs.
|
|
13478
|
|
13479 @item
|
|
13480 The pattern following point is the fill prefix regular expression.
|
|
13481 @end enumerate
|
|
13482
|
|
13483 The last condition may be puzzling, until you remember that point was
|
|
13484 moved to the beginning of the line early in the @code{forward-paragraph}
|
|
13485 function. This means that if the text has a fill prefix, the
|
|
13486 @code{looking-at} function will see it.
|
|
13487
|
|
13488 @need 1250
|
|
13489 Consider what happens when there is no fill prefix.
|
|
13490
|
|
13491 @smallexample
|
|
13492 @group
|
|
13493 (while (and (re-search-forward sp-parstart nil 1)
|
|
13494 (progn (setq start (match-beginning 0))
|
|
13495 (goto-char start)
|
|
13496 (not (eobp)))
|
|
13497 (progn (move-to-left-margin)
|
|
13498 (not (looking-at parsep)))
|
|
13499 (or (not (looking-at parstart))
|
|
13500 (and use-hard-newlines
|
|
13501 (not (get-text-property (1- start) 'hard)))))
|
|
13502 (forward-char 1))
|
|
13503 @end group
|
|
13504 @end smallexample
|
|
13505
|
|
13506 @noindent
|
|
13507 This @code{while} loop has us searching forward for
|
|
13508 @code{sp-parstart}, which is the combination of possible whitespace
|
|
13509 with a the local value of the start of a paragraph or of a paragraph
|
|
13510 separator. (The latter two are within an expression starting
|
|
13511 @code{\(?:} so that they are not referenced by the
|
|
13512 @code{match-beginning} function.)
|
|
13513
|
|
13514 @need 800
|
|
13515 The two expressions,
|
|
13516
|
|
13517 @smallexample
|
|
13518 @group
|
|
13519 (setq start (match-beginning 0))
|
|
13520 (goto-char start)
|
|
13521 @end group
|
|
13522 @end smallexample
|
|
13523
|
|
13524 @noindent
|
|
13525 mean go to the start of the text matched by the regular expression
|
|
13526 search.
|
|
13527
|
|
13528 The @code{(match-beginning 0)} expression is new. It returns a number
|
|
13529 specifying the location of the start of the text that was matched by
|
|
13530 the last search.
|
|
13531
|
|
13532 The @code{match-beginning} function is used here because of a
|
|
13533 characteristic of a forward search: a successful forward search,
|
|
13534 regardless of whether it is a plain search or a regular expression
|
|
13535 search, moves point to the end of the text that is found. In this
|
|
13536 case, a successful search moves point to the end of the pattern for
|
|
13537 @code{sp-parstart}.
|
|
13538
|
|
13539 However, we want to put point at the end of the current paragraph, not
|
|
13540 somewhere else. Indeed, since the search possibly includes the
|
|
13541 paragraph separator, point may end up at the beginning of the next one
|
|
13542 unless we use an expression that includes @code{match-beginning}.
|
|
13543
|
|
13544 @findex match-beginning
|
|
13545 When given an argument of 0, @code{match-beginning} returns the
|
|
13546 position that is the start of the text matched by the most recent
|
|
13547 search. In this case, the most recent search looks for
|
|
13548 @code{sp-parstart}. The @code{(match-beginning 0)} expression returns
|
|
13549 the beginning position of that pattern, rather than the end position
|
|
13550 of that pattern.
|
|
13551
|
|
13552 (Incidentally, when passed a positive number as an argument, the
|
|
13553 @code{match-beginning} function returns the location of point at that
|
|
13554 parenthesized expression in the last search unless that parenthesized
|
|
13555 expression begins with @code{\(?:}. I don't know why @code{\(?:}
|
|
13556 appears here since the argument is 0.)
|
|
13557
|
|
13558 @need 1250
|
|
13559 The last expression when there is no fill prefix is
|
|
13560
|
|
13561 @smallexample
|
|
13562 @group
|
|
13563 (if (< (point) (point-max))
|
|
13564 (goto-char start))))
|
|
13565 @end group
|
|
13566 @end smallexample
|
|
13567
|
|
13568 @noindent
|
|
13569 This says that if there is no fill prefix and if we are not at the
|
|
13570 end, point should move to the beginning of whatever was found by the
|
|
13571 regular expression search for @code{sp-parstart}.
|
|
13572
|
|
13573 The full definition for the @code{forward-paragraph} function not only
|
|
13574 includes code for going forwards, but also code for going backwards.
|
|
13575
|
|
13576 If you are reading this inside of GNU Emacs and you want to see the
|
|
13577 whole function, you can type @kbd{C-h f} (@code{describe-function})
|
|
13578 and the name of the function. This gives you the function
|
|
13579 documentation and the name of the library containing the function's
|
|
13580 source. Place point over the name of the library and press the RET
|
|
13581 key; you will be taken directly to the source. (Be sure to install
|
|
13582 your sources! Without them, you are like a person who tries to drive
|
|
13583 a car with his eyes shut!)
|
|
13584
|
|
13585 @node etags, Regexp Review, forward-paragraph, Regexp Search
|
|
13586 @section Create Your Own @file{TAGS} File
|
|
13587 @findex etags
|
|
13588 @cindex @file{TAGS} file, create own
|
|
13589
|
|
13590 Besides @kbd{C-h f} (@code{describe-function}), another way to see the
|
|
13591 source of a function is to type @kbd{M-.} (@code{find-tag}) and the
|
|
13592 name of the function when prompted for it. This is a good habit to
|
|
13593 get into. The @kbd{M-.} (@code{find-tag}) command takes you directly
|
|
13594 to the source for a function, variable, or node. The function depends
|
|
13595 on tags tables to tell it where to go.
|
|
13596
|
|
13597 If the @code{find-tag} function first asks you for the name of a
|
|
13598 @file{TAGS} table, give it the name of a @file{TAGS} file such as
|
|
13599 @file{/usr/local/src/emacs/src/TAGS}. (The exact path to your
|
|
13600 @file{TAGS} file depends on how your copy of Emacs was installed. I
|
|
13601 just told you the location that provides both my C and my Emacs Lisp
|
|
13602 sources.)
|
|
13603
|
|
13604 You can also create your own @file{TAGS} file for directories that
|
|
13605 lack one.
|
|
13606
|
|
13607 You often need to build and install tags tables yourself. They are
|
|
13608 not built automatically. A tags table is called a @file{TAGS} file;
|
|
13609 the name is in upper case letters.
|
|
13610
|
|
13611 You can create a @file{TAGS} file by calling the @code{etags} program
|
|
13612 that comes as a part of the Emacs distribution. Usually, @code{etags}
|
|
13613 is compiled and installed when Emacs is built. (@code{etags} is not
|
|
13614 an Emacs Lisp function or a part of Emacs; it is a C program.)
|
|
13615
|
|
13616 @need 1250
|
|
13617 To create a @file{TAGS} file, first switch to the directory in which
|
|
13618 you want to create the file. In Emacs you can do this with the
|
|
13619 @kbd{M-x cd} command, or by visiting a file in the directory, or by
|
|
13620 listing the directory with @kbd{C-x d} (@code{dired}). Then run the
|
|
13621 compile command, with @w{@code{etags *.el}} as the command to execute
|
|
13622
|
|
13623 @smallexample
|
|
13624 M-x compile RET etags *.el RET
|
|
13625 @end smallexample
|
|
13626
|
|
13627 @noindent
|
|
13628 to create a @file{TAGS} file for Emacs Lisp.
|
|
13629
|
|
13630 For example, if you have a large number of files in your
|
|
13631 @file{~/emacs} directory, as I do---I have 137 @file{.el} files in it,
|
|
13632 of which I load 12---you can create a @file{TAGS} file for the Emacs
|
|
13633 Lisp files in that directory.
|
|
13634
|
|
13635 @need 1250
|
|
13636 The @code{etags} program takes all the usual shell `wildcards'. For
|
|
13637 example, if you have two directories for which you want a single
|
|
13638 @file{TAGS} file, type @w{@code{etags *.el ../elisp/*.el}}, where
|
|
13639 @file{../elisp/} is the second directory:
|
|
13640
|
|
13641 @smallexample
|
|
13642 M-x compile RET etags *.el ../elisp/*.el RET
|
|
13643 @end smallexample
|
|
13644
|
|
13645 @need 1250
|
|
13646 Type
|
|
13647
|
|
13648 @smallexample
|
|
13649 M-x compile RET etags --help RET
|
|
13650 @end smallexample
|
|
13651
|
|
13652 @noindent
|
|
13653 to see a list of the options accepted by @code{etags} as well as a
|
|
13654 list of supported languages.
|
|
13655
|
|
13656 The @code{etags} program handles more than 20 languages, including
|
|
13657 Emacs Lisp, Common Lisp, Scheme, C, C++, Ada, Fortran, HTML, Java,
|
|
13658 LaTeX, Pascal, Perl, Postscript, Python, TeX, Texinfo, makefiles, and
|
|
13659 most assemblers. The program has no switches for specifying the
|
|
13660 language; it recognizes the language in an input file according to its
|
|
13661 file name and contents.
|
|
13662
|
|
13663 @file{etags} is very helpful when you are writing code yourself and
|
|
13664 want to refer back to functions you have already written. Just run
|
|
13665 @code{etags} again at intervals as you write new functions, so they
|
|
13666 become part of the @file{TAGS} file.
|
|
13667
|
|
13668 If you think an appropriate @file{TAGS} file already exists for what
|
|
13669 you want, but do not know where it is, you can use the @code{locate}
|
|
13670 program to attempt to find it.
|
|
13671
|
|
13672 Type @w{@kbd{M-x locate @key{RET} TAGS @key{RET}}} and Emacs will list
|
|
13673 for you the full path names of all your @file{TAGS} files. On my
|
|
13674 system, this command lists 34 @file{TAGS} files. On the other hand, a
|
|
13675 `plain vanilla' system I recently installed did not contain any
|
|
13676 @file{TAGS} files.
|
|
13677
|
|
13678 If the tags table you want has been created, you can use the @code{M-x
|
|
13679 visit-tags-table} command to specify it. Otherwise, you will need to
|
|
13680 create the tag table yourself and then use @code{M-x
|
|
13681 visit-tags-table}.
|
|
13682
|
|
13683 @subsubheading Building Tags in the Emacs sources
|
|
13684 @cindex Building Tags in the Emacs sources
|
|
13685 @cindex Tags in the Emacs sources
|
|
13686 @findex make tags
|
|
13687
|
|
13688 The GNU Emacs sources come with a @file{Makefile} that contains a
|
|
13689 sophisticated @code{etags} command that creates, collects, and merges
|
|
13690 tags tables from all over the Emacs sources and puts the information
|
|
13691 into one @file{TAGS} file in the @file{src/} directory. (The
|
|
13692 @file{src/} directory is below the top level of your Emacs directory.)
|
|
13693
|
|
13694 @need 1250
|
|
13695 To build this @file{TAGS} file, go to the top level of your Emacs
|
|
13696 source directory and run the compile command @code{make tags}:
|
|
13697
|
|
13698 @smallexample
|
|
13699 M-x compile RET make tags RET
|
|
13700 @end smallexample
|
|
13701
|
|
13702 @noindent
|
|
13703 (The @code{make tags} command works well with the GNU Emacs sources,
|
|
13704 as well as with some other source packages.)
|
|
13705
|
|
13706 For more information, see @ref{Tags, , Tag Tables, emacs, The GNU Emacs
|
|
13707 Manual}.
|
|
13708
|
|
13709 @node Regexp Review, re-search Exercises, etags, Regexp Search
|
|
13710 @comment node-name, next, previous, up
|
|
13711 @section Review
|
|
13712
|
|
13713 Here is a brief summary of some recently introduced functions.
|
|
13714
|
|
13715 @table @code
|
|
13716 @item while
|
|
13717 Repeatedly evaluate the body of the expression so long as the first
|
|
13718 element of the body tests true. Then return @code{nil}. (The
|
|
13719 expression is evaluated only for its side effects.)
|
|
13720
|
|
13721 @need 1250
|
|
13722 For example:
|
|
13723
|
|
13724 @smallexample
|
|
13725 @group
|
|
13726 (let ((foo 2))
|
|
13727 (while (> foo 0)
|
|
13728 (insert (format "foo is %d.\n" foo))
|
|
13729 (setq foo (1- foo))))
|
|
13730
|
|
13731 @result{} foo is 2.
|
|
13732 foo is 1.
|
|
13733 nil
|
|
13734 @end group
|
|
13735 @end smallexample
|
|
13736
|
|
13737 @noindent
|
|
13738 (The @code{insert} function inserts its arguments at point; the
|
|
13739 @code{format} function returns a string formatted from its arguments
|
|
13740 the way @code{message} formats its arguments; @code{\n} produces a new
|
|
13741 line.)
|
|
13742
|
|
13743 @item re-search-forward
|
|
13744 Search for a pattern, and if the pattern is found, move point to rest
|
|
13745 just after it.
|
|
13746
|
|
13747 @noindent
|
|
13748 Takes four arguments, like @code{search-forward}:
|
|
13749
|
|
13750 @enumerate
|
|
13751 @item
|
|
13752 A regular expression that specifies the pattern to search for.
|
|
13753 (Remember to put quotation marks around this argument!)
|
|
13754
|
|
13755 @item
|
|
13756 Optionally, the limit of the search.
|
|
13757
|
|
13758 @item
|
|
13759 Optionally, what to do if the search fails, return @code{nil} or an
|
|
13760 error message.
|
|
13761
|
|
13762 @item
|
|
13763 Optionally, how many times to repeat the search; if negative, the
|
|
13764 search goes backwards.
|
|
13765 @end enumerate
|
|
13766
|
|
13767 @item let*
|
|
13768 Bind some variables locally to particular values,
|
|
13769 and then evaluate the remaining arguments, returning the value of the
|
|
13770 last one. While binding the local variables, use the local values of
|
|
13771 variables bound earlier, if any.
|
|
13772
|
|
13773 @need 1250
|
|
13774 For example:
|
|
13775
|
|
13776 @smallexample
|
|
13777 @group
|
|
13778 (let* ((foo 7)
|
|
13779 (bar (* 3 foo)))
|
|
13780 (message "`bar' is %d." bar))
|
|
13781 @result{} `bar' is 21.
|
|
13782 @end group
|
|
13783 @end smallexample
|
|
13784
|
|
13785 @item match-beginning
|
|
13786 Return the position of the start of the text found by the last regular
|
|
13787 expression search.
|
|
13788
|
|
13789 @item looking-at
|
|
13790 Return @code{t} for true if the text after point matches the argument,
|
|
13791 which should be a regular expression.
|
|
13792
|
|
13793 @item eobp
|
|
13794 Return @code{t} for true if point is at the end of the accessible part
|
|
13795 of a buffer. The end of the accessible part is the end of the buffer
|
|
13796 if the buffer is not narrowed; it is the end of the narrowed part if
|
|
13797 the buffer is narrowed.
|
|
13798 @end table
|
|
13799
|
|
13800 @need 1500
|
|
13801 @node re-search Exercises, , Regexp Review, Regexp Search
|
|
13802 @section Exercises with @code{re-search-forward}
|
|
13803
|
|
13804 @itemize @bullet
|
|
13805 @item
|
|
13806 Write a function to search for a regular expression that matches two
|
|
13807 or more blank lines in sequence.
|
|
13808
|
|
13809 @item
|
|
13810 Write a function to search for duplicated words, such as `the the'.
|
|
13811 @xref{Regexps, , Syntax of Regular Expressions, emacs, The GNU Emacs
|
|
13812 Manual}, for information on how to write a regexp (a regular
|
|
13813 expression) to match a string that is composed of two identical
|
|
13814 halves. You can devise several regexps; some are better than others.
|
|
13815 The function I use is described in an appendix, along with several
|
|
13816 regexps. @xref{the-the, , @code{the-the} Duplicated Words Function}.
|
|
13817 @end itemize
|
|
13818
|
|
13819 @node Counting Words, Words in a defun, Regexp Search, Top
|
|
13820 @chapter Counting: Repetition and Regexps
|
|
13821 @cindex Repetition for word counting
|
|
13822 @cindex Regular expressions for word counting
|
|
13823
|
|
13824 Repetition and regular expression searches are powerful tools that you
|
|
13825 often use when you write code in Emacs Lisp. This chapter illustrates
|
|
13826 the use of regular expression searches through the construction of
|
|
13827 word count commands using @code{while} loops and recursion.
|
|
13828
|
|
13829 @menu
|
|
13830 * Why Count Words::
|
|
13831 * count-words-region:: Use a regexp, but find a problem.
|
|
13832 * recursive-count-words:: Start with case of no words in region.
|
|
13833 * Counting Exercise::
|
|
13834 @end menu
|
|
13835
|
|
13836 @node Why Count Words, count-words-region, Counting Words, Counting Words
|
|
13837 @ifnottex
|
|
13838 @unnumberedsec Counting words
|
|
13839 @end ifnottex
|
|
13840
|
|
13841 The standard Emacs distribution contains a function for counting the
|
|
13842 number of lines within a region. However, there is no corresponding
|
|
13843 function for counting words.
|
|
13844
|
|
13845 Certain types of writing ask you to count words. Thus, if you write
|
|
13846 an essay, you may be limited to 800 words; if you write a novel, you
|
|
13847 may discipline yourself to write 1000 words a day. It seems odd to me
|
|
13848 that Emacs lacks a word count command. Perhaps people use Emacs
|
|
13849 mostly for code or types of documentation that do not require word
|
|
13850 counts; or perhaps they restrict themselves to the operating system
|
|
13851 word count command, @code{wc}. Alternatively, people may follow
|
|
13852 the publishers' convention and compute a word count by dividing the
|
|
13853 number of characters in a document by five. In any event, here are
|
|
13854 commands to count words.
|
|
13855
|
|
13856 @node count-words-region, recursive-count-words, Why Count Words, Counting Words
|
|
13857 @comment node-name, next, previous, up
|
|
13858 @section The @code{count-words-region} Function
|
|
13859 @findex count-words-region
|
|
13860
|
|
13861 A word count command could count words in a line, paragraph, region,
|
|
13862 or buffer. What should the command cover? You could design the
|
|
13863 command to count the number of words in a complete buffer. However,
|
|
13864 the Emacs tradition encourages flexibility---you may want to count
|
|
13865 words in just a section, rather than all of a buffer. So it makes
|
|
13866 more sense to design the command to count the number of words in a
|
|
13867 region. Once you have a @code{count-words-region} command, you can,
|
|
13868 if you wish, count words in a whole buffer by marking it with
|
|
13869 @w{@kbd{C-x h}} (@code{mark-whole-buffer}).
|
|
13870
|
|
13871 Clearly, counting words is a repetitive act: starting from the
|
|
13872 beginning of the region, you count the first word, then the second
|
|
13873 word, then the third word, and so on, until you reach the end of the
|
|
13874 region. This means that word counting is ideally suited to recursion
|
|
13875 or to a @code{while} loop.
|
|
13876
|
|
13877 @menu
|
|
13878 * Design count-words-region:: The definition using a @code{while} loop.
|
|
13879 * Whitespace Bug:: The Whitespace Bug in @code{count-words-region}.
|
|
13880 @end menu
|
|
13881
|
|
13882 @node Design count-words-region, Whitespace Bug, count-words-region, count-words-region
|
|
13883 @ifnottex
|
|
13884 @unnumberedsubsec Designing @code{count-words-region}
|
|
13885 @end ifnottex
|
|
13886
|
|
13887 First, we will implement the word count command with a @code{while}
|
|
13888 loop, then with recursion. The command will, of course, be
|
|
13889 interactive.
|
|
13890
|
|
13891 @need 800
|
|
13892 The template for an interactive function definition is, as always:
|
|
13893
|
|
13894 @smallexample
|
|
13895 @group
|
|
13896 (defun @var{name-of-function} (@var{argument-list})
|
|
13897 "@var{documentation}@dots{}"
|
|
13898 (@var{interactive-expression}@dots{})
|
|
13899 @var{body}@dots{})
|
|
13900 @end group
|
|
13901 @end smallexample
|
|
13902
|
|
13903 What we need to do is fill in the slots.
|
|
13904
|
|
13905 The name of the function should be self-explanatory and similar to the
|
|
13906 existing @code{count-lines-region} name. This makes the name easier
|
|
13907 to remember. @code{count-words-region} is a good choice.
|
|
13908
|
|
13909 The function counts words within a region. This means that the
|
|
13910 argument list must contain symbols that are bound to the two
|
|
13911 positions, the beginning and end of the region. These two positions
|
|
13912 can be called @samp{beginning} and @samp{end} respectively. The first
|
|
13913 line of the documentation should be a single sentence, since that is
|
|
13914 all that is printed as documentation by a command such as
|
|
13915 @code{apropos}. The interactive expression will be of the form
|
|
13916 @samp{(interactive "r")}, since that will cause Emacs to pass the
|
|
13917 beginning and end of the region to the function's argument list. All
|
|
13918 this is routine.
|
|
13919
|
|
13920 The body of the function needs to be written to do three tasks:
|
|
13921 first, to set up conditions under which the @code{while} loop can
|
|
13922 count words, second, to run the @code{while} loop, and third, to send
|
|
13923 a message to the user.
|
|
13924
|
|
13925 When a user calls @code{count-words-region}, point may be at the
|
|
13926 beginning or the end of the region. However, the counting process
|
|
13927 must start at the beginning of the region. This means we will want
|
|
13928 to put point there if it is not already there. Executing
|
|
13929 @code{(goto-char beginning)} ensures this. Of course, we will want to
|
|
13930 return point to its expected position when the function finishes its
|
|
13931 work. For this reason, the body must be enclosed in a
|
|
13932 @code{save-excursion} expression.
|
|
13933
|
|
13934 The central part of the body of the function consists of a
|
|
13935 @code{while} loop in which one expression jumps point forward word by
|
|
13936 word, and another expression counts those jumps. The true-or-false-test
|
|
13937 of the @code{while} loop should test true so long as point should jump
|
|
13938 forward, and false when point is at the end of the region.
|
|
13939
|
|
13940 We could use @code{(forward-word 1)} as the expression for moving point
|
|
13941 forward word by word, but it is easier to see what Emacs identifies as a
|
|
13942 `word' if we use a regular expression search.
|
|
13943
|
|
13944 A regular expression search that finds the pattern for which it is
|
|
13945 searching leaves point after the last character matched. This means
|
|
13946 that a succession of successful word searches will move point forward
|
|
13947 word by word.
|
|
13948
|
|
13949 As a practical matter, we want the regular expression search to jump
|
|
13950 over whitespace and punctuation between words as well as over the
|
|
13951 words themselves. A regexp that refuses to jump over interword
|
|
13952 whitespace would never jump more than one word! This means that
|
|
13953 the regexp should include the whitespace and punctuation that follows
|
|
13954 a word, if any, as well as the word itself. (A word may end a buffer
|
|
13955 and not have any following whitespace or punctuation, so that part of
|
|
13956 the regexp must be optional.)
|
|
13957
|
|
13958 Thus, what we want for the regexp is a pattern defining one or more
|
|
13959 word constituent characters followed, optionally, by one or more
|
|
13960 characters that are not word constituents. The regular expression for
|
|
13961 this is:
|
|
13962
|
|
13963 @smallexample
|
|
13964 \w+\W*
|
|
13965 @end smallexample
|
|
13966
|
|
13967 @noindent
|
|
13968 The buffer's syntax table determines which characters are and are not
|
|
13969 word constituents. (@xref{Syntax, , What Constitutes a Word or
|
|
13970 Symbol?}, for more about syntax. Also, see @ref{Syntax, Syntax, The
|
|
13971 Syntax Table, emacs, The GNU Emacs Manual}, and @ref{Syntax Tables, ,
|
|
13972 Syntax Tables, elisp, The GNU Emacs Lisp Reference Manual}.)
|
|
13973
|
|
13974 @need 800
|
|
13975 The search expression looks like this:
|
|
13976
|
|
13977 @smallexample
|
|
13978 (re-search-forward "\\w+\\W*")
|
|
13979 @end smallexample
|
|
13980
|
|
13981 @noindent
|
|
13982 (Note that paired backslashes precede the @samp{w} and @samp{W}. A
|
|
13983 single backslash has special meaning to the Emacs Lisp interpreter.
|
|
13984 It indicates that the following character is interpreted differently
|
|
13985 than usual. For example, the two characters, @samp{\n}, stand for
|
|
13986 @samp{newline}, rather than for a backslash followed by @samp{n}. Two
|
|
13987 backslashes in a row stand for an ordinary, `unspecial' backslash, so
|
|
13988 Emacs Lisp interpreter ends of seeing a single backslash followed by a
|
|
13989 letter. So it discovers the letter is special.)
|
|
13990
|
|
13991 We need a counter to count how many words there are; this variable
|
|
13992 must first be set to 0 and then incremented each time Emacs goes
|
|
13993 around the @code{while} loop. The incrementing expression is simply:
|
|
13994
|
|
13995 @smallexample
|
|
13996 (setq count (1+ count))
|
|
13997 @end smallexample
|
|
13998
|
|
13999 Finally, we want to tell the user how many words there are in the
|
|
14000 region. The @code{message} function is intended for presenting this
|
|
14001 kind of information to the user. The message has to be phrased so
|
|
14002 that it reads properly regardless of how many words there are in the
|
|
14003 region: we don't want to say that ``there are 1 words in the region''.
|
|
14004 The conflict between singular and plural is ungrammatical. We can
|
|
14005 solve this problem by using a conditional expression that evaluates
|
|
14006 different messages depending on the number of words in the region.
|
|
14007 There are three possibilities: no words in the region, one word in the
|
|
14008 region, and more than one word. This means that the @code{cond}
|
|
14009 special form is appropriate.
|
|
14010
|
|
14011 @need 1500
|
|
14012 All this leads to the following function definition:
|
|
14013
|
|
14014 @smallexample
|
|
14015 @group
|
|
14016 ;;; @r{First version; has bugs!}
|
|
14017 (defun count-words-region (beginning end)
|
|
14018 "Print number of words in the region.
|
|
14019 Words are defined as at least one word-constituent
|
|
14020 character followed by at least one character that
|
|
14021 is not a word-constituent. The buffer's syntax
|
|
14022 table determines which characters these are."
|
|
14023 (interactive "r")
|
|
14024 (message "Counting words in region ... ")
|
|
14025 @end group
|
|
14026
|
|
14027 @group
|
|
14028 ;;; @r{1. Set up appropriate conditions.}
|
|
14029 (save-excursion
|
|
14030 (goto-char beginning)
|
|
14031 (let ((count 0))
|
|
14032 @end group
|
|
14033
|
|
14034 @group
|
|
14035 ;;; @r{2. Run the} while @r{loop.}
|
|
14036 (while (< (point) end)
|
|
14037 (re-search-forward "\\w+\\W*")
|
|
14038 (setq count (1+ count)))
|
|
14039 @end group
|
|
14040
|
|
14041 @group
|
|
14042 ;;; @r{3. Send a message to the user.}
|
|
14043 (cond ((zerop count)
|
|
14044 (message
|
|
14045 "The region does NOT have any words."))
|
|
14046 ((= 1 count)
|
|
14047 (message
|
|
14048 "The region has 1 word."))
|
|
14049 (t
|
|
14050 (message
|
|
14051 "The region has %d words." count))))))
|
|
14052 @end group
|
|
14053 @end smallexample
|
|
14054
|
|
14055 @noindent
|
|
14056 As written, the function works, but not in all circumstances.
|
|
14057
|
|
14058 @node Whitespace Bug, , Design count-words-region, count-words-region
|
|
14059 @comment node-name, next, previous, up
|
|
14060 @subsection The Whitespace Bug in @code{count-words-region}
|
|
14061
|
|
14062 The @code{count-words-region} command described in the preceding
|
|
14063 section has two bugs, or rather, one bug with two manifestations.
|
|
14064 First, if you mark a region containing only whitespace in the middle
|
|
14065 of some text, the @code{count-words-region} command tells you that the
|
|
14066 region contains one word! Second, if you mark a region containing
|
|
14067 only whitespace at the end of the buffer or the accessible portion of
|
|
14068 a narrowed buffer, the command displays an error message that looks
|
|
14069 like this:
|
|
14070
|
|
14071 @smallexample
|
|
14072 Search failed: "\\w+\\W*"
|
|
14073 @end smallexample
|
|
14074
|
|
14075 If you are reading this in Info in GNU Emacs, you can test for these
|
|
14076 bugs yourself.
|
|
14077
|
|
14078 First, evaluate the function in the usual manner to install it.
|
|
14079 @ifinfo
|
|
14080 Here is a copy of the definition. Place your cursor after the closing
|
|
14081 parenthesis and type @kbd{C-x C-e} to install it.
|
|
14082
|
|
14083 @smallexample
|
|
14084 @group
|
|
14085 ;; @r{First version; has bugs!}
|
|
14086 (defun count-words-region (beginning end)
|
|
14087 "Print number of words in the region.
|
|
14088 Words are defined as at least one word-constituent character followed
|
|
14089 by at least one character that is not a word-constituent. The buffer's
|
|
14090 syntax table determines which characters these are."
|
|
14091 @end group
|
|
14092 @group
|
|
14093 (interactive "r")
|
|
14094 (message "Counting words in region ... ")
|
|
14095 @end group
|
|
14096
|
|
14097 @group
|
|
14098 ;;; @r{1. Set up appropriate conditions.}
|
|
14099 (save-excursion
|
|
14100 (goto-char beginning)
|
|
14101 (let ((count 0))
|
|
14102 @end group
|
|
14103
|
|
14104 @group
|
|
14105 ;;; @r{2. Run the} while @r{loop.}
|
|
14106 (while (< (point) end)
|
|
14107 (re-search-forward "\\w+\\W*")
|
|
14108 (setq count (1+ count)))
|
|
14109 @end group
|
|
14110
|
|
14111 @group
|
|
14112 ;;; @r{3. Send a message to the user.}
|
|
14113 (cond ((zerop count)
|
|
14114 (message "The region does NOT have any words."))
|
|
14115 ((= 1 count) (message "The region has 1 word."))
|
|
14116 (t (message "The region has %d words." count))))))
|
|
14117 @end group
|
|
14118 @end smallexample
|
|
14119 @end ifinfo
|
|
14120
|
|
14121 @need 1000
|
|
14122 If you wish, you can also install this keybinding by evaluating it:
|
|
14123
|
|
14124 @smallexample
|
|
14125 (global-set-key "\C-c=" 'count-words-region)
|
|
14126 @end smallexample
|
|
14127
|
|
14128 To conduct the first test, set mark and point to the beginning and end
|
|
14129 of the following line and then type @kbd{C-c =} (or @kbd{M-x
|
|
14130 count-words-region} if you have not bound @kbd{C-c =}):
|
|
14131
|
|
14132 @smallexample
|
|
14133 one two three
|
|
14134 @end smallexample
|
|
14135
|
|
14136 @noindent
|
|
14137 Emacs will tell you, correctly, that the region has three words.
|
|
14138
|
|
14139 Repeat the test, but place mark at the beginning of the line and place
|
|
14140 point just @emph{before} the word @samp{one}. Again type the command
|
|
14141 @kbd{C-c =} (or @kbd{M-x count-words-region}). Emacs should tell you
|
|
14142 that the region has no words, since it is composed only of the
|
|
14143 whitespace at the beginning of the line. But instead Emacs tells you
|
|
14144 that the region has one word!
|
|
14145
|
|
14146 For the third test, copy the sample line to the end of the
|
|
14147 @file{*scratch*} buffer and then type several spaces at the end of the
|
|
14148 line. Place mark right after the word @samp{three} and point at the
|
|
14149 end of line. (The end of the line will be the end of the buffer.)
|
|
14150 Type @kbd{C-c =} (or @kbd{M-x count-words-region}) as you did before.
|
|
14151 Again, Emacs should tell you that the region has no words, since it is
|
|
14152 composed only of the whitespace at the end of the line. Instead,
|
|
14153 Emacs displays an error message saying @samp{Search failed}.
|
|
14154
|
|
14155 The two bugs stem from the same problem.
|
|
14156
|
|
14157 Consider the first manifestation of the bug, in which the command
|
|
14158 tells you that the whitespace at the beginning of the line contains
|
|
14159 one word. What happens is this: The @code{M-x count-words-region}
|
|
14160 command moves point to the beginning of the region. The @code{while}
|
|
14161 tests whether the value of point is smaller than the value of
|
|
14162 @code{end}, which it is. Consequently, the regular expression search
|
|
14163 looks for and finds the first word. It leaves point after the word.
|
|
14164 @code{count} is set to one. The @code{while} loop repeats; but this
|
|
14165 time the value of point is larger than the value of @code{end}, the
|
|
14166 loop is exited; and the function displays a message saying the number
|
|
14167 of words in the region is one. In brief, the regular expression
|
|
14168 search looks for and finds the word even though it is outside
|
|
14169 the marked region.
|
|
14170
|
|
14171 In the second manifestation of the bug, the region is whitespace at
|
|
14172 the end of the buffer. Emacs says @samp{Search failed}. What happens
|
|
14173 is that the true-or-false-test in the @code{while} loop tests true, so
|
|
14174 the search expression is executed. But since there are no more words
|
|
14175 in the buffer, the search fails.
|
|
14176
|
|
14177 In both manifestations of the bug, the search extends or attempts to
|
|
14178 extend outside of the region.
|
|
14179
|
|
14180 The solution is to limit the search to the region---this is a fairly
|
|
14181 simple action, but as you may have come to expect, it is not quite as
|
|
14182 simple as you might think.
|
|
14183
|
|
14184 As we have seen, the @code{re-search-forward} function takes a search
|
|
14185 pattern as its first argument. But in addition to this first,
|
|
14186 mandatory argument, it accepts three optional arguments. The optional
|
|
14187 second argument bounds the search. The optional third argument, if
|
|
14188 @code{t}, causes the function to return @code{nil} rather than signal
|
|
14189 an error if the search fails. The optional fourth argument is a
|
|
14190 repeat count. (In Emacs, you can see a function's documentation by
|
|
14191 typing @kbd{C-h f}, the name of the function, and then @key{RET}.)
|
|
14192
|
|
14193 In the @code{count-words-region} definition, the value of the end of
|
|
14194 the region is held by the variable @code{end} which is passed as an
|
|
14195 argument to the function. Thus, we can add @code{end} as an argument
|
|
14196 to the regular expression search expression:
|
|
14197
|
|
14198 @smallexample
|
|
14199 (re-search-forward "\\w+\\W*" end)
|
|
14200 @end smallexample
|
|
14201
|
|
14202 However, if you make only this change to the @code{count-words-region}
|
|
14203 definition and then test the new version of the definition on a
|
|
14204 stretch of whitespace, you will receive an error message saying
|
|
14205 @samp{Search failed}.
|
|
14206
|
|
14207 What happens is this: the search is limited to the region, and fails
|
|
14208 as you expect because there are no word-constituent characters in the
|
|
14209 region. Since it fails, we receive an error message. But we do not
|
|
14210 want to receive an error message in this case; we want to receive the
|
|
14211 message that "The region does NOT have any words."
|
|
14212
|
|
14213 The solution to this problem is to provide @code{re-search-forward}
|
|
14214 with a third argument of @code{t}, which causes the function to return
|
|
14215 @code{nil} rather than signal an error if the search fails.
|
|
14216
|
|
14217 However, if you make this change and try it, you will see the message
|
|
14218 ``Counting words in region ... '' and @dots{} you will keep on seeing
|
|
14219 that message @dots{}, until you type @kbd{C-g} (@code{keyboard-quit}).
|
|
14220
|
|
14221 Here is what happens: the search is limited to the region, as before,
|
|
14222 and it fails because there are no word-constituent characters in the
|
|
14223 region, as expected. Consequently, the @code{re-search-forward}
|
|
14224 expression returns @code{nil}. It does nothing else. In particular,
|
|
14225 it does not move point, which it does as a side effect if it finds the
|
|
14226 search target. After the @code{re-search-forward} expression returns
|
|
14227 @code{nil}, the next expression in the @code{while} loop is evaluated.
|
|
14228 This expression increments the count. Then the loop repeats. The
|
|
14229 true-or-false-test tests true because the value of point is still less
|
|
14230 than the value of end, since the @code{re-search-forward} expression
|
|
14231 did not move point. @dots{} and the cycle repeats @dots{}
|
|
14232
|
|
14233 The @code{count-words-region} definition requires yet another
|
|
14234 modification, to cause the true-or-false-test of the @code{while} loop
|
|
14235 to test false if the search fails. Put another way, there are two
|
|
14236 conditions that must be satisfied in the true-or-false-test before the
|
|
14237 word count variable is incremented: point must still be within the
|
|
14238 region and the search expression must have found a word to count.
|
|
14239
|
|
14240 Since both the first condition and the second condition must be true
|
|
14241 together, the two expressions, the region test and the search
|
|
14242 expression, can be joined with an @code{and} special form and embedded in
|
|
14243 the @code{while} loop as the true-or-false-test, like this:
|
|
14244
|
|
14245 @smallexample
|
|
14246 (and (< (point) end) (re-search-forward "\\w+\\W*" end t))
|
|
14247 @end smallexample
|
|
14248
|
|
14249 @c colon in printed section title causes problem in Info cross reference
|
|
14250 @c also trouble with an overfull hbox
|
|
14251 @iftex
|
|
14252 @noindent
|
|
14253 (For information about @code{and}, see
|
|
14254 @ref{kill-new function, , The @code{kill-new} function}.)
|
|
14255 @end iftex
|
|
14256 @ifinfo
|
|
14257 @noindent
|
|
14258 (@xref{kill-new function, , The @code{kill-new} function}, for
|
|
14259 information about @code{and}.)
|
|
14260 @end ifinfo
|
|
14261
|
|
14262 The @code{re-search-forward} expression returns @code{t} if the search
|
|
14263 succeeds and as a side effect moves point. Consequently, as words are
|
|
14264 found, point is moved through the region. When the search expression
|
|
14265 fails to find another word, or when point reaches the end of the
|
|
14266 region, the true-or-false-test tests false, the @code{while} loop
|
|
14267 exits, and the @code{count-words-region} function displays one or
|
|
14268 other of its messages.
|
|
14269
|
|
14270 After incorporating these final changes, the @code{count-words-region}
|
|
14271 works without bugs (or at least, without bugs that I have found!).
|
|
14272 Here is what it looks like:
|
|
14273
|
|
14274 @smallexample
|
|
14275 @group
|
|
14276 ;;; @r{Final version:} @code{while}
|
|
14277 (defun count-words-region (beginning end)
|
|
14278 "Print number of words in the region."
|
|
14279 (interactive "r")
|
|
14280 (message "Counting words in region ... ")
|
|
14281 @end group
|
|
14282
|
|
14283 @group
|
|
14284 ;;; @r{1. Set up appropriate conditions.}
|
|
14285 (save-excursion
|
|
14286 (let ((count 0))
|
|
14287 (goto-char beginning)
|
|
14288 @end group
|
|
14289
|
|
14290 @group
|
|
14291 ;;; @r{2. Run the} while @r{loop.}
|
|
14292 (while (and (< (point) end)
|
|
14293 (re-search-forward "\\w+\\W*" end t))
|
|
14294 (setq count (1+ count)))
|
|
14295 @end group
|
|
14296
|
|
14297 @group
|
|
14298 ;;; @r{3. Send a message to the user.}
|
|
14299 (cond ((zerop count)
|
|
14300 (message
|
|
14301 "The region does NOT have any words."))
|
|
14302 ((= 1 count)
|
|
14303 (message
|
|
14304 "The region has 1 word."))
|
|
14305 (t
|
|
14306 (message
|
|
14307 "The region has %d words." count))))))
|
|
14308 @end group
|
|
14309 @end smallexample
|
|
14310
|
|
14311 @node recursive-count-words, Counting Exercise, count-words-region, Counting Words
|
|
14312 @comment node-name, next, previous, up
|
|
14313 @section Count Words Recursively
|
|
14314 @cindex Count words recursively
|
|
14315 @cindex Recursively counting words
|
|
14316 @cindex Words, counted recursively
|
|
14317
|
|
14318 You can write the function for counting words recursively as well as
|
|
14319 with a @code{while} loop. Let's see how this is done.
|
|
14320
|
|
14321 First, we need to recognize that the @code{count-words-region}
|
|
14322 function has three jobs: it sets up the appropriate conditions for
|
|
14323 counting to occur; it counts the words in the region; and it sends a
|
|
14324 message to the user telling how many words there are.
|
|
14325
|
|
14326 If we write a single recursive function to do everything, we will
|
|
14327 receive a message for every recursive call. If the region contains 13
|
|
14328 words, we will receive thirteen messages, one right after the other.
|
|
14329 We don't want this! Instead, we must write two functions to do the
|
|
14330 job, one of which (the recursive function) will be used inside of the
|
|
14331 other. One function will set up the conditions and display the
|
|
14332 message; the other will return the word count.
|
|
14333
|
|
14334 Let us start with the function that causes the message to be displayed.
|
|
14335 We can continue to call this @code{count-words-region}.
|
|
14336
|
|
14337 This is the function that the user will call. It will be interactive.
|
|
14338 Indeed, it will be similar to our previous versions of this
|
|
14339 function, except that it will call @code{recursive-count-words} to
|
|
14340 determine how many words are in the region.
|
|
14341
|
|
14342 @need 1250
|
|
14343 We can readily construct a template for this function, based on our
|
|
14344 previous versions:
|
|
14345
|
|
14346 @smallexample
|
|
14347 @group
|
|
14348 ;; @r{Recursive version; uses regular expression search}
|
|
14349 (defun count-words-region (beginning end)
|
|
14350 "@var{documentation}@dots{}"
|
|
14351 (@var{interactive-expression}@dots{})
|
|
14352 @end group
|
|
14353 @group
|
|
14354
|
|
14355 ;;; @r{1. Set up appropriate conditions.}
|
|
14356 (@var{explanatory message})
|
|
14357 (@var{set-up functions}@dots{}
|
|
14358 @end group
|
|
14359 @group
|
|
14360
|
|
14361 ;;; @r{2. Count the words.}
|
|
14362 @var{recursive call}
|
|
14363 @end group
|
|
14364 @group
|
|
14365
|
|
14366 ;;; @r{3. Send a message to the user.}
|
|
14367 @var{message providing word count}))
|
|
14368 @end group
|
|
14369 @end smallexample
|
|
14370
|
|
14371 The definition looks straightforward, except that somehow the count
|
|
14372 returned by the recursive call must be passed to the message
|
|
14373 displaying the word count. A little thought suggests that this can be
|
|
14374 done by making use of a @code{let} expression: we can bind a variable
|
|
14375 in the varlist of a @code{let} expression to the number of words in
|
|
14376 the region, as returned by the recursive call; and then the
|
|
14377 @code{cond} expression, using binding, can display the value to the
|
|
14378 user.
|
|
14379
|
|
14380 Often, one thinks of the binding within a @code{let} expression as
|
|
14381 somehow secondary to the `primary' work of a function. But in this
|
|
14382 case, what you might consider the `primary' job of the function,
|
|
14383 counting words, is done within the @code{let} expression.
|
|
14384
|
|
14385 @need 1250
|
|
14386 Using @code{let}, the function definition looks like this:
|
|
14387
|
|
14388 @smallexample
|
|
14389 @group
|
|
14390 (defun count-words-region (beginning end)
|
|
14391 "Print number of words in the region."
|
|
14392 (interactive "r")
|
|
14393 @end group
|
|
14394
|
|
14395 @group
|
|
14396 ;;; @r{1. Set up appropriate conditions.}
|
|
14397 (message "Counting words in region ... ")
|
|
14398 (save-excursion
|
|
14399 (goto-char beginning)
|
|
14400 @end group
|
|
14401
|
|
14402 @group
|
|
14403 ;;; @r{2. Count the words.}
|
|
14404 (let ((count (recursive-count-words end)))
|
|
14405 @end group
|
|
14406
|
|
14407 @group
|
|
14408 ;;; @r{3. Send a message to the user.}
|
|
14409 (cond ((zerop count)
|
|
14410 (message
|
|
14411 "The region does NOT have any words."))
|
|
14412 ((= 1 count)
|
|
14413 (message
|
|
14414 "The region has 1 word."))
|
|
14415 (t
|
|
14416 (message
|
|
14417 "The region has %d words." count))))))
|
|
14418 @end group
|
|
14419 @end smallexample
|
|
14420
|
|
14421 Next, we need to write the recursive counting function.
|
|
14422
|
|
14423 A recursive function has at least three parts: the `do-again-test', the
|
|
14424 `next-step-expression', and the recursive call.
|
|
14425
|
|
14426 The do-again-test determines whether the function will or will not be
|
|
14427 called again. Since we are counting words in a region and can use a
|
|
14428 function that moves point forward for every word, the do-again-test
|
|
14429 can check whether point is still within the region. The do-again-test
|
|
14430 should find the value of point and determine whether point is before,
|
|
14431 at, or after the value of the end of the region. We can use the
|
|
14432 @code{point} function to locate point. Clearly, we must pass the
|
|
14433 value of the end of the region to the recursive counting function as an
|
|
14434 argument.
|
|
14435
|
|
14436 In addition, the do-again-test should also test whether the search finds a
|
|
14437 word. If it does not, the function should not call itself again.
|
|
14438
|
|
14439 The next-step-expression changes a value so that when the recursive
|
|
14440 function is supposed to stop calling itself, it stops. More
|
|
14441 precisely, the next-step-expression changes a value so that at the
|
|
14442 right time, the do-again-test stops the recursive function from
|
|
14443 calling itself again. In this case, the next-step-expression can be
|
|
14444 the expression that moves point forward, word by word.
|
|
14445
|
|
14446 The third part of a recursive function is the recursive call.
|
|
14447
|
|
14448 Somewhere, also, we also need a part that does the `work' of the
|
|
14449 function, a part that does the counting. A vital part!
|
|
14450
|
|
14451 @need 1250
|
|
14452 But already, we have an outline of the recursive counting function:
|
|
14453
|
|
14454 @smallexample
|
|
14455 @group
|
|
14456 (defun recursive-count-words (region-end)
|
|
14457 "@var{documentation}@dots{}"
|
|
14458 @var{do-again-test}
|
|
14459 @var{next-step-expression}
|
|
14460 @var{recursive call})
|
|
14461 @end group
|
|
14462 @end smallexample
|
|
14463
|
|
14464 Now we need to fill in the slots. Let's start with the simplest cases
|
|
14465 first: if point is at or beyond the end of the region, there cannot
|
|
14466 be any words in the region, so the function should return zero.
|
|
14467 Likewise, if the search fails, there are no words to count, so the
|
|
14468 function should return zero.
|
|
14469
|
|
14470 On the other hand, if point is within the region and the search
|
|
14471 succeeds, the function should call itself again.
|
|
14472
|
|
14473 @need 800
|
|
14474 Thus, the do-again-test should look like this:
|
|
14475
|
|
14476 @smallexample
|
|
14477 @group
|
|
14478 (and (< (point) region-end)
|
|
14479 (re-search-forward "\\w+\\W*" region-end t))
|
|
14480 @end group
|
|
14481 @end smallexample
|
|
14482
|
|
14483 Note that the search expression is part of the do-again-test---the
|
|
14484 function returns @code{t} if its search succeeds and @code{nil} if it
|
|
14485 fails. (@xref{Whitespace Bug, , The Whitespace Bug in
|
|
14486 @code{count-words-region}}, for an explanation of how
|
|
14487 @code{re-search-forward} works.)
|
|
14488
|
|
14489 The do-again-test is the true-or-false test of an @code{if} clause.
|
|
14490 Clearly, if the do-again-test succeeds, the then-part of the @code{if}
|
|
14491 clause should call the function again; but if it fails, the else-part
|
|
14492 should return zero since either point is outside the region or the
|
|
14493 search failed because there were no words to find.
|
|
14494
|
|
14495 But before considering the recursive call, we need to consider the
|
|
14496 next-step-expression. What is it? Interestingly, it is the search
|
|
14497 part of the do-again-test.
|
|
14498
|
|
14499 In addition to returning @code{t} or @code{nil} for the
|
|
14500 do-again-test, @code{re-search-forward} moves point forward as a side
|
|
14501 effect of a successful search. This is the action that changes the
|
|
14502 value of point so that the recursive function stops calling itself
|
|
14503 when point completes its movement through the region. Consequently,
|
|
14504 the @code{re-search-forward} expression is the next-step-expression.
|
|
14505
|
|
14506 @need 1200
|
|
14507 In outline, then, the body of the @code{recursive-count-words}
|
|
14508 function looks like this:
|
|
14509
|
|
14510 @smallexample
|
|
14511 @group
|
|
14512 (if @var{do-again-test-and-next-step-combined}
|
|
14513 ;; @r{then}
|
|
14514 @var{recursive-call-returning-count}
|
|
14515 ;; @r{else}
|
|
14516 @var{return-zero})
|
|
14517 @end group
|
|
14518 @end smallexample
|
|
14519
|
|
14520 How to incorporate the mechanism that counts?
|
|
14521
|
|
14522 If you are not used to writing recursive functions, a question like
|
|
14523 this can be troublesome. But it can and should be approached
|
|
14524 systematically.
|
|
14525
|
|
14526 We know that the counting mechanism should be associated in some way
|
|
14527 with the recursive call. Indeed, since the next-step-expression moves
|
|
14528 point forward by one word, and since a recursive call is made for
|
|
14529 each word, the counting mechanism must be an expression that adds one
|
|
14530 to the value returned by a call to @code{recursive-count-words}.
|
|
14531
|
|
14532 @need 800
|
|
14533 Consider several cases:
|
|
14534
|
|
14535 @itemize @bullet
|
|
14536 @item
|
|
14537 If there are two words in the region, the function should return
|
|
14538 a value resulting from adding one to the value returned when it counts
|
|
14539 the first word, plus the number returned when it counts the remaining
|
|
14540 words in the region, which in this case is one.
|
|
14541
|
|
14542 @item
|
|
14543 If there is one word in the region, the function should return
|
|
14544 a value resulting from adding one to the value returned when it counts
|
|
14545 that word, plus the number returned when it counts the remaining
|
|
14546 words in the region, which in this case is zero.
|
|
14547
|
|
14548 @item
|
|
14549 If there are no words in the region, the function should return zero.
|
|
14550 @end itemize
|
|
14551
|
|
14552 From the sketch we can see that the else-part of the @code{if} returns
|
|
14553 zero for the case of no words. This means that the then-part of the
|
|
14554 @code{if} must return a value resulting from adding one to the value
|
|
14555 returned from a count of the remaining words.
|
|
14556
|
|
14557 @need 1200
|
|
14558 The expression will look like this, where @code{1+} is a function that
|
|
14559 adds one to its argument.
|
|
14560
|
|
14561 @smallexample
|
|
14562 (1+ (recursive-count-words region-end))
|
|
14563 @end smallexample
|
|
14564
|
|
14565 @need 1200
|
|
14566 The whole @code{recursive-count-words} function will then look like
|
|
14567 this:
|
|
14568
|
|
14569 @smallexample
|
|
14570 @group
|
|
14571 (defun recursive-count-words (region-end)
|
|
14572 "@var{documentation}@dots{}"
|
|
14573
|
|
14574 ;;; @r{1. do-again-test}
|
|
14575 (if (and (< (point) region-end)
|
|
14576 (re-search-forward "\\w+\\W*" region-end t))
|
|
14577 @end group
|
|
14578
|
|
14579 @group
|
|
14580 ;;; @r{2. then-part: the recursive call}
|
|
14581 (1+ (recursive-count-words region-end))
|
|
14582
|
|
14583 ;;; @r{3. else-part}
|
|
14584 0))
|
|
14585 @end group
|
|
14586 @end smallexample
|
|
14587
|
|
14588 @need 1250
|
|
14589 Let's examine how this works:
|
|
14590
|
|
14591 If there are no words in the region, the else part of the @code{if}
|
|
14592 expression is evaluated and consequently the function returns zero.
|
|
14593
|
|
14594 If there is one word in the region, the value of point is less than
|
|
14595 the value of @code{region-end} and the search succeeds. In this case,
|
|
14596 the true-or-false-test of the @code{if} expression tests true, and the
|
|
14597 then-part of the @code{if} expression is evaluated. The counting
|
|
14598 expression is evaluated. This expression returns a value (which will
|
|
14599 be the value returned by the whole function) that is the sum of one
|
|
14600 added to the value returned by a recursive call.
|
|
14601
|
|
14602 Meanwhile, the next-step-expression has caused point to jump over the
|
|
14603 first (and in this case only) word in the region. This means that
|
|
14604 when @code{(recursive-count-words region-end)} is evaluated a second
|
|
14605 time, as a result of the recursive call, the value of point will be
|
|
14606 equal to or greater than the value of region end. So this time,
|
|
14607 @code{recursive-count-words} will return zero. The zero will be added
|
|
14608 to one, and the original evaluation of @code{recursive-count-words}
|
|
14609 will return one plus zero, which is one, which is the correct amount.
|
|
14610
|
|
14611 Clearly, if there are two words in the region, the first call to
|
|
14612 @code{recursive-count-words} returns one added to the value returned
|
|
14613 by calling @code{recursive-count-words} on a region containing the
|
|
14614 remaining word---that is, it adds one to one, producing two, which is
|
|
14615 the correct amount.
|
|
14616
|
|
14617 Similarly, if there are three words in the region, the first call to
|
|
14618 @code{recursive-count-words} returns one added to the value returned
|
|
14619 by calling @code{recursive-count-words} on a region containing the
|
|
14620 remaining two words---and so on and so on.
|
|
14621
|
|
14622 @need 1250
|
|
14623 @noindent
|
|
14624 With full documentation the two functions look like this:
|
|
14625
|
|
14626 @need 1250
|
|
14627 @noindent
|
|
14628 The recursive function:
|
|
14629
|
|
14630 @findex recursive-count-words
|
|
14631 @smallexample
|
|
14632 @group
|
|
14633 (defun recursive-count-words (region-end)
|
|
14634 "Number of words between point and REGION-END."
|
|
14635 @end group
|
|
14636
|
|
14637 @group
|
|
14638 ;;; @r{1. do-again-test}
|
|
14639 (if (and (< (point) region-end)
|
|
14640 (re-search-forward "\\w+\\W*" region-end t))
|
|
14641 @end group
|
|
14642
|
|
14643 @group
|
|
14644 ;;; @r{2. then-part: the recursive call}
|
|
14645 (1+ (recursive-count-words region-end))
|
|
14646
|
|
14647 ;;; @r{3. else-part}
|
|
14648 0))
|
|
14649 @end group
|
|
14650 @end smallexample
|
|
14651
|
|
14652 @need 800
|
|
14653 @noindent
|
|
14654 The wrapper:
|
|
14655
|
|
14656 @smallexample
|
|
14657 @group
|
|
14658 ;;; @r{Recursive version}
|
|
14659 (defun count-words-region (beginning end)
|
|
14660 "Print number of words in the region.
|
|
14661 @end group
|
|
14662
|
|
14663 @group
|
|
14664 Words are defined as at least one word-constituent
|
|
14665 character followed by at least one character that is
|
|
14666 not a word-constituent. The buffer's syntax table
|
|
14667 determines which characters these are."
|
|
14668 @end group
|
|
14669 @group
|
|
14670 (interactive "r")
|
|
14671 (message "Counting words in region ... ")
|
|
14672 (save-excursion
|
|
14673 (goto-char beginning)
|
|
14674 (let ((count (recursive-count-words end)))
|
|
14675 @end group
|
|
14676 @group
|
|
14677 (cond ((zerop count)
|
|
14678 (message
|
|
14679 "The region does NOT have any words."))
|
|
14680 @end group
|
|
14681 @group
|
|
14682 ((= 1 count)
|
|
14683 (message "The region has 1 word."))
|
|
14684 (t
|
|
14685 (message
|
|
14686 "The region has %d words." count))))))
|
|
14687 @end group
|
|
14688 @end smallexample
|
|
14689
|
|
14690 @node Counting Exercise, , recursive-count-words, Counting Words
|
|
14691 @section Exercise: Counting Punctuation
|
|
14692
|
|
14693 Using a @code{while} loop, write a function to count the number of
|
|
14694 punctuation marks in a region---period, comma, semicolon, colon,
|
|
14695 exclamation mark, and question mark. Do the same using recursion.
|
|
14696
|
|
14697 @node Words in a defun, Readying a Graph, Counting Words, Top
|
|
14698 @chapter Counting Words in a @code{defun}
|
|
14699 @cindex Counting words in a @code{defun}
|
|
14700 @cindex Word counting in a @code{defun}
|
|
14701
|
|
14702 Our next project is to count the number of words in a function
|
|
14703 definition. Clearly, this can be done using some variant of
|
|
14704 @code{count-word-region}. @xref{Counting Words, , Counting Words:
|
|
14705 Repetition and Regexps}. If we are just going to count the words in
|
|
14706 one definition, it is easy enough to mark the definition with the
|
|
14707 @kbd{C-M-h} (@code{mark-defun}) command, and then call
|
|
14708 @code{count-word-region}.
|
|
14709
|
|
14710 However, I am more ambitious: I want to count the words and symbols in
|
|
14711 every definition in the Emacs sources and then print a graph that
|
|
14712 shows how many functions there are of each length: how many contain 40
|
|
14713 to 49 words or symbols, how many contain 50 to 59 words or symbols,
|
|
14714 and so on. I have often been curious how long a typical function is,
|
|
14715 and this will tell.
|
|
14716
|
|
14717 @menu
|
|
14718 * Divide and Conquer::
|
|
14719 * Words and Symbols:: What to count?
|
|
14720 * Syntax:: What constitutes a word or symbol?
|
|
14721 * count-words-in-defun:: Very like @code{count-words}.
|
|
14722 * Several defuns:: Counting several defuns in a file.
|
|
14723 * Find a File:: Do you want to look at a file?
|
|
14724 * lengths-list-file:: A list of the lengths of many definitions.
|
|
14725 * Several files:: Counting in definitions in different files.
|
|
14726 * Several files recursively:: Recursively counting in different files.
|
|
14727 * Prepare the data:: Prepare the data for display in a graph.
|
|
14728 @end menu
|
|
14729
|
|
14730 @node Divide and Conquer, Words and Symbols, Words in a defun, Words in a defun
|
|
14731 @ifnottex
|
|
14732 @unnumberedsec Divide and Conquer
|
|
14733 @end ifnottex
|
|
14734
|
|
14735 Described in one phrase, the histogram project is daunting; but
|
|
14736 divided into numerous small steps, each of which we can take one at a
|
|
14737 time, the project becomes less fearsome. Let us consider what the
|
|
14738 steps must be:
|
|
14739
|
|
14740 @itemize @bullet
|
|
14741 @item
|
|
14742 First, write a function to count the words in one definition. This
|
|
14743 includes the problem of handling symbols as well as words.
|
|
14744
|
|
14745 @item
|
|
14746 Second, write a function to list the numbers of words in each function
|
|
14747 in a file. This function can use the @code{count-words-in-defun}
|
|
14748 function.
|
|
14749
|
|
14750 @item
|
|
14751 Third, write a function to list the numbers of words in each function
|
|
14752 in each of several files. This entails automatically finding the
|
|
14753 various files, switching to them, and counting the words in the
|
|
14754 definitions within them.
|
|
14755
|
|
14756 @item
|
|
14757 Fourth, write a function to convert the list of numbers that we
|
|
14758 created in step three to a form that will be suitable for printing as
|
|
14759 a graph.
|
|
14760
|
|
14761 @item
|
|
14762 Fifth, write a function to print the results as a graph.
|
|
14763 @end itemize
|
|
14764
|
|
14765 This is quite a project! But if we take each step slowly, it will not
|
|
14766 be difficult.
|
|
14767
|
|
14768 @node Words and Symbols, Syntax, Divide and Conquer, Words in a defun
|
|
14769 @section What to Count?
|
|
14770 @cindex Words and symbols in defun
|
|
14771
|
|
14772 When we first start thinking about how to count the words in a
|
|
14773 function definition, the first question is (or ought to be) what are
|
|
14774 we going to count? When we speak of `words' with respect to a Lisp
|
|
14775 function definition, we are actually speaking, in large part, of
|
|
14776 `symbols'. For example, the following @code{multiply-by-seven}
|
|
14777 function contains the five symbols @code{defun},
|
|
14778 @code{multiply-by-seven}, @code{number}, @code{*}, and @code{7}. In
|
|
14779 addition, in the documentation string, it contains the four words
|
|
14780 @samp{Multiply}, @samp{NUMBER}, @samp{by}, and @samp{seven}. The
|
|
14781 symbol @samp{number} is repeated, so the definition contains a total
|
|
14782 of ten words and symbols.
|
|
14783
|
|
14784 @smallexample
|
|
14785 @group
|
|
14786 (defun multiply-by-seven (number)
|
|
14787 "Multiply NUMBER by seven."
|
|
14788 (* 7 number))
|
|
14789 @end group
|
|
14790 @end smallexample
|
|
14791
|
|
14792 @noindent
|
|
14793 However, if we mark the @code{multiply-by-seven} definition with
|
|
14794 @kbd{C-M-h} (@code{mark-defun}), and then call
|
|
14795 @code{count-words-region} on it, we will find that
|
|
14796 @code{count-words-region} claims the definition has eleven words, not
|
|
14797 ten! Something is wrong!
|
|
14798
|
|
14799 The problem is twofold: @code{count-words-region} does not count the
|
|
14800 @samp{*} as a word, and it counts the single symbol,
|
|
14801 @code{multiply-by-seven}, as containing three words. The hyphens are
|
|
14802 treated as if they were interword spaces rather than intraword
|
|
14803 connectors: @samp{multiply-by-seven} is counted as if it were written
|
|
14804 @samp{multiply by seven}.
|
|
14805
|
|
14806 The cause of this confusion is the regular expression search within
|
|
14807 the @code{count-words-region} definition that moves point forward word
|
|
14808 by word. In the canonical version of @code{count-words-region}, the
|
|
14809 regexp is:
|
|
14810
|
|
14811 @smallexample
|
|
14812 "\\w+\\W*"
|
|
14813 @end smallexample
|
|
14814
|
|
14815 @noindent
|
|
14816 This regular expression is a pattern defining one or more word
|
|
14817 constituent characters possibly followed by one or more characters
|
|
14818 that are not word constituents. What is meant by `word constituent
|
|
14819 characters' brings us to the issue of syntax, which is worth a section
|
|
14820 of its own.
|
|
14821
|
|
14822 @node Syntax, count-words-in-defun, Words and Symbols, Words in a defun
|
|
14823 @section What Constitutes a Word or Symbol?
|
|
14824 @cindex Syntax categories and tables
|
|
14825
|
|
14826 Emacs treats different characters as belonging to different
|
|
14827 @dfn{syntax categories}. For example, the regular expression,
|
|
14828 @samp{\\w+}, is a pattern specifying one or more @emph{word
|
|
14829 constituent} characters. Word constituent characters are members of
|
|
14830 one syntax category. Other syntax categories include the class of
|
|
14831 punctuation characters, such as the period and the comma, and the
|
|
14832 class of whitespace characters, such as the blank space and the tab
|
|
14833 character. (For more information, see @ref{Syntax, Syntax, The Syntax
|
|
14834 Table, emacs, The GNU Emacs Manual}, and @ref{Syntax Tables, , Syntax
|
|
14835 Tables, elisp, The GNU Emacs Lisp Reference Manual}.)
|
|
14836
|
|
14837 Syntax tables specify which characters belong to which categories.
|
|
14838 Usually, a hyphen is not specified as a `word constituent character'.
|
|
14839 Instead, it is specified as being in the `class of characters that are
|
|
14840 part of symbol names but not words.' This means that the
|
|
14841 @code{count-words-region} function treats it in the same way it treats
|
|
14842 an interword white space, which is why @code{count-words-region}
|
|
14843 counts @samp{multiply-by-seven} as three words.
|
|
14844
|
|
14845 There are two ways to cause Emacs to count @samp{multiply-by-seven} as
|
|
14846 one symbol: modify the syntax table or modify the regular expression.
|
|
14847
|
|
14848 We could redefine a hyphen as a word constituent character by
|
|
14849 modifying the syntax table that Emacs keeps for each mode. This
|
|
14850 action would serve our purpose, except that a hyphen is merely the
|
|
14851 most common character within symbols that is not typically a word
|
|
14852 constituent character; there are others, too.
|
|
14853
|
|
14854 Alternatively, we can redefine the regular expression used in the
|
|
14855 @code{count-words} definition so as to include symbols. This
|
|
14856 procedure has the merit of clarity, but the task is a little tricky.
|
|
14857
|
|
14858 @need 1200
|
|
14859 The first part is simple enough: the pattern must match ``at least one
|
|
14860 character that is a word or symbol constituent''. Thus:
|
|
14861
|
|
14862 @smallexample
|
|
14863 "\\(\\w\\|\\s_\\)+"
|
|
14864 @end smallexample
|
|
14865
|
|
14866 @noindent
|
|
14867 The @samp{\\(} is the first part of the grouping construct that
|
|
14868 includes the @samp{\\w} and the @samp{\\s_} as alternatives, separated
|
|
14869 by the @samp{\\|}. The @samp{\\w} matches any word-constituent
|
|
14870 character and the @samp{\\s_} matches any character that is part of a
|
|
14871 symbol name but not a word-constituent character. The @samp{+}
|
|
14872 following the group indicates that the word or symbol constituent
|
|
14873 characters must be matched at least once.
|
|
14874
|
|
14875 However, the second part of the regexp is more difficult to design.
|
|
14876 What we want is to follow the first part with ``optionally one or more
|
|
14877 characters that are not constituents of a word or symbol''. At first,
|
|
14878 I thought I could define this with the following:
|
|
14879
|
|
14880 @smallexample
|
|
14881 "\\(\\W\\|\\S_\\)*"
|
|
14882 @end smallexample
|
|
14883
|
|
14884 @noindent
|
|
14885 The upper case @samp{W} and @samp{S} match characters that are
|
|
14886 @emph{not} word or symbol constituents. Unfortunately, this
|
|
14887 expression matches any character that is either not a word constituent
|
|
14888 or not a symbol constituent. This matches any character!
|
|
14889
|
|
14890 I then noticed that every word or symbol in my test region was
|
|
14891 followed by white space (blank space, tab, or newline). So I tried
|
|
14892 placing a pattern to match one or more blank spaces after the pattern
|
|
14893 for one or more word or symbol constituents. This failed, too. Words
|
|
14894 and symbols are often separated by whitespace, but in actual code
|
|
14895 parentheses may follow symbols and punctuation may follow words. So
|
|
14896 finally, I designed a pattern in which the word or symbol constituents
|
|
14897 are followed optionally by characters that are not white space and
|
|
14898 then followed optionally by white space.
|
|
14899
|
|
14900 @need 800
|
|
14901 Here is the full regular expression:
|
|
14902
|
|
14903 @smallexample
|
|
14904 "\\(\\w\\|\\s_\\)+[^ \t\n]*[ \t\n]*"
|
|
14905 @end smallexample
|
|
14906
|
|
14907 @node count-words-in-defun, Several defuns, Syntax, Words in a defun
|
|
14908 @section The @code{count-words-in-defun} Function
|
|
14909 @cindex Counting words in a @code{defun}
|
|
14910
|
|
14911 We have seen that there are several ways to write a
|
|
14912 @code{count-word-region} function. To write a
|
|
14913 @code{count-words-in-defun}, we need merely adapt one of these
|
|
14914 versions.
|
|
14915
|
|
14916 The version that uses a @code{while} loop is easy to understand, so I
|
|
14917 am going to adapt that. Because @code{count-words-in-defun} will be
|
|
14918 part of a more complex program, it need not be interactive and it need
|
|
14919 not display a message but just return the count. These considerations
|
|
14920 simplify the definition a little.
|
|
14921
|
|
14922 On the other hand, @code{count-words-in-defun} will be used within a
|
|
14923 buffer that contains function definitions. Consequently, it is
|
|
14924 reasonable to ask that the function determine whether it is called
|
|
14925 when point is within a function definition, and if it is, to return
|
|
14926 the count for that definition. This adds complexity to the
|
|
14927 definition, but saves us from needing to pass arguments to the
|
|
14928 function.
|
|
14929
|
|
14930 @need 1250
|
|
14931 These considerations lead us to prepare the following template:
|
|
14932
|
|
14933 @smallexample
|
|
14934 @group
|
|
14935 (defun count-words-in-defun ()
|
|
14936 "@var{documentation}@dots{}"
|
|
14937 (@var{set up}@dots{}
|
|
14938 (@var{while loop}@dots{})
|
|
14939 @var{return count})
|
|
14940 @end group
|
|
14941 @end smallexample
|
|
14942
|
|
14943 @noindent
|
|
14944 As usual, our job is to fill in the slots.
|
|
14945
|
|
14946 First, the set up.
|
|
14947
|
|
14948 We are presuming that this function will be called within a buffer
|
|
14949 containing function definitions. Point will either be within a
|
|
14950 function definition or not. For @code{count-words-in-defun} to work,
|
|
14951 point must move to the beginning of the definition, a counter must
|
|
14952 start at zero, and the counting loop must stop when point reaches the
|
|
14953 end of the definition.
|
|
14954
|
|
14955 The @code{beginning-of-defun} function searches backwards for an
|
|
14956 opening delimiter such as a @samp{(} at the beginning of a line, and
|
|
14957 moves point to that position, or else to the limit of the search. In
|
|
14958 practice, this means that @code{beginning-of-defun} moves point to the
|
|
14959 beginning of an enclosing or preceding function definition, or else to
|
|
14960 the beginning of the buffer. We can use @code{beginning-of-defun} to
|
|
14961 place point where we wish to start.
|
|
14962
|
|
14963 The @code{while} loop requires a counter to keep track of the words or
|
|
14964 symbols being counted. A @code{let} expression can be used to create
|
|
14965 a local variable for this purpose, and bind it to an initial value of zero.
|
|
14966
|
|
14967 The @code{end-of-defun} function works like @code{beginning-of-defun}
|
|
14968 except that it moves point to the end of the definition.
|
|
14969 @code{end-of-defun} can be used as part of an expression that
|
|
14970 determines the position of the end of the definition.
|
|
14971
|
|
14972 The set up for @code{count-words-in-defun} takes shape rapidly: first
|
|
14973 we move point to the beginning of the definition, then we create a
|
|
14974 local variable to hold the count, and finally, we record the position
|
|
14975 of the end of the definition so the @code{while} loop will know when to stop
|
|
14976 looping.
|
|
14977
|
|
14978 @need 1250
|
|
14979 The code looks like this:
|
|
14980
|
|
14981 @smallexample
|
|
14982 @group
|
|
14983 (beginning-of-defun)
|
|
14984 (let ((count 0)
|
|
14985 (end (save-excursion (end-of-defun) (point))))
|
|
14986 @end group
|
|
14987 @end smallexample
|
|
14988
|
|
14989 @noindent
|
|
14990 The code is simple. The only slight complication is likely to concern
|
|
14991 @code{end}: it is bound to the position of the end of the definition
|
|
14992 by a @code{save-excursion} expression that returns the value of point
|
|
14993 after @code{end-of-defun} temporarily moves it to the end of the
|
|
14994 definition.
|
|
14995
|
|
14996 The second part of the @code{count-words-in-defun}, after the set up,
|
|
14997 is the @code{while} loop.
|
|
14998
|
|
14999 The loop must contain an expression that jumps point forward word by
|
|
15000 word and symbol by symbol, and another expression that counts the
|
|
15001 jumps. The true-or-false-test for the @code{while} loop should test
|
|
15002 true so long as point should jump forward, and false when point is at
|
|
15003 the end of the definition. We have already redefined the regular
|
|
15004 expression for this (@pxref{Syntax}), so the loop is straightforward:
|
|
15005
|
|
15006 @smallexample
|
|
15007 @group
|
|
15008 (while (and (< (point) end)
|
|
15009 (re-search-forward
|
|
15010 "\\(\\w\\|\\s_\\)+[^ \t\n]*[ \t\n]*" end t)
|
|
15011 (setq count (1+ count)))
|
|
15012 @end group
|
|
15013 @end smallexample
|
|
15014
|
|
15015 The third part of the function definition returns the count of words
|
|
15016 and symbols. This part is the last expression within the body of the
|
|
15017 @code{let} expression, and can be, very simply, the local variable
|
|
15018 @code{count}, which when evaluated returns the count.
|
|
15019
|
|
15020 @need 1250
|
|
15021 Put together, the @code{count-words-in-defun} definition looks like this:
|
|
15022
|
|
15023 @findex count-words-in-defun
|
|
15024 @smallexample
|
|
15025 @group
|
|
15026 (defun count-words-in-defun ()
|
|
15027 "Return the number of words and symbols in a defun."
|
|
15028 (beginning-of-defun)
|
|
15029 (let ((count 0)
|
|
15030 (end (save-excursion (end-of-defun) (point))))
|
|
15031 @end group
|
|
15032 @group
|
|
15033 (while
|
|
15034 (and (< (point) end)
|
|
15035 (re-search-forward
|
|
15036 "\\(\\w\\|\\s_\\)+[^ \t\n]*[ \t\n]*"
|
|
15037 end t))
|
|
15038 (setq count (1+ count)))
|
|
15039 count))
|
|
15040 @end group
|
|
15041 @end smallexample
|
|
15042
|
|
15043 How to test this? The function is not interactive, but it is easy to
|
|
15044 put a wrapper around the function to make it interactive; we can use
|
|
15045 almost the same code as for the recursive version of
|
|
15046 @code{count-words-region}:
|
|
15047
|
|
15048 @smallexample
|
|
15049 @group
|
|
15050 ;;; @r{Interactive version.}
|
|
15051 (defun count-words-defun ()
|
|
15052 "Number of words and symbols in a function definition."
|
|
15053 (interactive)
|
|
15054 (message
|
|
15055 "Counting words and symbols in function definition ... ")
|
|
15056 @end group
|
|
15057 @group
|
|
15058 (let ((count (count-words-in-defun)))
|
|
15059 (cond
|
|
15060 ((zerop count)
|
|
15061 (message
|
|
15062 "The definition does NOT have any words or symbols."))
|
|
15063 @end group
|
|
15064 @group
|
|
15065 ((= 1 count)
|
|
15066 (message
|
|
15067 "The definition has 1 word or symbol."))
|
|
15068 (t
|
|
15069 (message
|
|
15070 "The definition has %d words or symbols." count)))))
|
|
15071 @end group
|
|
15072 @end smallexample
|
|
15073
|
|
15074 @need 800
|
|
15075 @noindent
|
|
15076 Let's re-use @kbd{C-c =} as a convenient keybinding:
|
|
15077
|
|
15078 @smallexample
|
|
15079 (global-set-key "\C-c=" 'count-words-defun)
|
|
15080 @end smallexample
|
|
15081
|
|
15082 Now we can try out @code{count-words-defun}: install both
|
|
15083 @code{count-words-in-defun} and @code{count-words-defun}, and set the
|
|
15084 keybinding, and then place the cursor within the following definition:
|
|
15085
|
|
15086 @smallexample
|
|
15087 @group
|
|
15088 (defun multiply-by-seven (number)
|
|
15089 "Multiply NUMBER by seven."
|
|
15090 (* 7 number))
|
|
15091 @result{} 10
|
|
15092 @end group
|
|
15093 @end smallexample
|
|
15094
|
|
15095 @noindent
|
|
15096 Success! The definition has 10 words and symbols.
|
|
15097
|
|
15098 The next problem is to count the numbers of words and symbols in
|
|
15099 several definitions within a single file.
|
|
15100
|
|
15101 @node Several defuns, Find a File, count-words-in-defun, Words in a defun
|
|
15102 @section Count Several @code{defuns} Within a File
|
|
15103
|
|
15104 A file such as @file{simple.el} may have a hundred or more function
|
|
15105 definitions within it. Our long term goal is to collect statistics on
|
|
15106 many files, but as a first step, our immediate goal is to collect
|
|
15107 statistics on one file.
|
|
15108
|
|
15109 The information will be a series of numbers, each number being the
|
|
15110 length of a function definition. We can store the numbers in a list.
|
|
15111
|
|
15112 We know that we will want to incorporate the information regarding one
|
|
15113 file with information about many other files; this means that the
|
|
15114 function for counting definition lengths within one file need only
|
|
15115 return the list of lengths. It need not and should not display any
|
|
15116 messages.
|
|
15117
|
|
15118 The word count commands contain one expression to jump point forward
|
|
15119 word by word and another expression to count the jumps. The function
|
|
15120 to return the lengths of definitions can be designed to work the same
|
|
15121 way, with one expression to jump point forward definition by
|
|
15122 definition and another expression to construct the lengths' list.
|
|
15123
|
|
15124 This statement of the problem makes it elementary to write the
|
|
15125 function definition. Clearly, we will start the count at the
|
|
15126 beginning of the file, so the first command will be @code{(goto-char
|
|
15127 (point-min))}. Next, we start the @code{while} loop; and the
|
|
15128 true-or-false test of the loop can be a regular expression search for
|
|
15129 the next function definition---so long as the search succeeds, point
|
|
15130 is moved forward and then the body of the loop is evaluated. The body
|
|
15131 needs an expression that constructs the lengths' list. @code{cons},
|
|
15132 the list construction command, can be used to create the list. That
|
|
15133 is almost all there is to it.
|
|
15134
|
|
15135 @need 800
|
|
15136 Here is what this fragment of code looks like:
|
|
15137
|
|
15138 @smallexample
|
|
15139 @group
|
|
15140 (goto-char (point-min))
|
|
15141 (while (re-search-forward "^(defun" nil t)
|
|
15142 (setq lengths-list
|
|
15143 (cons (count-words-in-defun) lengths-list)))
|
|
15144 @end group
|
|
15145 @end smallexample
|
|
15146
|
|
15147 What we have left out is the mechanism for finding the file that
|
|
15148 contains the function definitions.
|
|
15149
|
|
15150 In previous examples, we either used this, the Info file, or we
|
|
15151 switched back and forth to some other buffer, such as the
|
|
15152 @file{*scratch*} buffer.
|
|
15153
|
|
15154 Finding a file is a new process that we have not yet discussed.
|
|
15155
|
|
15156 @node Find a File, lengths-list-file, Several defuns, Words in a defun
|
|
15157 @comment node-name, next, previous, up
|
|
15158 @section Find a File
|
|
15159 @cindex Find a File
|
|
15160
|
|
15161 To find a file in Emacs, you use the @kbd{C-x C-f} (@code{find-file})
|
|
15162 command. This command is almost, but not quite right for the lengths
|
|
15163 problem.
|
|
15164
|
|
15165 @need 1200
|
|
15166 Let's look at the source for @code{find-file}:
|
|
15167
|
|
15168 @smallexample
|
|
15169 @group
|
|
15170 (defun find-file (filename)
|
|
15171 "Edit file FILENAME.
|
|
15172 Switch to a buffer visiting file FILENAME,
|
|
15173 creating one if none already exists."
|
|
15174 (interactive "FFind file: ")
|
|
15175 (switch-to-buffer (find-file-noselect filename)))
|
|
15176 @end group
|
|
15177 @end smallexample
|
|
15178
|
|
15179 @noindent
|
|
15180 (The most recent version of the @code{find-file} function definition
|
|
15181 permits you to specify optional wildcards to visit multiple files; that
|
|
15182 makes the definition more complex and we will not discuss it here,
|
|
15183 since it is not relevant. You can see its source using either
|
|
15184 @kbd{M-.} (@code{find-tag}) or @kbd{C-h f} (@code{describe-function}).)
|
|
15185
|
|
15186 @ignore
|
|
15187 In Emacs 22
|
|
15188 (defun find-file (filename &optional wildcards)
|
|
15189 "Edit file FILENAME.
|
|
15190 Switch to a buffer visiting file FILENAME,
|
|
15191 creating one if none already exists.
|
|
15192 Interactively, the default if you just type RET is the current directory,
|
|
15193 but the visited file name is available through the minibuffer history:
|
|
15194 type M-n to pull it into the minibuffer.
|
|
15195
|
|
15196 Interactively, or if WILDCARDS is non-nil in a call from Lisp,
|
|
15197 expand wildcards (if any) and visit multiple files. You can
|
|
15198 suppress wildcard expansion by setting `find-file-wildcards' to nil.
|
|
15199
|
|
15200 To visit a file without any kind of conversion and without
|
|
15201 automatically choosing a major mode, use \\[find-file-literally]."
|
|
15202 (interactive (find-file-read-args "Find file: " nil))
|
|
15203 (let ((value (find-file-noselect filename nil nil wildcards)))
|
|
15204 (if (listp value)
|
|
15205 (mapcar 'switch-to-buffer (nreverse value))
|
|
15206 (switch-to-buffer value))))
|
|
15207 @end ignore
|
|
15208
|
|
15209 The definition I am showing possesses short but complete documentation
|
|
15210 and an interactive specification that prompts you for a file name when
|
|
15211 you use the command interactively. The body of the definition
|
|
15212 contains two functions, @code{find-file-noselect} and
|
|
15213 @code{switch-to-buffer}.
|
|
15214
|
|
15215 According to its documentation as shown by @kbd{C-h f} (the
|
|
15216 @code{describe-function} command), the @code{find-file-noselect}
|
|
15217 function reads the named file into a buffer and returns the buffer.
|
|
15218 (Its most recent version includes an optional wildcards argument,
|
|
15219 too, as well as another to read a file literally and an other you
|
|
15220 suppress warning messages. These optional arguments are irrelevant.)
|
|
15221
|
|
15222 However, the @code{find-file-noselect} function does not select the
|
|
15223 buffer in which it puts the file. Emacs does not switch its attention
|
|
15224 (or yours if you are using @code{find-file-noselect}) to the selected
|
|
15225 buffer. That is what @code{switch-to-buffer} does: it switches the
|
|
15226 buffer to which Emacs attention is directed; and it switches the
|
|
15227 buffer displayed in the window to the new buffer. We have discussed
|
|
15228 buffer switching elsewhere. (@xref{Switching Buffers}.)
|
|
15229
|
|
15230 In this histogram project, we do not need to display each file on the
|
|
15231 screen as the program determines the length of each definition within
|
|
15232 it. Instead of employing @code{switch-to-buffer}, we can work with
|
|
15233 @code{set-buffer}, which redirects the attention of the computer
|
|
15234 program to a different buffer but does not redisplay it on the screen.
|
|
15235 So instead of calling on @code{find-file} to do the job, we must write
|
|
15236 our own expression.
|
|
15237
|
|
15238 The task is easy: use @code{find-file-noselect} and @code{set-buffer}.
|
|
15239
|
|
15240 @node lengths-list-file, Several files, Find a File, Words in a defun
|
|
15241 @section @code{lengths-list-file} in Detail
|
|
15242
|
|
15243 The core of the @code{lengths-list-file} function is a @code{while}
|
|
15244 loop containing a function to move point forward `defun by defun' and
|
|
15245 a function to count the number of words and symbols in each defun.
|
|
15246 This core must be surrounded by functions that do various other tasks,
|
|
15247 including finding the file, and ensuring that point starts out at the
|
|
15248 beginning of the file. The function definition looks like this:
|
|
15249 @findex lengths-list-file
|
|
15250
|
|
15251 @smallexample
|
|
15252 @group
|
|
15253 (defun lengths-list-file (filename)
|
|
15254 "Return list of definitions' lengths within FILE.
|
|
15255 The returned list is a list of numbers.
|
|
15256 Each number is the number of words or
|
|
15257 symbols in one function definition."
|
|
15258 @end group
|
|
15259 @group
|
|
15260 (message "Working on `%s' ... " filename)
|
|
15261 (save-excursion
|
|
15262 (let ((buffer (find-file-noselect filename))
|
|
15263 (lengths-list))
|
|
15264 (set-buffer buffer)
|
|
15265 (setq buffer-read-only t)
|
|
15266 (widen)
|
|
15267 (goto-char (point-min))
|
|
15268 (while (re-search-forward "^(defun" nil t)
|
|
15269 (setq lengths-list
|
|
15270 (cons (count-words-in-defun) lengths-list)))
|
|
15271 (kill-buffer buffer)
|
|
15272 lengths-list)))
|
|
15273 @end group
|
|
15274 @end smallexample
|
|
15275
|
|
15276 @noindent
|
|
15277 The function is passed one argument, the name of the file on which it
|
|
15278 will work. It has four lines of documentation, but no interactive
|
|
15279 specification. Since people worry that a computer is broken if they
|
|
15280 don't see anything going on, the first line of the body is a
|
|
15281 message.
|
|
15282
|
|
15283 The next line contains a @code{save-excursion} that returns Emacs'
|
|
15284 attention to the current buffer when the function completes. This is
|
|
15285 useful in case you embed this function in another function that
|
|
15286 presumes point is restored to the original buffer.
|
|
15287
|
|
15288 In the varlist of the @code{let} expression, Emacs finds the file and
|
|
15289 binds the local variable @code{buffer} to the buffer containing the
|
|
15290 file. At the same time, Emacs creates @code{lengths-list} as a local
|
|
15291 variable.
|
|
15292
|
|
15293 Next, Emacs switches its attention to the buffer.
|
|
15294
|
|
15295 In the following line, Emacs makes the buffer read-only. Ideally,
|
|
15296 this line is not necessary. None of the functions for counting words
|
|
15297 and symbols in a function definition should change the buffer.
|
|
15298 Besides, the buffer is not going to be saved, even if it were changed.
|
|
15299 This line is entirely the consequence of great, perhaps excessive,
|
|
15300 caution. The reason for the caution is that this function and those
|
|
15301 it calls work on the sources for Emacs and it is inconvenient if they
|
|
15302 are inadvertently modified. It goes without saying that I did not
|
|
15303 realize a need for this line until an experiment went awry and started
|
|
15304 to modify my Emacs source files @dots{}
|
|
15305
|
|
15306 Next comes a call to widen the buffer if it is narrowed. This
|
|
15307 function is usually not needed---Emacs creates a fresh buffer if none
|
|
15308 already exists; but if a buffer visiting the file already exists Emacs
|
|
15309 returns that one. In this case, the buffer may be narrowed and must
|
|
15310 be widened. If we wanted to be fully `user-friendly', we would
|
|
15311 arrange to save the restriction and the location of point, but we
|
|
15312 won't.
|
|
15313
|
|
15314 The @code{(goto-char (point-min))} expression moves point to the
|
|
15315 beginning of the buffer.
|
|
15316
|
|
15317 Then comes a @code{while} loop in which the `work' of the function is
|
|
15318 carried out. In the loop, Emacs determines the length of each
|
|
15319 definition and constructs a lengths' list containing the information.
|
|
15320
|
|
15321 Emacs kills the buffer after working through it. This is to save
|
|
15322 space inside of Emacs. My version of GNU Emacs 19 contained over 300
|
|
15323 source files of interest; GNU Emacs 22 contains over a thousand source
|
|
15324 files. Another function will apply @code{lengths-list-file} to each
|
|
15325 of the files.
|
|
15326
|
|
15327 Finally, the last expression within the @code{let} expression is the
|
|
15328 @code{lengths-list} variable; its value is returned as the value of
|
|
15329 the whole function.
|
|
15330
|
|
15331 You can try this function by installing it in the usual fashion. Then
|
|
15332 place your cursor after the following expression and type @kbd{C-x
|
|
15333 C-e} (@code{eval-last-sexp}).
|
|
15334
|
|
15335 @c !!! 22.1.1 lisp sources location here
|
|
15336 @smallexample
|
|
15337 (lengths-list-file
|
|
15338 "/usr/local/share/emacs/22.1.1/lisp/emacs-lisp/debug.el")
|
|
15339 @end smallexample
|
|
15340
|
|
15341 @noindent
|
|
15342 (You may need to change the pathname of the file; the one here is for
|
|
15343 GNU Emacs version 22.1.1. To change the expression, copy it to
|
|
15344 the @file{*scratch*} buffer and edit it.
|
|
15345
|
|
15346 @need 1200
|
|
15347 @noindent
|
|
15348 (Also, to see the full length of the list, rather than a truncated
|
|
15349 version, you may have to evaluate the following:
|
|
15350
|
|
15351 @smallexample
|
|
15352 (custom-set-variables '(eval-expression-print-length nil))
|
|
15353 @end smallexample
|
|
15354
|
|
15355 @noindent
|
|
15356 (@xref{defcustom, , Specifying Variables using @code{defcustom}}.
|
|
15357 Then evaluate the @code{lengths-list-file} expression.)
|
|
15358
|
|
15359 @need 1200
|
|
15360 The lengths' list for @file{debug.el} takes less than a second to
|
|
15361 produce and looks like this in GNU Emacs 22:
|
|
15362
|
|
15363 @smallexample
|
|
15364 (83 113 105 144 289 22 30 97 48 89 25 52 52 88 28 29 77 49 43 290 232 587)
|
|
15365 @end smallexample
|
|
15366
|
|
15367 @need 1500
|
|
15368 (Using my old machine, the version 19 lengths' list for @file{debug.el}
|
|
15369 took seven seconds to produce and looked like this:
|
|
15370
|
|
15371 @smallexample
|
|
15372 (75 41 80 62 20 45 44 68 45 12 34 235)
|
|
15373 @end smallexample
|
|
15374
|
|
15375 (The newer version of @file{debug.el} contains more defuns than the
|
|
15376 earlier one; and my new machine is much faster than the old one.)
|
|
15377
|
|
15378 Note that the length of the last definition in the file is first in
|
|
15379 the list.
|
|
15380
|
|
15381 @node Several files, Several files recursively, lengths-list-file, Words in a defun
|
|
15382 @section Count Words in @code{defuns} in Different Files
|
|
15383
|
|
15384 In the previous section, we created a function that returns a list of
|
|
15385 the lengths of each definition in a file. Now, we want to define a
|
|
15386 function to return a master list of the lengths of the definitions in
|
|
15387 a list of files.
|
|
15388
|
|
15389 Working on each of a list of files is a repetitious act, so we can use
|
|
15390 either a @code{while} loop or recursion.
|
|
15391
|
|
15392 @menu
|
|
15393 * lengths-list-many-files:: Return a list of the lengths of defuns.
|
|
15394 * append:: Attach one list to another.
|
|
15395 @end menu
|
|
15396
|
|
15397 @node lengths-list-many-files, append, Several files, Several files
|
|
15398 @ifnottex
|
|
15399 @unnumberedsubsec Determine the lengths of @code{defuns}
|
|
15400 @end ifnottex
|
|
15401
|
|
15402 The design using a @code{while} loop is routine. The argument passed
|
|
15403 the function is a list of files. As we saw earlier (@pxref{Loop
|
|
15404 Example}), you can write a @code{while} loop so that the body of the
|
|
15405 loop is evaluated if such a list contains elements, but to exit the
|
|
15406 loop if the list is empty. For this design to work, the body of the
|
|
15407 loop must contain an expression that shortens the list each time the
|
|
15408 body is evaluated, so that eventually the list is empty. The usual
|
|
15409 technique is to set the value of the list to the value of the @sc{cdr}
|
|
15410 of the list each time the body is evaluated.
|
|
15411
|
|
15412 @need 800
|
|
15413 The template looks like this:
|
|
15414
|
|
15415 @smallexample
|
|
15416 @group
|
|
15417 (while @var{test-whether-list-is-empty}
|
|
15418 @var{body}@dots{}
|
|
15419 @var{set-list-to-cdr-of-list})
|
|
15420 @end group
|
|
15421 @end smallexample
|
|
15422
|
|
15423 Also, we remember that a @code{while} loop returns @code{nil} (the
|
|
15424 result of evaluating the true-or-false-test), not the result of any
|
|
15425 evaluation within its body. (The evaluations within the body of the
|
|
15426 loop are done for their side effects.) However, the expression that
|
|
15427 sets the lengths' list is part of the body---and that is the value
|
|
15428 that we want returned by the function as a whole. To do this, we
|
|
15429 enclose the @code{while} loop within a @code{let} expression, and
|
|
15430 arrange that the last element of the @code{let} expression contains
|
|
15431 the value of the lengths' list. (@xref{Incrementing Example, , Loop
|
|
15432 Example with an Incrementing Counter}.)
|
|
15433
|
|
15434 @findex lengths-list-many-files
|
|
15435 @need 1250
|
|
15436 These considerations lead us directly to the function itself:
|
|
15437
|
|
15438 @smallexample
|
|
15439 @group
|
|
15440 ;;; @r{Use @code{while} loop.}
|
|
15441 (defun lengths-list-many-files (list-of-files)
|
|
15442 "Return list of lengths of defuns in LIST-OF-FILES."
|
|
15443 @end group
|
|
15444 @group
|
|
15445 (let (lengths-list)
|
|
15446
|
|
15447 ;;; @r{true-or-false-test}
|
|
15448 (while list-of-files
|
|
15449 (setq lengths-list
|
|
15450 (append
|
|
15451 lengths-list
|
|
15452
|
|
15453 ;;; @r{Generate a lengths' list.}
|
|
15454 (lengths-list-file
|
|
15455 (expand-file-name (car list-of-files)))))
|
|
15456 @end group
|
|
15457
|
|
15458 @group
|
|
15459 ;;; @r{Make files' list shorter.}
|
|
15460 (setq list-of-files (cdr list-of-files)))
|
|
15461
|
|
15462 ;;; @r{Return final value of lengths' list.}
|
|
15463 lengths-list))
|
|
15464 @end group
|
|
15465 @end smallexample
|
|
15466
|
|
15467 @code{expand-file-name} is a built-in function that converts a file
|
|
15468 name to the absolute, long, path name form. The function employs the
|
|
15469 name of the directory in which the function is called.
|
|
15470
|
|
15471 @c !!! 22.1.1 lisp sources location here
|
|
15472 @need 1500
|
|
15473 Thus, if @code{expand-file-name} is called on @code{debug.el} when
|
|
15474 Emacs is visiting the
|
|
15475 @file{/usr/local/share/emacs/22.1.1/lisp/emacs-lisp/} directory,
|
|
15476
|
|
15477 @smallexample
|
|
15478 debug.el
|
|
15479 @end smallexample
|
|
15480
|
|
15481 @need 800
|
|
15482 @noindent
|
|
15483 becomes
|
|
15484
|
|
15485 @c !!! 22.1.1 lisp sources location here
|
|
15486 @smallexample
|
|
15487 /usr/local/share/emacs/22.1.1/lisp/emacs-lisp/debug.el
|
|
15488 @end smallexample
|
|
15489
|
|
15490 The only other new element of this function definition is the as yet
|
|
15491 unstudied function @code{append}, which merits a short section for
|
|
15492 itself.
|
|
15493
|
|
15494 @node append, , lengths-list-many-files, Several files
|
|
15495 @subsection The @code{append} Function
|
|
15496
|
|
15497 @need 800
|
|
15498 The @code{append} function attaches one list to another. Thus,
|
|
15499
|
|
15500 @smallexample
|
|
15501 (append '(1 2 3 4) '(5 6 7 8))
|
|
15502 @end smallexample
|
|
15503
|
|
15504 @need 800
|
|
15505 @noindent
|
|
15506 produces the list
|
|
15507
|
|
15508 @smallexample
|
|
15509 (1 2 3 4 5 6 7 8)
|
|
15510 @end smallexample
|
|
15511
|
|
15512 This is exactly how we want to attach two lengths' lists produced by
|
|
15513 @code{lengths-list-file} to each other. The results contrast with
|
|
15514 @code{cons},
|
|
15515
|
|
15516 @smallexample
|
|
15517 (cons '(1 2 3 4) '(5 6 7 8))
|
|
15518 @end smallexample
|
|
15519
|
|
15520 @need 1250
|
|
15521 @noindent
|
|
15522 which constructs a new list in which the first argument to @code{cons}
|
|
15523 becomes the first element of the new list:
|
|
15524
|
|
15525 @smallexample
|
|
15526 ((1 2 3 4) 5 6 7 8)
|
|
15527 @end smallexample
|
|
15528
|
|
15529 @node Several files recursively, Prepare the data, Several files, Words in a defun
|
|
15530 @section Recursively Count Words in Different Files
|
|
15531
|
|
15532 Besides a @code{while} loop, you can work on each of a list of files
|
|
15533 with recursion. A recursive version of @code{lengths-list-many-files}
|
|
15534 is short and simple.
|
|
15535
|
|
15536 The recursive function has the usual parts: the `do-again-test', the
|
|
15537 `next-step-expression', and the recursive call. The `do-again-test'
|
|
15538 determines whether the function should call itself again, which it
|
|
15539 will do if the @code{list-of-files} contains any remaining elements;
|
|
15540 the `next-step-expression' resets the @code{list-of-files} to the
|
|
15541 @sc{cdr} of itself, so eventually the list will be empty; and the
|
|
15542 recursive call calls itself on the shorter list. The complete
|
|
15543 function is shorter than this description!
|
|
15544 @findex recursive-lengths-list-many-files
|
|
15545
|
|
15546 @smallexample
|
|
15547 @group
|
|
15548 (defun recursive-lengths-list-many-files (list-of-files)
|
|
15549 "Return list of lengths of each defun in LIST-OF-FILES."
|
|
15550 (if list-of-files ; @r{do-again-test}
|
|
15551 (append
|
|
15552 (lengths-list-file
|
|
15553 (expand-file-name (car list-of-files)))
|
|
15554 (recursive-lengths-list-many-files
|
|
15555 (cdr list-of-files)))))
|
|
15556 @end group
|
|
15557 @end smallexample
|
|
15558
|
|
15559 @noindent
|
|
15560 In a sentence, the function returns the lengths' list for the first of
|
|
15561 the @code{list-of-files} appended to the result of calling itself on
|
|
15562 the rest of the @code{list-of-files}.
|
|
15563
|
|
15564 Here is a test of @code{recursive-lengths-list-many-files}, along with
|
|
15565 the results of running @code{lengths-list-file} on each of the files
|
|
15566 individually.
|
|
15567
|
|
15568 Install @code{recursive-lengths-list-many-files} and
|
|
15569 @code{lengths-list-file}, if necessary, and then evaluate the
|
|
15570 following expressions. You may need to change the files' pathnames;
|
|
15571 those here work when this Info file and the Emacs sources are located
|
|
15572 in their customary places. To change the expressions, copy them to
|
|
15573 the @file{*scratch*} buffer, edit them, and then evaluate them.
|
|
15574
|
|
15575 The results are shown after the @samp{@result{}}. (These results are
|
|
15576 for files from Emacs version 22.1.1; files from other versions of
|
|
15577 Emacs may produce different results.)
|
|
15578
|
|
15579 @c !!! 22.1.1 lisp sources location here
|
|
15580 @smallexample
|
|
15581 @group
|
|
15582 (cd "/usr/local/share/emacs/22.1.1/")
|
|
15583
|
|
15584 (lengths-list-file "./lisp/macros.el")
|
|
15585 @result{} (283 263 480 90)
|
|
15586 @end group
|
|
15587
|
|
15588 @group
|
|
15589 (lengths-list-file "./lisp/mail/mailalias.el")
|
|
15590 @result{} (38 32 29 95 178 180 321 218 324)
|
|
15591 @end group
|
|
15592
|
|
15593 @group
|
|
15594 (lengths-list-file "./lisp/makesum.el")
|
|
15595 @result{} (85 181)
|
|
15596 @end group
|
|
15597
|
|
15598 @group
|
|
15599 (recursive-lengths-list-many-files
|
|
15600 '("./lisp/macros.el"
|
|
15601 "./lisp/mail/mailalias.el"
|
|
15602 "./lisp/makesum.el"))
|
|
15603 @result{} (283 263 480 90 38 32 29 95 178 180 321 218 324 85 181)
|
|
15604 @end group
|
|
15605 @end smallexample
|
|
15606
|
|
15607 The @code{recursive-lengths-list-many-files} function produces the
|
|
15608 output we want.
|
|
15609
|
|
15610 The next step is to prepare the data in the list for display in a graph.
|
|
15611
|
|
15612 @node Prepare the data, , Several files recursively, Words in a defun
|
|
15613 @section Prepare the Data for Display in a Graph
|
|
15614
|
|
15615 The @code{recursive-lengths-list-many-files} function returns a list
|
|
15616 of numbers. Each number records the length of a function definition.
|
|
15617 What we need to do now is transform this data into a list of numbers
|
|
15618 suitable for generating a graph. The new list will tell how many
|
|
15619 functions definitions contain less than 10 words and
|
|
15620 symbols, how many contain between 10 and 19 words and symbols, how
|
|
15621 many contain between 20 and 29 words and symbols, and so on.
|
|
15622
|
|
15623 In brief, we need to go through the lengths' list produced by the
|
|
15624 @code{recursive-lengths-list-many-files} function and count the number
|
|
15625 of defuns within each range of lengths, and produce a list of those
|
|
15626 numbers.
|
|
15627
|
|
15628 @menu
|
|
15629 * Data for Display in Detail::
|
|
15630 * Sorting:: Sorting lists.
|
|
15631 * Files List:: Making a list of files.
|
|
15632 * Counting function definitions::
|
|
15633 @end menu
|
|
15634
|
|
15635 @node Data for Display in Detail, Sorting, Prepare the data, Prepare the data
|
|
15636 @ifnottex
|
|
15637 @unnumberedsubsec The Data for Display in Detail
|
|
15638 @end ifnottex
|
|
15639
|
|
15640 Based on what we have done before, we can readily foresee that it
|
|
15641 should not be too hard to write a function that `@sc{cdr}s' down the
|
|
15642 lengths' list, looks at each element, determines which length range it
|
|
15643 is in, and increments a counter for that range.
|
|
15644
|
|
15645 However, before beginning to write such a function, we should consider
|
|
15646 the advantages of sorting the lengths' list first, so the numbers are
|
|
15647 ordered from smallest to largest. First, sorting will make it easier
|
|
15648 to count the numbers in each range, since two adjacent numbers will
|
|
15649 either be in the same length range or in adjacent ranges. Second, by
|
|
15650 inspecting a sorted list, we can discover the highest and lowest
|
|
15651 number, and thereby determine the largest and smallest length range
|
|
15652 that we will need.
|
|
15653
|
|
15654 @node Sorting, Files List, Data for Display in Detail, Prepare the data
|
|
15655 @subsection Sorting Lists
|
|
15656 @findex sort
|
|
15657
|
|
15658 Emacs contains a function to sort lists, called (as you might guess)
|
|
15659 @code{sort}. The @code{sort} function takes two arguments, the list
|
|
15660 to be sorted, and a predicate that determines whether the first of
|
|
15661 two list elements is ``less'' than the second.
|
|
15662
|
|
15663 As we saw earlier (@pxref{Wrong Type of Argument, , Using the Wrong
|
|
15664 Type Object as an Argument}), a predicate is a function that
|
|
15665 determines whether some property is true or false. The @code{sort}
|
|
15666 function will reorder a list according to whatever property the
|
|
15667 predicate uses; this means that @code{sort} can be used to sort
|
|
15668 non-numeric lists by non-numeric criteria---it can, for example,
|
|
15669 alphabetize a list.
|
|
15670
|
|
15671 @need 1250
|
|
15672 The @code{<} function is used when sorting a numeric list. For example,
|
|
15673
|
|
15674 @smallexample
|
|
15675 (sort '(4 8 21 17 33 7 21 7) '<)
|
|
15676 @end smallexample
|
|
15677
|
|
15678 @need 800
|
|
15679 @noindent
|
|
15680 produces this:
|
|
15681
|
|
15682 @smallexample
|
|
15683 (4 7 7 8 17 21 21 33)
|
|
15684 @end smallexample
|
|
15685
|
|
15686 @noindent
|
|
15687 (Note that in this example, both the arguments are quoted so that the
|
|
15688 symbols are not evaluated before being passed to @code{sort} as
|
|
15689 arguments.)
|
|
15690
|
|
15691 Sorting the list returned by the
|
|
15692 @code{recursive-lengths-list-many-files} function is straightforward;
|
|
15693 it uses the @code{<} function:
|
|
15694
|
|
15695 @ignore
|
|
15696 2006 Oct 29
|
|
15697 In GNU Emacs 22, eval
|
|
15698 (progn
|
|
15699 (cd "/usr/local/share/emacs/22.0.50/")
|
|
15700 (sort
|
|
15701 (recursive-lengths-list-many-files
|
|
15702 '("./lisp/macros.el"
|
|
15703 "./lisp/mail/mailalias.el"
|
|
15704 "./lisp/makesum.el"))
|
|
15705 '<))
|
|
15706
|
|
15707 @end ignore
|
|
15708
|
|
15709 @smallexample
|
|
15710 @group
|
|
15711 (sort
|
|
15712 (recursive-lengths-list-many-files
|
|
15713 '("./lisp/macros.el"
|
|
15714 "./lisp/mailalias.el"
|
|
15715 "./lisp/makesum.el"))
|
|
15716 '<)
|
|
15717 @end group
|
|
15718 @end smallexample
|
|
15719
|
|
15720 @need 800
|
|
15721 @noindent
|
|
15722 which produces:
|
|
15723
|
|
15724 @smallexample
|
|
15725 (29 32 38 85 90 95 178 180 181 218 263 283 321 324 480)
|
|
15726 @end smallexample
|
|
15727
|
|
15728 @noindent
|
|
15729 (Note that in this example, the first argument to @code{sort} is not
|
|
15730 quoted, since the expression must be evaluated so as to produce the
|
|
15731 list that is passed to @code{sort}.)
|
|
15732
|
|
15733 @node Files List, Counting function definitions, Sorting, Prepare the data
|
|
15734 @subsection Making a List of Files
|
|
15735
|
|
15736 The @code{recursive-lengths-list-many-files} function requires a list
|
|
15737 of files as its argument. For our test examples, we constructed such
|
|
15738 a list by hand; but the Emacs Lisp source directory is too large for
|
|
15739 us to do for that. Instead, we will write a function to do the job
|
|
15740 for us. In this function, we will use both a @code{while} loop and a
|
|
15741 recursive call.
|
|
15742
|
|
15743 @findex directory-files
|
|
15744 We did not have to write a function like this for older versions of
|
|
15745 GNU Emacs, since they placed all the @samp{.el} files in one
|
|
15746 directory. Instead, we were able to use the @code{directory-files}
|
|
15747 function, which lists the names of files that match a specified
|
|
15748 pattern within a single directory.
|
|
15749
|
|
15750 However, recent versions of Emacs place Emacs Lisp files in
|
|
15751 sub-directories of the top level @file{lisp} directory. This
|
|
15752 re-arrangement eases navigation. For example, all the mail related
|
|
15753 files are in a @file{lisp} sub-directory called @file{mail}. But at
|
|
15754 the same time, this arrangement forces us to create a file listing
|
|
15755 function that descends into the sub-directories.
|
|
15756
|
|
15757 @findex files-in-below-directory
|
|
15758 We can create this function, called @code{files-in-below-directory},
|
|
15759 using familiar functions such as @code{car}, @code{nthcdr}, and
|
|
15760 @code{substring} in conjunction with an existing function called
|
|
15761 @code{directory-files-and-attributes}. This latter function not only
|
|
15762 lists all the filenames in a directory, including the names
|
|
15763 of sub-directories, but also their attributes.
|
|
15764
|
|
15765 To restate our goal: to create a function that will enable us
|
|
15766 to feed filenames to @code{recursive-lengths-list-many-files}
|
|
15767 as a list that looks like this (but with more elements):
|
|
15768
|
|
15769 @smallexample
|
|
15770 @group
|
|
15771 ("./lisp/macros.el"
|
|
15772 "./lisp/mail/rmail.el"
|
|
15773 "./lisp/makesum.el")
|
|
15774 @end group
|
|
15775 @end smallexample
|
|
15776
|
|
15777 The @code{directory-files-and-attributes} function returns a list of
|
|
15778 lists. Each of the lists within the main list consists of 13
|
|
15779 elements. The first element is a string that contains the name of the
|
|
15780 file -- which, in GNU/Linux, may be a `directory file', that is to
|
|
15781 say, a file with the special attributes of a directory. The second
|
|
15782 element of the list is @code{t} for a directory, a string
|
|
15783 for symbolic link (the string is the name linked to), or @code{nil}.
|
|
15784
|
|
15785 For example, the first @samp{.el} file in the @file{lisp/} directory
|
|
15786 is @file{abbrev.el}. Its name is
|
|
15787 @file{/usr/local/share/emacs/22.1.1/lisp/abbrev.el} and it is not a
|
|
15788 directory or a symbolic link.
|
|
15789
|
|
15790 @need 1000
|
|
15791 This is how @code{directory-files-and-attributes} lists that file and
|
|
15792 its attributes:
|
|
15793
|
|
15794 @smallexample
|
|
15795 @group
|
|
15796 ("abbrev.el"
|
|
15797 nil
|
|
15798 1
|
|
15799 1000
|
|
15800 100
|
|
15801 @end group
|
|
15802 @group
|
|
15803 (17733 259)
|
|
15804 (17491 28834)
|
|
15805 (17596 62124)
|
|
15806 13157
|
|
15807 "-rw-rw-r--"
|
|
15808 @end group
|
|
15809 @group
|
|
15810 nil
|
|
15811 2971624
|
|
15812 773)
|
|
15813 @end group
|
|
15814 @end smallexample
|
|
15815
|
|
15816 @need 1200
|
|
15817 On the other hand, @file{mail/} is a directory within the @file{lisp/}
|
|
15818 directory. The beginning of its listing looks like this:
|
|
15819
|
|
15820 @smallexample
|
|
15821 @group
|
|
15822 ("mail"
|
|
15823 t
|
|
15824 @dots{}
|
|
15825 )
|
|
15826 @end group
|
|
15827 @end smallexample
|
|
15828
|
|
15829 (To learn about the different attributes, look at the documentation of
|
|
15830 @code{file-attributes}. Bear in mind that the @code{file-attributes}
|
|
15831 function does not list the filename, so its first element is
|
|
15832 @code{directory-files-and-attributes}'s second element.)
|
|
15833
|
|
15834 We will want our new function, @code{files-in-below-directory}, to
|
|
15835 list the @samp{.el} files in the directory it is told to check, and in
|
|
15836 any directories below that directory.
|
|
15837
|
|
15838 This gives us a hint on how to construct
|
|
15839 @code{files-in-below-directory}: within a directory, the function
|
|
15840 should add @samp{.el} filenames to a list; and if, within a directory,
|
|
15841 the function comes upon a sub-directory, it should go into that
|
|
15842 sub-directory and repeat its actions.
|
|
15843
|
|
15844 However, we should note that every directory contains a name that
|
|
15845 refers to itself, called @file{.}, (``dot'') and a name that refers to
|
|
15846 its parent directory, called @file{..} (``double dot''). (In
|
|
15847 @file{/}, the root directory, @file{..} refers to itself, since
|
|
15848 @file{/} has no parent.) Clearly, we do not want our
|
|
15849 @code{files-in-below-directory} function to enter those directories,
|
|
15850 since they always lead us, directly or indirectly, to the current
|
|
15851 directory.
|
|
15852
|
|
15853 Consequently, our @code{files-in-below-directory} function must do
|
|
15854 several tasks:
|
|
15855
|
|
15856 @itemize @bullet
|
|
15857 @item
|
|
15858 Check to see whether it is looking at a filename that ends in
|
|
15859 @samp{.el}; and if so, add its name to a list.
|
|
15860
|
|
15861 @item
|
|
15862 Check to see whether it is looking at a filename that is the name of a
|
|
15863 directory; and if so,
|
|
15864
|
|
15865 @itemize @minus
|
|
15866 @item
|
|
15867 Check to see whether it is looking at @file{.} or @file{..}; and if
|
|
15868 so skip it.
|
|
15869
|
|
15870 @item
|
|
15871 Or else, go into that directory and repeat the process.
|
|
15872 @end itemize
|
|
15873 @end itemize
|
|
15874
|
|
15875 Let's write a function definition to do these tasks. We will use a
|
|
15876 @code{while} loop to move from one filename to another within a
|
|
15877 directory, checking what needs to be done; and we will use a recursive
|
|
15878 call to repeat the actions on each sub-directory. The recursive
|
|
15879 pattern is `accumulate'
|
|
15880 (@pxref{Accumulate, , Recursive Pattern: @emph{accumulate}}),
|
|
15881 using @code{append} as the combiner.
|
|
15882
|
|
15883 @ignore
|
|
15884 (directory-files "/usr/local/src/emacs/lisp/" t "\\.el$")
|
|
15885 (shell-command "find /usr/local/src/emacs/lisp/ -name '*.el'")
|
|
15886
|
|
15887 (directory-files "/usr/local/share/emacs/22.1.1/lisp/" t "\\.el$")
|
|
15888 (shell-command "find /usr/local/share/emacs/22.1.1/lisp/ -name '*.el'")
|
|
15889 @end ignore
|
|
15890
|
|
15891 @c /usr/local/share/emacs/22.1.1/lisp/
|
|
15892
|
|
15893 @need 800
|
|
15894 Here is the function:
|
|
15895
|
|
15896 @smallexample
|
|
15897 @group
|
|
15898 (defun files-in-below-directory (directory)
|
|
15899 "List the .el files in DIRECTORY and in its sub-directories."
|
|
15900 ;; Although the function will be used non-interactively,
|
|
15901 ;; it will be easier to test if we make it interactive.
|
|
15902 ;; The directory will have a name such as
|
|
15903 ;; "/usr/local/share/emacs/22.1.1/lisp/"
|
|
15904 (interactive "DDirectory name: ")
|
|
15905 @end group
|
|
15906 @group
|
|
15907 (let (el-files-list
|
|
15908 (current-directory-list
|
|
15909 (directory-files-and-attributes directory t)))
|
|
15910 ;; while we are in the current directory
|
|
15911 (while current-directory-list
|
|
15912 @end group
|
|
15913 @group
|
|
15914 (cond
|
|
15915 ;; check to see whether filename ends in `.el'
|
|
15916 ;; and if so, append its name to a list.
|
|
15917 ((equal ".el" (substring (car (car current-directory-list)) -3))
|
|
15918 (setq el-files-list
|
|
15919 (cons (car (car current-directory-list)) el-files-list)))
|
|
15920 @end group
|
|
15921 @group
|
|
15922 ;; check whether filename is that of a directory
|
|
15923 ((eq t (car (cdr (car current-directory-list))))
|
|
15924 ;; decide whether to skip or recurse
|
|
15925 (if
|
|
15926 (equal "."
|
|
15927 (substring (car (car current-directory-list)) -1))
|
|
15928 ;; then do nothing since filename is that of
|
|
15929 ;; current directory or parent, "." or ".."
|
|
15930 ()
|
|
15931 @end group
|
|
15932 @group
|
|
15933 ;; else descend into the directory and repeat the process
|
|
15934 (setq el-files-list
|
|
15935 (append
|
|
15936 (files-in-below-directory
|
|
15937 (car (car current-directory-list)))
|
|
15938 el-files-list)))))
|
|
15939 ;; move to the next filename in the list; this also
|
|
15940 ;; shortens the list so the while loop eventually comes to an end
|
|
15941 (setq current-directory-list (cdr current-directory-list)))
|
|
15942 ;; return the filenames
|
|
15943 el-files-list))
|
|
15944 @end group
|
|
15945 @end smallexample
|
|
15946
|
|
15947 @c (files-in-below-directory "/usr/local/src/emacs/lisp/")
|
|
15948 @c (files-in-below-directory "/usr/local/share/emacs/22.1.1/lisp/")
|
|
15949
|
|
15950 The @code{files-in-below-directory} @code{directory-files} function
|
|
15951 takes one argument, the name of a directory.
|
|
15952
|
|
15953 @need 1250
|
|
15954 Thus, on my system,
|
|
15955
|
|
15956 @c (length (files-in-below-directory "/usr/local/src/emacs/lisp/"))
|
|
15957
|
|
15958 @c !!! 22.1.1 lisp sources location here
|
|
15959 @smallexample
|
|
15960 @group
|
|
15961 (length
|
|
15962 (files-in-below-directory "/usr/local/share/emacs/22.1.1/lisp/"))
|
|
15963 @end group
|
|
15964 @end smallexample
|
|
15965
|
|
15966 @noindent
|
|
15967 tells me that in and below my Lisp sources directory are 1031
|
|
15968 @samp{.el} files.
|
|
15969
|
|
15970 @code{files-in-below-directory} returns a list in reverse alphabetical
|
|
15971 order. An expression to sort the list in alphabetical order looks
|
|
15972 like this:
|
|
15973
|
|
15974 @smallexample
|
|
15975 @group
|
|
15976 (sort
|
|
15977 (files-in-below-directory "/usr/local/share/emacs/22.1.1/lisp/")
|
|
15978 'string-lessp)
|
|
15979 @end group
|
|
15980 @end smallexample
|
|
15981
|
|
15982 @ignore
|
|
15983 (defun test ()
|
|
15984 "Test how long it takes to find lengths of all sorted elisp defuns."
|
|
15985 (insert "\n" (current-time-string) "\n")
|
|
15986 (sit-for 0)
|
|
15987 (sort
|
|
15988 (recursive-lengths-list-many-files
|
|
15989 (files-in-below-directory "/usr/local/src/emacs/lisp/"))
|
|
15990 '<)
|
|
15991 (insert (format "%s" (current-time-string))))
|
|
15992 @end ignore
|
|
15993
|
|
15994 @node Counting function definitions, , Files List, Prepare the data
|
|
15995 @subsection Counting function definitions
|
|
15996
|
|
15997 Our immediate goal is to generate a list that tells us how many
|
|
15998 function definitions contain fewer than 10 words and symbols, how many
|
|
15999 contain between 10 and 19 words and symbols, how many contain between
|
|
16000 20 and 29 words and symbols, and so on.
|
|
16001
|
|
16002 With a sorted list of numbers, this is easy: count how many elements
|
|
16003 of the list are smaller than 10, then, after moving past the numbers
|
|
16004 just counted, count how many are smaller than 20, then, after moving
|
|
16005 past the numbers just counted, count how many are smaller than 30, and
|
|
16006 so on. Each of the numbers, 10, 20, 30, 40, and the like, is one
|
|
16007 larger than the top of that range. We can call the list of such
|
|
16008 numbers the @code{top-of-ranges} list.
|
|
16009
|
|
16010 @need 1200
|
|
16011 If we wished, we could generate this list automatically, but it is
|
|
16012 simpler to write a list manually. Here it is:
|
|
16013 @vindex top-of-ranges
|
|
16014
|
|
16015 @smallexample
|
|
16016 @group
|
|
16017 (defvar top-of-ranges
|
|
16018 '(10 20 30 40 50
|
|
16019 60 70 80 90 100
|
|
16020 110 120 130 140 150
|
|
16021 160 170 180 190 200
|
|
16022 210 220 230 240 250
|
|
16023 260 270 280 290 300)
|
|
16024 "List specifying ranges for `defuns-per-range'.")
|
|
16025 @end group
|
|
16026 @end smallexample
|
|
16027
|
|
16028 To change the ranges, we edit this list.
|
|
16029
|
|
16030 Next, we need to write the function that creates the list of the
|
|
16031 number of definitions within each range. Clearly, this function must
|
|
16032 take the @code{sorted-lengths} and the @code{top-of-ranges} lists
|
|
16033 as arguments.
|
|
16034
|
|
16035 The @code{defuns-per-range} function must do two things again and
|
|
16036 again: it must count the number of definitions within a range
|
|
16037 specified by the current top-of-range value; and it must shift to the
|
|
16038 next higher value in the @code{top-of-ranges} list after counting the
|
|
16039 number of definitions in the current range. Since each of these
|
|
16040 actions is repetitive, we can use @code{while} loops for the job.
|
|
16041 One loop counts the number of definitions in the range defined by the
|
|
16042 current top-of-range value, and the other loop selects each of the
|
|
16043 top-of-range values in turn.
|
|
16044
|
|
16045 Several entries of the @code{sorted-lengths} list are counted for each
|
|
16046 range; this means that the loop for the @code{sorted-lengths} list
|
|
16047 will be inside the loop for the @code{top-of-ranges} list, like a
|
|
16048 small gear inside a big gear.
|
|
16049
|
|
16050 The inner loop counts the number of definitions within the range. It
|
|
16051 is a simple counting loop of the type we have seen before.
|
|
16052 (@xref{Incrementing Loop, , A loop with an incrementing counter}.)
|
|
16053 The true-or-false test of the loop tests whether the value from the
|
|
16054 @code{sorted-lengths} list is smaller than the current value of the
|
|
16055 top of the range. If it is, the function increments the counter and
|
|
16056 tests the next value from the @code{sorted-lengths} list.
|
|
16057
|
|
16058 @need 1250
|
|
16059 The inner loop looks like this:
|
|
16060
|
|
16061 @smallexample
|
|
16062 @group
|
|
16063 (while @var{length-element-smaller-than-top-of-range}
|
|
16064 (setq number-within-range (1+ number-within-range))
|
|
16065 (setq sorted-lengths (cdr sorted-lengths)))
|
|
16066 @end group
|
|
16067 @end smallexample
|
|
16068
|
|
16069 The outer loop must start with the lowest value of the
|
|
16070 @code{top-of-ranges} list, and then be set to each of the succeeding
|
|
16071 higher values in turn. This can be done with a loop like this:
|
|
16072
|
|
16073 @smallexample
|
|
16074 @group
|
|
16075 (while top-of-ranges
|
|
16076 @var{body-of-loop}@dots{}
|
|
16077 (setq top-of-ranges (cdr top-of-ranges)))
|
|
16078 @end group
|
|
16079 @end smallexample
|
|
16080
|
|
16081 @need 1200
|
|
16082 Put together, the two loops look like this:
|
|
16083
|
|
16084 @smallexample
|
|
16085 @group
|
|
16086 (while top-of-ranges
|
|
16087
|
|
16088 ;; @r{Count the number of elements within the current range.}
|
|
16089 (while @var{length-element-smaller-than-top-of-range}
|
|
16090 (setq number-within-range (1+ number-within-range))
|
|
16091 (setq sorted-lengths (cdr sorted-lengths)))
|
|
16092
|
|
16093 ;; @r{Move to next range.}
|
|
16094 (setq top-of-ranges (cdr top-of-ranges)))
|
|
16095 @end group
|
|
16096 @end smallexample
|
|
16097
|
|
16098 In addition, in each circuit of the outer loop, Emacs should record
|
|
16099 the number of definitions within that range (the value of
|
|
16100 @code{number-within-range}) in a list. We can use @code{cons} for
|
|
16101 this purpose. (@xref{cons, , @code{cons}}.)
|
|
16102
|
|
16103 The @code{cons} function works fine, except that the list it
|
|
16104 constructs will contain the number of definitions for the highest
|
|
16105 range at its beginning and the number of definitions for the lowest
|
|
16106 range at its end. This is because @code{cons} attaches new elements
|
|
16107 of the list to the beginning of the list, and since the two loops are
|
|
16108 working their way through the lengths' list from the lower end first,
|
|
16109 the @code{defuns-per-range-list} will end up largest number first.
|
|
16110 But we will want to print our graph with smallest values first and the
|
|
16111 larger later. The solution is to reverse the order of the
|
|
16112 @code{defuns-per-range-list}. We can do this using the
|
|
16113 @code{nreverse} function, which reverses the order of a list.
|
|
16114 @findex nreverse
|
|
16115
|
|
16116 @need 800
|
|
16117 For example,
|
|
16118
|
|
16119 @smallexample
|
|
16120 (nreverse '(1 2 3 4))
|
|
16121 @end smallexample
|
|
16122
|
|
16123 @need 800
|
|
16124 @noindent
|
|
16125 produces:
|
|
16126
|
|
16127 @smallexample
|
|
16128 (4 3 2 1)
|
|
16129 @end smallexample
|
|
16130
|
|
16131 Note that the @code{nreverse} function is ``destructive''---that is,
|
|
16132 it changes the list to which it is applied; this contrasts with the
|
|
16133 @code{car} and @code{cdr} functions, which are non-destructive. In
|
|
16134 this case, we do not want the original @code{defuns-per-range-list},
|
|
16135 so it does not matter that it is destroyed. (The @code{reverse}
|
|
16136 function provides a reversed copy of a list, leaving the original list
|
|
16137 as is.)
|
|
16138 @findex reverse
|
|
16139
|
|
16140 @need 1250
|
|
16141 Put all together, the @code{defuns-per-range} looks like this:
|
|
16142
|
|
16143 @smallexample
|
|
16144 @group
|
|
16145 (defun defuns-per-range (sorted-lengths top-of-ranges)
|
|
16146 "SORTED-LENGTHS defuns in each TOP-OF-RANGES range."
|
|
16147 (let ((top-of-range (car top-of-ranges))
|
|
16148 (number-within-range 0)
|
|
16149 defuns-per-range-list)
|
|
16150 @end group
|
|
16151
|
|
16152 @group
|
|
16153 ;; @r{Outer loop.}
|
|
16154 (while top-of-ranges
|
|
16155 @end group
|
|
16156
|
|
16157 @group
|
|
16158 ;; @r{Inner loop.}
|
|
16159 (while (and
|
|
16160 ;; @r{Need number for numeric test.}
|
|
16161 (car sorted-lengths)
|
|
16162 (< (car sorted-lengths) top-of-range))
|
|
16163 @end group
|
|
16164
|
|
16165 @group
|
|
16166 ;; @r{Count number of definitions within current range.}
|
|
16167 (setq number-within-range (1+ number-within-range))
|
|
16168 (setq sorted-lengths (cdr sorted-lengths)))
|
|
16169
|
|
16170 ;; @r{Exit inner loop but remain within outer loop.}
|
|
16171 @end group
|
|
16172
|
|
16173 @group
|
|
16174 (setq defuns-per-range-list
|
|
16175 (cons number-within-range defuns-per-range-list))
|
|
16176 (setq number-within-range 0) ; @r{Reset count to zero.}
|
|
16177 @end group
|
|
16178
|
|
16179 @group
|
|
16180 ;; @r{Move to next range.}
|
|
16181 (setq top-of-ranges (cdr top-of-ranges))
|
|
16182 ;; @r{Specify next top of range value.}
|
|
16183 (setq top-of-range (car top-of-ranges)))
|
|
16184 @end group
|
|
16185
|
|
16186 @group
|
|
16187 ;; @r{Exit outer loop and count the number of defuns larger than}
|
|
16188 ;; @r{ the largest top-of-range value.}
|
|
16189 (setq defuns-per-range-list
|
|
16190 (cons
|
|
16191 (length sorted-lengths)
|
|
16192 defuns-per-range-list))
|
|
16193 @end group
|
|
16194
|
|
16195 @group
|
|
16196 ;; @r{Return a list of the number of definitions within each range,}
|
|
16197 ;; @r{ smallest to largest.}
|
|
16198 (nreverse defuns-per-range-list)))
|
|
16199 @end group
|
|
16200 @end smallexample
|
|
16201
|
|
16202 @need 1200
|
|
16203 @noindent
|
|
16204 The function is straightforward except for one subtle feature. The
|
|
16205 true-or-false test of the inner loop looks like this:
|
|
16206
|
|
16207 @smallexample
|
|
16208 @group
|
|
16209 (and (car sorted-lengths)
|
|
16210 (< (car sorted-lengths) top-of-range))
|
|
16211 @end group
|
|
16212 @end smallexample
|
|
16213
|
|
16214 @need 800
|
|
16215 @noindent
|
|
16216 instead of like this:
|
|
16217
|
|
16218 @smallexample
|
|
16219 (< (car sorted-lengths) top-of-range)
|
|
16220 @end smallexample
|
|
16221
|
|
16222 The purpose of the test is to determine whether the first item in the
|
|
16223 @code{sorted-lengths} list is less than the value of the top of the
|
|
16224 range.
|
|
16225
|
|
16226 The simple version of the test works fine unless the
|
|
16227 @code{sorted-lengths} list has a @code{nil} value. In that case, the
|
|
16228 @code{(car sorted-lengths)} expression function returns
|
|
16229 @code{nil}. The @code{<} function cannot compare a number to
|
|
16230 @code{nil}, which is an empty list, so Emacs signals an error and
|
|
16231 stops the function from attempting to continue to execute.
|
|
16232
|
|
16233 The @code{sorted-lengths} list always becomes @code{nil} when the
|
|
16234 counter reaches the end of the list. This means that any attempt to
|
|
16235 use the @code{defuns-per-range} function with the simple version of
|
|
16236 the test will fail.
|
|
16237
|
|
16238 We solve the problem by using the @code{(car sorted-lengths)}
|
|
16239 expression in conjunction with the @code{and} expression. The
|
|
16240 @code{(car sorted-lengths)} expression returns a non-@code{nil}
|
|
16241 value so long as the list has at least one number within it, but
|
|
16242 returns @code{nil} if the list is empty. The @code{and} expression
|
|
16243 first evaluates the @code{(car sorted-lengths)} expression, and
|
|
16244 if it is @code{nil}, returns false @emph{without} evaluating the
|
|
16245 @code{<} expression. But if the @code{(car sorted-lengths)}
|
|
16246 expression returns a non-@code{nil} value, the @code{and} expression
|
|
16247 evaluates the @code{<} expression, and returns that value as the value
|
|
16248 of the @code{and} expression.
|
|
16249
|
|
16250 @c colon in printed section title causes problem in Info cross reference
|
|
16251 This way, we avoid an error.
|
|
16252 @iftex
|
|
16253 @noindent
|
|
16254 (For information about @code{and}, see
|
|
16255 @ref{kill-new function, , The @code{kill-new} function}.)
|
|
16256 @end iftex
|
|
16257 @ifinfo
|
|
16258 @noindent
|
|
16259 (@xref{kill-new function, , The @code{kill-new} function}, for
|
|
16260 information about @code{and}.)
|
|
16261 @end ifinfo
|
|
16262
|
|
16263 Here is a short test of the @code{defuns-per-range} function. First,
|
|
16264 evaluate the expression that binds (a shortened)
|
|
16265 @code{top-of-ranges} list to the list of values, then evaluate the
|
|
16266 expression for binding the @code{sorted-lengths} list, and then
|
|
16267 evaluate the @code{defuns-per-range} function.
|
|
16268
|
|
16269 @smallexample
|
|
16270 @group
|
|
16271 ;; @r{(Shorter list than we will use later.)}
|
|
16272 (setq top-of-ranges
|
|
16273 '(110 120 130 140 150
|
|
16274 160 170 180 190 200))
|
|
16275
|
|
16276 (setq sorted-lengths
|
|
16277 '(85 86 110 116 122 129 154 176 179 200 265 300 300))
|
|
16278
|
|
16279 (defuns-per-range sorted-lengths top-of-ranges)
|
|
16280 @end group
|
|
16281 @end smallexample
|
|
16282
|
|
16283 @need 800
|
|
16284 @noindent
|
|
16285 The list returned looks like this:
|
|
16286
|
|
16287 @smallexample
|
|
16288 (2 2 2 0 0 1 0 2 0 0 4)
|
|
16289 @end smallexample
|
|
16290
|
|
16291 @noindent
|
|
16292 Indeed, there are two elements of the @code{sorted-lengths} list
|
|
16293 smaller than 110, two elements between 110 and 119, two elements
|
|
16294 between 120 and 129, and so on. There are four elements with a value
|
|
16295 of 200 or larger.
|
|
16296
|
|
16297 @c The next step is to turn this numbers' list into a graph.
|
|
16298 @node Readying a Graph, Emacs Initialization, Words in a defun, Top
|
|
16299 @chapter Readying a Graph
|
|
16300 @cindex Readying a graph
|
|
16301 @cindex Graph prototype
|
|
16302 @cindex Prototype graph
|
|
16303 @cindex Body of graph
|
|
16304
|
|
16305 Our goal is to construct a graph showing the numbers of function
|
|
16306 definitions of various lengths in the Emacs lisp sources.
|
|
16307
|
|
16308 As a practical matter, if you were creating a graph, you would
|
|
16309 probably use a program such as @code{gnuplot} to do the job.
|
|
16310 (@code{gnuplot} is nicely integrated into GNU Emacs.) In this case,
|
|
16311 however, we create one from scratch, and in the process we will
|
|
16312 re-acquaint ourselves with some of what we learned before and learn
|
|
16313 more.
|
|
16314
|
|
16315 In this chapter, we will first write a simple graph printing function.
|
|
16316 This first definition will be a @dfn{prototype}, a rapidly written
|
|
16317 function that enables us to reconnoiter this unknown graph-making
|
|
16318 territory. We will discover dragons, or find that they are myth.
|
|
16319 After scouting the terrain, we will feel more confident and enhance
|
|
16320 the function to label the axes automatically.
|
|
16321
|
|
16322 @menu
|
|
16323 * Columns of a graph::
|
|
16324 * graph-body-print:: How to print the body of a graph.
|
|
16325 * recursive-graph-body-print::
|
|
16326 * Printed Axes::
|
|
16327 * Line Graph Exercise::
|
|
16328 @end menu
|
|
16329
|
|
16330 @node Columns of a graph, graph-body-print, Readying a Graph, Readying a Graph
|
|
16331 @ifnottex
|
|
16332 @unnumberedsec Printing the Columns of a Graph
|
|
16333 @end ifnottex
|
|
16334
|
|
16335 Since Emacs is designed to be flexible and work with all kinds of
|
|
16336 terminals, including character-only terminals, the graph will need to
|
|
16337 be made from one of the `typewriter' symbols. An asterisk will do; as
|
|
16338 we enhance the graph-printing function, we can make the choice of
|
|
16339 symbol a user option.
|
|
16340
|
|
16341 We can call this function @code{graph-body-print}; it will take a
|
|
16342 @code{numbers-list} as its only argument. At this stage, we will not
|
|
16343 label the graph, but only print its body.
|
|
16344
|
|
16345 The @code{graph-body-print} function inserts a vertical column of
|
|
16346 asterisks for each element in the @code{numbers-list}. The height of
|
|
16347 each line is determined by the value of that element of the
|
|
16348 @code{numbers-list}.
|
|
16349
|
|
16350 Inserting columns is a repetitive act; that means that this function can
|
|
16351 be written either with a @code{while} loop or recursively.
|
|
16352
|
|
16353 Our first challenge is to discover how to print a column of asterisks.
|
|
16354 Usually, in Emacs, we print characters onto a screen horizontally,
|
|
16355 line by line, by typing. We have two routes we can follow: write our
|
|
16356 own column-insertion function or discover whether one exists in Emacs.
|
|
16357
|
|
16358 To see whether there is one in Emacs, we can use the @kbd{M-x apropos}
|
|
16359 command. This command is like the @kbd{C-h a} (@code{command-apropos})
|
|
16360 command, except that the latter finds only those functions that are
|
|
16361 commands. The @kbd{M-x apropos} command lists all symbols that match
|
|
16362 a regular expression, including functions that are not interactive.
|
|
16363 @findex apropos
|
|
16364
|
|
16365 What we want to look for is some command that prints or inserts
|
|
16366 columns. Very likely, the name of the function will contain either
|
|
16367 the word `print' or the word `insert' or the word `column'.
|
|
16368 Therefore, we can simply type @kbd{M-x apropos RET
|
|
16369 print\|insert\|column RET} and look at the result. On my system, this
|
|
16370 command once too takes quite some time, and then produced a list of 79
|
|
16371 functions and variables. Now it does not take much time at all and
|
|
16372 produces a list of 211 functions and variables. Scanning down the
|
|
16373 list, the only function that looks as if it might do the job is
|
|
16374 @code{insert-rectangle}.
|
|
16375
|
|
16376 @need 1200
|
|
16377 Indeed, this is the function we want; its documentation says:
|
|
16378
|
|
16379 @smallexample
|
|
16380 @group
|
|
16381 insert-rectangle:
|
|
16382 Insert text of RECTANGLE with upper left corner at point.
|
|
16383 RECTANGLE's first line is inserted at point,
|
|
16384 its second line is inserted at a point vertically under point, etc.
|
|
16385 RECTANGLE should be a list of strings.
|
|
16386 After this command, the mark is at the upper left corner
|
|
16387 and point is at the lower right corner.
|
|
16388 @end group
|
|
16389 @end smallexample
|
|
16390
|
|
16391 We can run a quick test, to make sure it does what we expect of it.
|
|
16392
|
|
16393 Here is the result of placing the cursor after the
|
|
16394 @code{insert-rectangle} expression and typing @kbd{C-u C-x C-e}
|
|
16395 (@code{eval-last-sexp}). The function inserts the strings
|
|
16396 @samp{"first"}, @samp{"second"}, and @samp{"third"} at and below
|
|
16397 point. Also the function returns @code{nil}.
|
|
16398
|
|
16399 @smallexample
|
|
16400 @group
|
|
16401 (insert-rectangle '("first" "second" "third"))first
|
|
16402 second
|
|
16403 thirdnil
|
|
16404 @end group
|
|
16405 @end smallexample
|
|
16406
|
|
16407 @noindent
|
|
16408 Of course, we won't be inserting the text of the
|
|
16409 @code{insert-rectangle} expression itself into the buffer in which we
|
|
16410 are making the graph, but will call the function from our program. We
|
|
16411 shall, however, have to make sure that point is in the buffer at the
|
|
16412 place where the @code{insert-rectangle} function will insert its
|
|
16413 column of strings.
|
|
16414
|
|
16415 If you are reading this in Info, you can see how this works by
|
|
16416 switching to another buffer, such as the @file{*scratch*} buffer,
|
|
16417 placing point somewhere in the buffer, typing @kbd{M-:}, typing the
|
|
16418 @code{insert-rectangle} expression into the minibuffer at the prompt,
|
|
16419 and then typing @key{RET}. This causes Emacs to evaluate the
|
|
16420 expression in the minibuffer, but to use as the value of point the
|
|
16421 position of point in the @file{*scratch*} buffer. (@kbd{M-:} is the
|
|
16422 keybinding for @code{eval-expression}. Also, @code{nil} does not
|
|
16423 appear in the @file{*scratch*} buffer since the expression is
|
|
16424 evaluated in the minibuffer.)
|
|
16425
|
|
16426 We find when we do this that point ends up at the end of the last
|
|
16427 inserted line---that is to say, this function moves point as a
|
|
16428 side-effect. If we were to repeat the command, with point at this
|
|
16429 position, the next insertion would be below and to the right of the
|
|
16430 previous insertion. We don't want this! If we are going to make a
|
|
16431 bar graph, the columns need to be beside each other.
|
|
16432
|
|
16433 So we discover that each cycle of the column-inserting @code{while}
|
|
16434 loop must reposition point to the place we want it, and that place
|
|
16435 will be at the top, not the bottom, of the column. Moreover, we
|
|
16436 remember that when we print a graph, we do not expect all the columns
|
|
16437 to be the same height. This means that the top of each column may be
|
|
16438 at a different height from the previous one. We cannot simply
|
|
16439 reposition point to the same line each time, but moved over to the
|
|
16440 right---or perhaps we can@dots{}
|
|
16441
|
|
16442 We are planning to make the columns of the bar graph out of asterisks.
|
|
16443 The number of asterisks in the column is the number specified by the
|
|
16444 current element of the @code{numbers-list}. We need to construct a
|
|
16445 list of asterisks of the right length for each call to
|
|
16446 @code{insert-rectangle}. If this list consists solely of the requisite
|
|
16447 number of asterisks, then we will have position point the right number
|
|
16448 of lines above the base for the graph to print correctly. This could
|
|
16449 be difficult.
|
|
16450
|
|
16451 Alternatively, if we can figure out some way to pass
|
|
16452 @code{insert-rectangle} a list of the same length each time, then we
|
|
16453 can place point on the same line each time, but move it over one
|
|
16454 column to the right for each new column. If we do this, however, some
|
|
16455 of the entries in the list passed to @code{insert-rectangle} must be
|
|
16456 blanks rather than asterisks. For example, if the maximum height of
|
|
16457 the graph is 5, but the height of the column is 3, then
|
|
16458 @code{insert-rectangle} requires an argument that looks like this:
|
|
16459
|
|
16460 @smallexample
|
|
16461 (" " " " "*" "*" "*")
|
|
16462 @end smallexample
|
|
16463
|
|
16464 This last proposal is not so difficult, so long as we can determine
|
|
16465 the column height. There are two ways for us to specify the column
|
|
16466 height: we can arbitrarily state what it will be, which would work
|
|
16467 fine for graphs of that height; or we can search through the list of
|
|
16468 numbers and use the maximum height of the list as the maximum height
|
|
16469 of the graph. If the latter operation were difficult, then the former
|
|
16470 procedure would be easiest, but there is a function built into Emacs
|
|
16471 that determines the maximum of its arguments. We can use that
|
|
16472 function. The function is called @code{max} and it returns the
|
|
16473 largest of all its arguments, which must be numbers. Thus, for
|
|
16474 example,
|
|
16475
|
|
16476 @smallexample
|
|
16477 (max 3 4 6 5 7 3)
|
|
16478 @end smallexample
|
|
16479
|
|
16480 @noindent
|
|
16481 returns 7. (A corresponding function called @code{min} returns the
|
|
16482 smallest of all its arguments.)
|
|
16483 @findex max
|
|
16484 @findex min
|
|
16485
|
|
16486 However, we cannot simply call @code{max} on the @code{numbers-list};
|
|
16487 the @code{max} function expects numbers as its argument, not a list of
|
|
16488 numbers. Thus, the following expression,
|
|
16489
|
|
16490 @smallexample
|
|
16491 (max '(3 4 6 5 7 3))
|
|
16492 @end smallexample
|
|
16493
|
|
16494 @need 800
|
|
16495 @noindent
|
|
16496 produces the following error message;
|
|
16497
|
|
16498 @smallexample
|
|
16499 Wrong type of argument: number-or-marker-p, (3 4 6 5 7 3)
|
|
16500 @end smallexample
|
|
16501
|
|
16502 @findex apply
|
|
16503 We need a function that passes a list of arguments to a function.
|
|
16504 This function is @code{apply}. This function `applies' its first
|
|
16505 argument (a function) to its remaining arguments, the last of which
|
|
16506 may be a list.
|
|
16507
|
|
16508 @need 1250
|
|
16509 For example,
|
|
16510
|
|
16511 @smallexample
|
|
16512 (apply 'max 3 4 7 3 '(4 8 5))
|
|
16513 @end smallexample
|
|
16514
|
|
16515 @noindent
|
|
16516 returns 8.
|
|
16517
|
|
16518 (Incidentally, I don't know how you would learn of this function
|
|
16519 without a book such as this. It is possible to discover other
|
|
16520 functions, like @code{search-forward} or @code{insert-rectangle}, by
|
|
16521 guessing at a part of their names and then using @code{apropos}. Even
|
|
16522 though its base in metaphor is clear---`apply' its first argument to
|
|
16523 the rest---I doubt a novice would come up with that particular word
|
|
16524 when using @code{apropos} or other aid. Of course, I could be wrong;
|
|
16525 after all, the function was first named by someone who had to invent
|
|
16526 it.)
|
|
16527
|
|
16528 The second and subsequent arguments to @code{apply} are optional, so
|
|
16529 we can use @code{apply} to call a function and pass the elements of a
|
|
16530 list to it, like this, which also returns 8:
|
|
16531
|
|
16532 @smallexample
|
|
16533 (apply 'max '(4 8 5))
|
|
16534 @end smallexample
|
|
16535
|
|
16536 This latter way is how we will use @code{apply}. The
|
|
16537 @code{recursive-lengths-list-many-files} function returns a numbers'
|
|
16538 list to which we can apply @code{max} (we could also apply @code{max} to
|
|
16539 the sorted numbers' list; it does not matter whether the list is
|
|
16540 sorted or not.)
|
|
16541
|
|
16542 @need 800
|
|
16543 Hence, the operation for finding the maximum height of the graph is this:
|
|
16544
|
|
16545 @smallexample
|
|
16546 (setq max-graph-height (apply 'max numbers-list))
|
|
16547 @end smallexample
|
|
16548
|
|
16549 Now we can return to the question of how to create a list of strings
|
|
16550 for a column of the graph. Told the maximum height of the graph
|
|
16551 and the number of asterisks that should appear in the column, the
|
|
16552 function should return a list of strings for the
|
|
16553 @code{insert-rectangle} command to insert.
|
|
16554
|
|
16555 Each column is made up of asterisks or blanks. Since the function is
|
|
16556 passed the value of the height of the column and the number of
|
|
16557 asterisks in the column, the number of blanks can be found by
|
|
16558 subtracting the number of asterisks from the height of the column.
|
|
16559 Given the number of blanks and the number of asterisks, two
|
|
16560 @code{while} loops can be used to construct the list:
|
|
16561
|
|
16562 @smallexample
|
|
16563 @group
|
|
16564 ;;; @r{First version.}
|
|
16565 (defun column-of-graph (max-graph-height actual-height)
|
|
16566 "Return list of strings that is one column of a graph."
|
|
16567 (let ((insert-list nil)
|
|
16568 (number-of-top-blanks
|
|
16569 (- max-graph-height actual-height)))
|
|
16570 @end group
|
|
16571
|
|
16572 @group
|
|
16573 ;; @r{Fill in asterisks.}
|
|
16574 (while (> actual-height 0)
|
|
16575 (setq insert-list (cons "*" insert-list))
|
|
16576 (setq actual-height (1- actual-height)))
|
|
16577 @end group
|
|
16578
|
|
16579 @group
|
|
16580 ;; @r{Fill in blanks.}
|
|
16581 (while (> number-of-top-blanks 0)
|
|
16582 (setq insert-list (cons " " insert-list))
|
|
16583 (setq number-of-top-blanks
|
|
16584 (1- number-of-top-blanks)))
|
|
16585 @end group
|
|
16586
|
|
16587 @group
|
|
16588 ;; @r{Return whole list.}
|
|
16589 insert-list))
|
|
16590 @end group
|
|
16591 @end smallexample
|
|
16592
|
|
16593 If you install this function and then evaluate the following
|
|
16594 expression you will see that it returns the list as desired:
|
|
16595
|
|
16596 @smallexample
|
|
16597 (column-of-graph 5 3)
|
|
16598 @end smallexample
|
|
16599
|
|
16600 @need 800
|
|
16601 @noindent
|
|
16602 returns
|
|
16603
|
|
16604 @smallexample
|
|
16605 (" " " " "*" "*" "*")
|
|
16606 @end smallexample
|
|
16607
|
|
16608 As written, @code{column-of-graph} contains a major flaw: the symbols
|
|
16609 used for the blank and for the marked entries in the column are
|
|
16610 `hard-coded' as a space and asterisk. This is fine for a prototype,
|
|
16611 but you, or another user, may wish to use other symbols. For example,
|
|
16612 in testing the graph function, you many want to use a period in place
|
|
16613 of the space, to make sure the point is being repositioned properly
|
|
16614 each time the @code{insert-rectangle} function is called; or you might
|
|
16615 want to substitute a @samp{+} sign or other symbol for the asterisk.
|
|
16616 You might even want to make a graph-column that is more than one
|
|
16617 display column wide. The program should be more flexible. The way to
|
|
16618 do that is to replace the blank and the asterisk with two variables
|
|
16619 that we can call @code{graph-blank} and @code{graph-symbol} and define
|
|
16620 those variables separately.
|
|
16621
|
|
16622 Also, the documentation is not well written. These considerations
|
|
16623 lead us to the second version of the function:
|
|
16624
|
|
16625 @smallexample
|
|
16626 @group
|
|
16627 (defvar graph-symbol "*"
|
|
16628 "String used as symbol in graph, usually an asterisk.")
|
|
16629 @end group
|
|
16630
|
|
16631 @group
|
|
16632 (defvar graph-blank " "
|
|
16633 "String used as blank in graph, usually a blank space.
|
|
16634 graph-blank must be the same number of columns wide
|
|
16635 as graph-symbol.")
|
|
16636 @end group
|
|
16637 @end smallexample
|
|
16638
|
|
16639 @noindent
|
|
16640 (For an explanation of @code{defvar}, see
|
|
16641 @ref{defvar, , Initializing a Variable with @code{defvar}}.)
|
|
16642
|
|
16643 @smallexample
|
|
16644 @group
|
|
16645 ;;; @r{Second version.}
|
|
16646 (defun column-of-graph (max-graph-height actual-height)
|
|
16647 "Return MAX-GRAPH-HEIGHT strings; ACTUAL-HEIGHT are graph-symbols.
|
|
16648
|
|
16649 @end group
|
|
16650 @group
|
|
16651 The graph-symbols are contiguous entries at the end
|
|
16652 of the list.
|
|
16653 The list will be inserted as one column of a graph.
|
|
16654 The strings are either graph-blank or graph-symbol."
|
|
16655 @end group
|
|
16656
|
|
16657 @group
|
|
16658 (let ((insert-list nil)
|
|
16659 (number-of-top-blanks
|
|
16660 (- max-graph-height actual-height)))
|
|
16661 @end group
|
|
16662
|
|
16663 @group
|
|
16664 ;; @r{Fill in @code{graph-symbols}.}
|
|
16665 (while (> actual-height 0)
|
|
16666 (setq insert-list (cons graph-symbol insert-list))
|
|
16667 (setq actual-height (1- actual-height)))
|
|
16668 @end group
|
|
16669
|
|
16670 @group
|
|
16671 ;; @r{Fill in @code{graph-blanks}.}
|
|
16672 (while (> number-of-top-blanks 0)
|
|
16673 (setq insert-list (cons graph-blank insert-list))
|
|
16674 (setq number-of-top-blanks
|
|
16675 (1- number-of-top-blanks)))
|
|
16676
|
|
16677 ;; @r{Return whole list.}
|
|
16678 insert-list))
|
|
16679 @end group
|
|
16680 @end smallexample
|
|
16681
|
|
16682 If we wished, we could rewrite @code{column-of-graph} a third time to
|
|
16683 provide optionally for a line graph as well as for a bar graph. This
|
|
16684 would not be hard to do. One way to think of a line graph is that it
|
|
16685 is no more than a bar graph in which the part of each bar that is
|
|
16686 below the top is blank. To construct a column for a line graph, the
|
|
16687 function first constructs a list of blanks that is one shorter than
|
|
16688 the value, then it uses @code{cons} to attach a graph symbol to the
|
|
16689 list; then it uses @code{cons} again to attach the `top blanks' to
|
|
16690 the list.
|
|
16691
|
|
16692 It is easy to see how to write such a function, but since we don't
|
|
16693 need it, we will not do it. But the job could be done, and if it were
|
|
16694 done, it would be done with @code{column-of-graph}. Even more
|
|
16695 important, it is worth noting that few changes would have to be made
|
|
16696 anywhere else. The enhancement, if we ever wish to make it, is
|
|
16697 simple.
|
|
16698
|
|
16699 Now, finally, we come to our first actual graph printing function.
|
|
16700 This prints the body of a graph, not the labels for the vertical and
|
|
16701 horizontal axes, so we can call this @code{graph-body-print}.
|
|
16702
|
|
16703 @node graph-body-print, recursive-graph-body-print, Columns of a graph, Readying a Graph
|
|
16704 @section The @code{graph-body-print} Function
|
|
16705 @findex graph-body-print
|
|
16706
|
|
16707 After our preparation in the preceding section, the
|
|
16708 @code{graph-body-print} function is straightforward. The function
|
|
16709 will print column after column of asterisks and blanks, using the
|
|
16710 elements of a numbers' list to specify the number of asterisks in each
|
|
16711 column. This is a repetitive act, which means we can use a
|
|
16712 decrementing @code{while} loop or recursive function for the job. In
|
|
16713 this section, we will write the definition using a @code{while} loop.
|
|
16714
|
|
16715 The @code{column-of-graph} function requires the height of the graph
|
|
16716 as an argument, so we should determine and record that as a local variable.
|
|
16717
|
|
16718 This leads us to the following template for the @code{while} loop
|
|
16719 version of this function:
|
|
16720
|
|
16721 @smallexample
|
|
16722 @group
|
|
16723 (defun graph-body-print (numbers-list)
|
|
16724 "@var{documentation}@dots{}"
|
|
16725 (let ((height @dots{}
|
|
16726 @dots{}))
|
|
16727 @end group
|
|
16728
|
|
16729 @group
|
|
16730 (while numbers-list
|
|
16731 @var{insert-columns-and-reposition-point}
|
|
16732 (setq numbers-list (cdr numbers-list)))))
|
|
16733 @end group
|
|
16734 @end smallexample
|
|
16735
|
|
16736 @noindent
|
|
16737 We need to fill in the slots of the template.
|
|
16738
|
|
16739 Clearly, we can use the @code{(apply 'max numbers-list)} expression to
|
|
16740 determine the height of the graph.
|
|
16741
|
|
16742 The @code{while} loop will cycle through the @code{numbers-list} one
|
|
16743 element at a time. As it is shortened by the @code{(setq numbers-list
|
|
16744 (cdr numbers-list))} expression, the @sc{car} of each instance of the
|
|
16745 list is the value of the argument for @code{column-of-graph}.
|
|
16746
|
|
16747 At each cycle of the @code{while} loop, the @code{insert-rectangle}
|
|
16748 function inserts the list returned by @code{column-of-graph}. Since
|
|
16749 the @code{insert-rectangle} function moves point to the lower right of
|
|
16750 the inserted rectangle, we need to save the location of point at the
|
|
16751 time the rectangle is inserted, move back to that position after the
|
|
16752 rectangle is inserted, and then move horizontally to the next place
|
|
16753 from which @code{insert-rectangle} is called.
|
|
16754
|
|
16755 If the inserted columns are one character wide, as they will be if
|
|
16756 single blanks and asterisks are used, the repositioning command is
|
|
16757 simply @code{(forward-char 1)}; however, the width of a column may be
|
|
16758 greater than one. This means that the repositioning command should be
|
|
16759 written @code{(forward-char symbol-width)}. The @code{symbol-width}
|
|
16760 itself is the length of a @code{graph-blank} and can be found using
|
|
16761 the expression @code{(length graph-blank)}. The best place to bind
|
|
16762 the @code{symbol-width} variable to the value of the width of graph
|
|
16763 column is in the varlist of the @code{let} expression.
|
|
16764
|
|
16765 @need 1250
|
|
16766 These considerations lead to the following function definition:
|
|
16767
|
|
16768 @smallexample
|
|
16769 @group
|
|
16770 (defun graph-body-print (numbers-list)
|
|
16771 "Print a bar graph of the NUMBERS-LIST.
|
|
16772 The numbers-list consists of the Y-axis values."
|
|
16773
|
|
16774 (let ((height (apply 'max numbers-list))
|
|
16775 (symbol-width (length graph-blank))
|
|
16776 from-position)
|
|
16777 @end group
|
|
16778
|
|
16779 @group
|
|
16780 (while numbers-list
|
|
16781 (setq from-position (point))
|
|
16782 (insert-rectangle
|
|
16783 (column-of-graph height (car numbers-list)))
|
|
16784 (goto-char from-position)
|
|
16785 (forward-char symbol-width)
|
|
16786 @end group
|
|
16787 @group
|
|
16788 ;; @r{Draw graph column by column.}
|
|
16789 (sit-for 0)
|
|
16790 (setq numbers-list (cdr numbers-list)))
|
|
16791 @end group
|
|
16792 @group
|
|
16793 ;; @r{Place point for X axis labels.}
|
|
16794 (forward-line height)
|
|
16795 (insert "\n")
|
|
16796 ))
|
|
16797 @end group
|
|
16798 @end smallexample
|
|
16799
|
|
16800 @noindent
|
|
16801 The one unexpected expression in this function is the
|
|
16802 @w{@code{(sit-for 0)}} expression in the @code{while} loop. This
|
|
16803 expression makes the graph printing operation more interesting to
|
|
16804 watch than it would be otherwise. The expression causes Emacs to
|
|
16805 `sit' or do nothing for a zero length of time and then redraw the
|
|
16806 screen. Placed here, it causes Emacs to redraw the screen column by
|
|
16807 column. Without it, Emacs would not redraw the screen until the
|
|
16808 function exits.
|
|
16809
|
|
16810 We can test @code{graph-body-print} with a short list of numbers.
|
|
16811
|
|
16812 @enumerate
|
|
16813 @item
|
|
16814 Install @code{graph-symbol}, @code{graph-blank},
|
|
16815 @code{column-of-graph}, which are in
|
|
16816 @iftex
|
|
16817 @ref{Readying a Graph, , Readying a Graph},
|
|
16818 @end iftex
|
|
16819 @ifinfo
|
|
16820 @ref{Columns of a graph},
|
|
16821 @end ifinfo
|
|
16822 and @code{graph-body-print}.
|
|
16823
|
|
16824 @need 800
|
|
16825 @item
|
|
16826 Copy the following expression:
|
|
16827
|
|
16828 @smallexample
|
|
16829 (graph-body-print '(1 2 3 4 6 4 3 5 7 6 5 2 3))
|
|
16830 @end smallexample
|
|
16831
|
|
16832 @item
|
|
16833 Switch to the @file{*scratch*} buffer and place the cursor where you
|
|
16834 want the graph to start.
|
|
16835
|
|
16836 @item
|
|
16837 Type @kbd{M-:} (@code{eval-expression}).
|
|
16838
|
|
16839 @item
|
|
16840 Yank the @code{graph-body-print} expression into the minibuffer
|
|
16841 with @kbd{C-y} (@code{yank)}.
|
|
16842
|
|
16843 @item
|
|
16844 Press @key{RET} to evaluate the @code{graph-body-print} expression.
|
|
16845 @end enumerate
|
|
16846
|
|
16847 @need 800
|
|
16848 Emacs will print a graph like this:
|
|
16849
|
|
16850 @smallexample
|
|
16851 @group
|
|
16852 *
|
|
16853 * **
|
|
16854 * ****
|
|
16855 *** ****
|
|
16856 ********* *
|
|
16857 ************
|
|
16858 *************
|
|
16859 @end group
|
|
16860 @end smallexample
|
|
16861
|
|
16862 @node recursive-graph-body-print, Printed Axes, graph-body-print, Readying a Graph
|
|
16863 @section The @code{recursive-graph-body-print} Function
|
|
16864 @findex recursive-graph-body-print
|
|
16865
|
|
16866 The @code{graph-body-print} function may also be written recursively.
|
|
16867 The recursive solution is divided into two parts: an outside `wrapper'
|
|
16868 that uses a @code{let} expression to determine the values of several
|
|
16869 variables that need only be found once, such as the maximum height of
|
|
16870 the graph, and an inside function that is called recursively to print
|
|
16871 the graph.
|
|
16872
|
|
16873 @need 1250
|
|
16874 The `wrapper' is uncomplicated:
|
|
16875
|
|
16876 @smallexample
|
|
16877 @group
|
|
16878 (defun recursive-graph-body-print (numbers-list)
|
|
16879 "Print a bar graph of the NUMBERS-LIST.
|
|
16880 The numbers-list consists of the Y-axis values."
|
|
16881 (let ((height (apply 'max numbers-list))
|
|
16882 (symbol-width (length graph-blank))
|
|
16883 from-position)
|
|
16884 (recursive-graph-body-print-internal
|
|
16885 numbers-list
|
|
16886 height
|
|
16887 symbol-width)))
|
|
16888 @end group
|
|
16889 @end smallexample
|
|
16890
|
|
16891 The recursive function is a little more difficult. It has four parts:
|
|
16892 the `do-again-test', the printing code, the recursive call, and the
|
|
16893 `next-step-expression'. The `do-again-test' is a @code{when}
|
|
16894 expression that determines whether the @code{numbers-list} contains
|
|
16895 any remaining elements; if it does, the function prints one column of
|
|
16896 the graph using the printing code and calls itself again. The
|
|
16897 function calls itself again according to the value produced by the
|
|
16898 `next-step-expression' which causes the call to act on a shorter
|
|
16899 version of the @code{numbers-list}.
|
|
16900
|
|
16901 @smallexample
|
|
16902 @group
|
|
16903 (defun recursive-graph-body-print-internal
|
|
16904 (numbers-list height symbol-width)
|
|
16905 "Print a bar graph.
|
|
16906 Used within recursive-graph-body-print function."
|
|
16907 @end group
|
|
16908
|
|
16909 @group
|
|
16910 (when numbers-list
|
|
16911 (setq from-position (point))
|
|
16912 (insert-rectangle
|
|
16913 (column-of-graph height (car numbers-list)))
|
|
16914 @end group
|
|
16915 @group
|
|
16916 (goto-char from-position)
|
|
16917 (forward-char symbol-width)
|
|
16918 (sit-for 0) ; @r{Draw graph column by column.}
|
|
16919 (recursive-graph-body-print-internal
|
|
16920 (cdr numbers-list) height symbol-width)))
|
|
16921 @end group
|
|
16922 @end smallexample
|
|
16923
|
|
16924 @need 1250
|
|
16925 After installation, this expression can be tested; here is a sample:
|
|
16926
|
|
16927 @smallexample
|
|
16928 (recursive-graph-body-print '(3 2 5 6 7 5 3 4 6 4 3 2 1))
|
|
16929 @end smallexample
|
|
16930
|
|
16931 @need 800
|
|
16932 Here is what @code{recursive-graph-body-print} produces:
|
|
16933
|
|
16934 @smallexample
|
|
16935 @group
|
|
16936 *
|
|
16937 ** *
|
|
16938 **** *
|
|
16939 **** ***
|
|
16940 * *********
|
|
16941 ************
|
|
16942 *************
|
|
16943 @end group
|
|
16944 @end smallexample
|
|
16945
|
|
16946 Either of these two functions, @code{graph-body-print} or
|
|
16947 @code{recursive-graph-body-print}, create the body of a graph.
|
|
16948
|
|
16949 @node Printed Axes, Line Graph Exercise, recursive-graph-body-print, Readying a Graph
|
|
16950 @section Need for Printed Axes
|
|
16951
|
|
16952 A graph needs printed axes, so you can orient yourself. For a do-once
|
|
16953 project, it may be reasonable to draw the axes by hand using Emacs'
|
|
16954 Picture mode; but a graph drawing function may be used more than once.
|
|
16955
|
|
16956 For this reason, I have written enhancements to the basic
|
|
16957 @code{print-graph-body} function that automatically print labels for
|
|
16958 the horizontal and vertical axes. Since the label printing functions
|
|
16959 do not contain much new material, I have placed their description in
|
|
16960 an appendix. @xref{Full Graph, , A Graph with Labelled Axes}.
|
|
16961
|
|
16962 @node Line Graph Exercise, , Printed Axes, Readying a Graph
|
|
16963 @section Exercise
|
|
16964
|
|
16965 Write a line graph version of the graph printing functions.
|
|
16966
|
|
16967 @node Emacs Initialization, Debugging, Readying a Graph, Top
|
|
16968 @chapter Your @file{.emacs} File
|
|
16969 @cindex @file{.emacs} file
|
|
16970 @cindex Customizing your @file{.emacs} file
|
|
16971 @cindex Initialization file
|
|
16972
|
|
16973 ``You don't have to like Emacs to like it'' -- this seemingly
|
|
16974 paradoxical statement is the secret of GNU Emacs. The plain, `out of
|
|
16975 the box' Emacs is a generic tool. Most people who use it, customize
|
|
16976 it to suit themselves.
|
|
16977
|
|
16978 GNU Emacs is mostly written in Emacs Lisp; this means that by writing
|
|
16979 expressions in Emacs Lisp you can change or extend Emacs.
|
|
16980
|
|
16981 @menu
|
|
16982 * Default Configuration::
|
|
16983 * Site-wide Init:: You can write site-wide init files.
|
|
16984 * defcustom:: Emacs will write code for you.
|
|
16985 * Beginning a .emacs File:: How to write a @code{.emacs file}.
|
|
16986 * Text and Auto-fill:: Automatically wrap lines.
|
|
16987 * Mail Aliases:: Use abbreviations for email addresses.
|
|
16988 * Indent Tabs Mode:: Don't use tabs with @TeX{}
|
|
16989 * Keybindings:: Create some personal keybindings.
|
|
16990 * Keymaps:: More about key binding.
|
|
16991 * Loading Files:: Load (i.e., evaluate) files automatically.
|
|
16992 * Autoload:: Make functions available.
|
|
16993 * Simple Extension:: Define a function; bind it to a key.
|
|
16994 * X11 Colors:: Colors in X.
|
|
16995 * Miscellaneous::
|
|
16996 * Mode Line:: How to customize your mode line.
|
|
16997 @end menu
|
|
16998
|
|
16999 @node Default Configuration, Site-wide Init, Emacs Initialization, Emacs Initialization
|
|
17000 @ifnottex
|
|
17001 @unnumberedsec Emacs' Default Configuration
|
|
17002 @end ifnottex
|
|
17003
|
|
17004 There are those who appreciate Emacs' default configuration. After
|
|
17005 all, Emacs starts you in C mode when you edit a C file, starts you in
|
|
17006 Fortran mode when you edit a Fortran file, and starts you in
|
|
17007 Fundamental mode when you edit an unadorned file. This all makes
|
|
17008 sense, if you do not know who is going to use Emacs. Who knows what a
|
|
17009 person hopes to do with an unadorned file? Fundamental mode is the
|
|
17010 right default for such a file, just as C mode is the right default for
|
|
17011 editing C code. (Enough programming languages have syntaxes
|
|
17012 that enable them to share or nearly share features, so C mode is
|
102187
|
17013 now provided by CC mode, the `C Collection'.)
|
83955
|
17014
|
|
17015 But when you do know who is going to use Emacs---you,
|
|
17016 yourself---then it makes sense to customize Emacs.
|
|
17017
|
|
17018 For example, I seldom want Fundamental mode when I edit an
|
|
17019 otherwise undistinguished file; I want Text mode. This is why I
|
|
17020 customize Emacs: so it suits me.
|
|
17021
|
|
17022 You can customize and extend Emacs by writing or adapting a
|
|
17023 @file{~/.emacs} file. This is your personal initialization file; its
|
|
17024 contents, written in Emacs Lisp, tell Emacs what to do.@footnote{You
|
|
17025 may also add @file{.el} to @file{~/.emacs} and call it a
|
|
17026 @file{~/.emacs.el} file. In the past, you were forbidden to type the
|
|
17027 extra keystrokes that the name @file{~/.emacs.el} requires, but now
|
|
17028 you may. The new format is consistent with the Emacs Lisp file
|
|
17029 naming conventions; the old format saves typing.}
|
|
17030
|
|
17031 A @file{~/.emacs} file contains Emacs Lisp code. You can write this
|
|
17032 code yourself; or you can use Emacs' @code{customize} feature to write
|
|
17033 the code for you. You can combine your own expressions and
|
|
17034 auto-written Customize expressions in your @file{.emacs} file.
|
|
17035
|
|
17036 (I myself prefer to write my own expressions, except for those,
|
|
17037 particularly fonts, that I find easier to manipulate using the
|
|
17038 @code{customize} command. I combine the two methods.)
|
|
17039
|
|
17040 Most of this chapter is about writing expressions yourself. It
|
|
17041 describes a simple @file{.emacs} file; for more information, see
|
|
17042 @ref{Init File, , The Init File, emacs, The GNU Emacs Manual}, and
|
|
17043 @ref{Init File, , The Init File, elisp, The GNU Emacs Lisp Reference
|
|
17044 Manual}.
|
|
17045
|
|
17046 @node Site-wide Init, defcustom, Default Configuration, Emacs Initialization
|
|
17047 @section Site-wide Initialization Files
|
|
17048
|
|
17049 @cindex @file{default.el} init file
|
|
17050 @cindex @file{site-init.el} init file
|
|
17051 @cindex @file{site-load.el} init file
|
|
17052 In addition to your personal initialization file, Emacs automatically
|
|
17053 loads various site-wide initialization files, if they exist. These
|
|
17054 have the same form as your @file{.emacs} file, but are loaded by
|
|
17055 everyone.
|
|
17056
|
|
17057 Two site-wide initialization files, @file{site-load.el} and
|
|
17058 @file{site-init.el}, are loaded into Emacs and then `dumped' if a
|
|
17059 `dumped' version of Emacs is created, as is most common. (Dumped
|
|
17060 copies of Emacs load more quickly. However, once a file is loaded and
|
|
17061 dumped, a change to it does not lead to a change in Emacs unless you
|
|
17062 load it yourself or re-dump Emacs. @xref{Building Emacs, , Building
|
|
17063 Emacs, elisp, The GNU Emacs Lisp Reference Manual}, and the
|
|
17064 @file{INSTALL} file.)
|
|
17065
|
|
17066 Three other site-wide initialization files are loaded automatically
|
|
17067 each time you start Emacs, if they exist. These are
|
|
17068 @file{site-start.el}, which is loaded @emph{before} your @file{.emacs}
|
|
17069 file, and @file{default.el}, and the terminal type file, which are both
|
|
17070 loaded @emph{after} your @file{.emacs} file.
|
|
17071
|
|
17072 Settings and definitions in your @file{.emacs} file will overwrite
|
|
17073 conflicting settings and definitions in a @file{site-start.el} file,
|
|
17074 if it exists; but the settings and definitions in a @file{default.el}
|
|
17075 or terminal type file will overwrite those in your @file{.emacs} file.
|
|
17076 (You can prevent interference from a terminal type file by setting
|
|
17077 @code{term-file-prefix} to @code{nil}. @xref{Simple Extension, , A
|
|
17078 Simple Extension}.)
|
|
17079
|
|
17080 @c Rewritten to avoid overfull hbox.
|
|
17081 The @file{INSTALL} file that comes in the distribution contains
|
|
17082 descriptions of the @file{site-init.el} and @file{site-load.el} files.
|
|
17083
|
|
17084 The @file{loadup.el}, @file{startup.el}, and @file{loaddefs.el} files
|
|
17085 control loading. These files are in the @file{lisp} directory of the
|
|
17086 Emacs distribution and are worth perusing.
|
|
17087
|
|
17088 The @file{loaddefs.el} file contains a good many suggestions as to
|
|
17089 what to put into your own @file{.emacs} file, or into a site-wide
|
|
17090 initialization file.
|
|
17091
|
|
17092 @node defcustom, Beginning a .emacs File, Site-wide Init, Emacs Initialization
|
|
17093 @section Specifying Variables using @code{defcustom}
|
|
17094 @findex defcustom
|
|
17095
|
|
17096 You can specify variables using @code{defcustom} so that you and
|
|
17097 others can then use Emacs' @code{customize} feature to set their
|
|
17098 values. (You cannot use @code{customize} to write function
|
|
17099 definitions; but you can write @code{defuns} in your @file{.emacs}
|
|
17100 file. Indeed, you can write any Lisp expression in your @file{.emacs}
|
|
17101 file.)
|
|
17102
|
|
17103 The @code{customize} feature depends on the @code{defcustom} special
|
|
17104 form. Although you can use @code{defvar} or @code{setq} for variables
|
|
17105 that users set, the @code{defcustom} special form is designed for the
|
|
17106 job.
|
|
17107
|
|
17108 You can use your knowledge of @code{defvar} for writing the
|
|
17109 first three arguments for @code{defcustom}. The first argument to
|
|
17110 @code{defcustom} is the name of the variable. The second argument is
|
|
17111 the variable's initial value, if any; and this value is set only if
|
|
17112 the value has not already been set. The third argument is the
|
|
17113 documentation.
|
|
17114
|
|
17115 The fourth and subsequent arguments to @code{defcustom} specify types
|
|
17116 and options; these are not featured in @code{defvar}. (These
|
|
17117 arguments are optional.)
|
|
17118
|
|
17119 Each of these arguments consists of a keyword followed by a value.
|
|
17120 Each keyword starts with the colon character @samp{:}.
|
|
17121
|
|
17122 @need 1250
|
|
17123 For example, the customizable user option variable
|
|
17124 @code{text-mode-hook} looks like this:
|
|
17125
|
|
17126 @smallexample
|
|
17127 @group
|
|
17128 (defcustom text-mode-hook nil
|
|
17129 "Normal hook run when entering Text mode and many related modes."
|
|
17130 :type 'hook
|
|
17131 :options '(turn-on-auto-fill flyspell-mode)
|
|
17132 :group 'data)
|
|
17133 @end group
|
|
17134 @end smallexample
|
|
17135
|
|
17136 @noindent
|
|
17137 The name of the variable is @code{text-mode-hook}; it has no default
|
|
17138 value; and its documentation string tells you what it does.
|
|
17139
|
|
17140 The @code{:type} keyword tells Emacs the kind of data to which
|
|
17141 @code{text-mode-hook} should be set and how to display the value in a
|
|
17142 Customization buffer.
|
|
17143
|
|
17144 The @code{:options} keyword specifies a suggested list of values for
|
|
17145 the variable. Usually, @code{:options} applies to a hook.
|
|
17146 The list is only a suggestion; it is not exclusive; a person who sets
|
|
17147 the variable may set it to other values; the list shown following the
|
|
17148 @code{:options} keyword is intended to offer convenient choices to a
|
|
17149 user.
|
|
17150
|
|
17151 Finally, the @code{:group} keyword tells the Emacs Customization
|
|
17152 command in which group the variable is located. This tells where to
|
|
17153 find it.
|
|
17154
|
|
17155 The @code{defcustom} function recognizes more than a dozen keywords.
|
|
17156 For more information, see @ref{Customization, , Writing Customization
|
|
17157 Definitions, elisp, The GNU Emacs Lisp Reference Manual}.
|
|
17158
|
|
17159 Consider @code{text-mode-hook} as an example.
|
|
17160
|
|
17161 There are two ways to customize this variable. You can use the
|
|
17162 customization command or write the appropriate expressions yourself.
|
|
17163
|
|
17164 @need 800
|
|
17165 Using the customization command, you can type:
|
|
17166
|
|
17167 @smallexample
|
|
17168 M-x customize
|
|
17169 @end smallexample
|
|
17170
|
|
17171 @noindent
|
|
17172 and find that the group for editing files of data is called `data'.
|
|
17173 Enter that group. Text Mode Hook is the first member. You can click
|
|
17174 on its various options, such as @code{turn-on-auto-fill}, to set the
|
|
17175 values. After you click on the button to
|
|
17176
|
|
17177 @smallexample
|
|
17178 Save for Future Sessions
|
|
17179 @end smallexample
|
|
17180
|
|
17181 @noindent
|
|
17182 Emacs will write an expression into your @file{.emacs} file.
|
|
17183 It will look like this:
|
|
17184
|
|
17185 @smallexample
|
|
17186 @group
|
|
17187 (custom-set-variables
|
|
17188 ;; custom-set-variables was added by Custom.
|
|
17189 ;; If you edit it by hand, you could mess it up, so be careful.
|
|
17190 ;; Your init file should contain only one such instance.
|
|
17191 ;; If there is more than one, they won't work right.
|
|
17192 '(text-mode-hook (quote (turn-on-auto-fill text-mode-hook-identify))))
|
|
17193 @end group
|
|
17194 @end smallexample
|
|
17195
|
|
17196 @noindent
|
|
17197 (The @code{text-mode-hook-identify} function tells
|
|
17198 @code{toggle-text-mode-auto-fill} which buffers are in Text mode.
|
|
17199 It comes on automatically.)
|
|
17200
|
|
17201 The @code{custom-set-variables} function works somewhat differently
|
|
17202 than a @code{setq}. While I have never learned the differences, I
|
|
17203 modify the @code{custom-set-variables} expressions in my @file{.emacs}
|
|
17204 file by hand: I make the changes in what appears to me to be a
|
|
17205 reasonable manner and have not had any problems. Others prefer to use
|
|
17206 the Customization command and let Emacs do the work for them.
|
|
17207
|
|
17208 Another @code{custom-set-@dots{}} function is @code{custom-set-faces}.
|
|
17209 This function sets the various font faces. Over time, I have set a
|
|
17210 considerable number of faces. Some of the time, I re-set them using
|
|
17211 @code{customize}; other times, I simply edit the
|
|
17212 @code{custom-set-faces} expression in my @file{.emacs} file itself.
|
|
17213
|
|
17214 The second way to customize your @code{text-mode-hook} is to set it
|
|
17215 yourself in your @file{.emacs} file using code that has nothing to do
|
|
17216 with the @code{custom-set-@dots{}} functions.
|
|
17217
|
|
17218 @need 800
|
|
17219 When you do this, and later use @code{customize}, you will see a
|
|
17220 message that says
|
|
17221
|
|
17222 @smallexample
|
|
17223 CHANGED outside Customize; operating on it here may be unreliable.
|
|
17224 @end smallexample
|
|
17225
|
|
17226 @need 800
|
|
17227 This message is only a warning. If you click on the button to
|
|
17228
|
|
17229 @smallexample
|
|
17230 Save for Future Sessions
|
|
17231 @end smallexample
|
|
17232
|
|
17233 @noindent
|
|
17234 Emacs will write a @code{custom-set-@dots{}} expression near the end
|
|
17235 of your @file{.emacs} file that will be evaluated after your
|
|
17236 hand-written expression. It will, therefore, overrule your
|
|
17237 hand-written expression. No harm will be done. When you do this,
|
|
17238 however, be careful to remember which expression is active; if you
|
|
17239 forget, you may confuse yourself.
|
|
17240
|
|
17241 So long as you remember where the values are set, you will have no
|
|
17242 trouble. In any event, the values are always set in your
|
|
17243 initialization file, which is usually called @file{.emacs}.
|
|
17244
|
|
17245 I myself use @code{customize} for hardly anything. Mostly, I write
|
|
17246 expressions myself.
|
|
17247
|
|
17248 @findex defsubst
|
|
17249 @findex defconst
|
|
17250 Incidentally, to be more complete concerning defines: @code{defsubst}
|
|
17251 defines an inline function. The syntax is just like that of
|
|
17252 @code{defun}. @code{defconst} defines a symbol as a constant. The
|
|
17253 intent is that neither programs nor users should ever change a value
|
|
17254 set by @code{defconst}. (You can change it; the value set is a
|
|
17255 variable; but please do not.)
|
|
17256
|
|
17257 @node Beginning a .emacs File, Text and Auto-fill, defcustom, Emacs Initialization
|
|
17258 @section Beginning a @file{.emacs} File
|
|
17259 @cindex @file{.emacs} file, beginning of
|
|
17260
|
|
17261 When you start Emacs, it loads your @file{.emacs} file unless you tell
|
|
17262 it not to by specifying @samp{-q} on the command line. (The
|
|
17263 @code{emacs -q} command gives you a plain, out-of-the-box Emacs.)
|
|
17264
|
|
17265 A @file{.emacs} file contains Lisp expressions. Often, these are no
|
|
17266 more than expressions to set values; sometimes they are function
|
|
17267 definitions.
|
|
17268
|
|
17269 @xref{Init File, , The Init File @file{~/.emacs}, emacs, The GNU Emacs
|
|
17270 Manual}, for a short description of initialization files.
|
|
17271
|
|
17272 This chapter goes over some of the same ground, but is a walk among
|
|
17273 extracts from a complete, long-used @file{.emacs} file---my own.
|
|
17274
|
|
17275 The first part of the file consists of comments: reminders to myself.
|
|
17276 By now, of course, I remember these things, but when I started, I did
|
|
17277 not.
|
|
17278
|
|
17279 @need 1200
|
|
17280 @smallexample
|
|
17281 @group
|
|
17282 ;;;; Bob's .emacs file
|
|
17283 ; Robert J. Chassell
|
|
17284 ; 26 September 1985
|
|
17285 @end group
|
|
17286 @end smallexample
|
|
17287
|
|
17288 @noindent
|
|
17289 Look at that date! I started this file a long time ago. I have been
|
|
17290 adding to it ever since.
|
|
17291
|
|
17292 @smallexample
|
|
17293 @group
|
|
17294 ; Each section in this file is introduced by a
|
|
17295 ; line beginning with four semicolons; and each
|
|
17296 ; entry is introduced by a line beginning with
|
|
17297 ; three semicolons.
|
|
17298 @end group
|
|
17299 @end smallexample
|
|
17300
|
|
17301 @noindent
|
|
17302 This describes the usual conventions for comments in Emacs Lisp.
|
|
17303 Everything on a line that follows a semicolon is a comment. Two,
|
|
17304 three, and four semicolons are used as subsection and section markers.
|
|
17305 (@xref{Comments, ,, elisp, The GNU Emacs Lisp Reference Manual}, for
|
|
17306 more about comments.)
|
|
17307
|
|
17308 @smallexample
|
|
17309 @group
|
|
17310 ;;;; The Help Key
|
|
17311 ; Control-h is the help key;
|
|
17312 ; after typing control-h, type a letter to
|
|
17313 ; indicate the subject about which you want help.
|
|
17314 ; For an explanation of the help facility,
|
|
17315 ; type control-h two times in a row.
|
|
17316 @end group
|
|
17317 @end smallexample
|
|
17318
|
|
17319 @noindent
|
|
17320 Just remember: type @kbd{C-h} two times for help.
|
|
17321
|
|
17322 @smallexample
|
|
17323 @group
|
|
17324 ; To find out about any mode, type control-h m
|
|
17325 ; while in that mode. For example, to find out
|
|
17326 ; about mail mode, enter mail mode and then type
|
|
17327 ; control-h m.
|
|
17328 @end group
|
|
17329 @end smallexample
|
|
17330
|
|
17331 @noindent
|
|
17332 `Mode help', as I call this, is very helpful. Usually, it tells you
|
|
17333 all you need to know.
|
|
17334
|
|
17335 Of course, you don't need to include comments like these in your
|
|
17336 @file{.emacs} file. I included them in mine because I kept forgetting
|
|
17337 about Mode help or the conventions for comments---but I was able to
|
|
17338 remember to look here to remind myself.
|
|
17339
|
|
17340 @node Text and Auto-fill, Mail Aliases, Beginning a .emacs File, Emacs Initialization
|
|
17341 @section Text and Auto Fill Mode
|
|
17342
|
|
17343 Now we come to the part that `turns on' Text mode and
|
|
17344 Auto Fill mode.
|
|
17345
|
|
17346 @smallexample
|
|
17347 @group
|
|
17348 ;;; Text mode and Auto Fill mode
|
|
17349 ; The next two lines put Emacs into Text mode
|
|
17350 ; and Auto Fill mode, and are for writers who
|
|
17351 ; want to start writing prose rather than code.
|
|
17352 (setq default-major-mode 'text-mode)
|
|
17353 (add-hook 'text-mode-hook 'turn-on-auto-fill)
|
|
17354 @end group
|
|
17355 @end smallexample
|
|
17356
|
|
17357 Here is the first part of this @file{.emacs} file that does something
|
|
17358 besides remind a forgetful human!
|
|
17359
|
|
17360 The first of the two lines in parentheses tells Emacs to turn on Text
|
|
17361 mode when you find a file, @emph{unless} that file should go into some
|
|
17362 other mode, such as C mode.
|
|
17363
|
|
17364 @cindex Per-buffer, local variables list
|
|
17365 @cindex Local variables list, per-buffer,
|
|
17366 @cindex Automatic mode selection
|
|
17367 @cindex Mode selection, automatic
|
|
17368 When Emacs reads a file, it looks at the extension to the file name,
|
|
17369 if any. (The extension is the part that comes after a @samp{.}.) If
|
|
17370 the file ends with a @samp{.c} or @samp{.h} extension then Emacs turns
|
|
17371 on C mode. Also, Emacs looks at first nonblank line of the file; if
|
|
17372 the line says @w{@samp{-*- C -*-}}, Emacs turns on C mode. Emacs
|
|
17373 possesses a list of extensions and specifications that it uses
|
|
17374 automatically. In addition, Emacs looks near the last page for a
|
|
17375 per-buffer, ``local variables list'', if any.
|
|
17376
|
|
17377 @ifinfo
|
|
17378 @xref{Choosing Modes, , How Major Modes are Chosen, emacs, The GNU
|
|
17379 Emacs Manual}.
|
|
17380
|
|
17381 @xref{File Variables, , Local Variables in Files, emacs, The GNU Emacs
|
|
17382 Manual}.
|
|
17383 @end ifinfo
|
|
17384 @iftex
|
|
17385 See sections ``How Major Modes are Chosen'' and ``Local Variables in
|
|
17386 Files'' in @cite{The GNU Emacs Manual}.
|
|
17387 @end iftex
|
|
17388
|
|
17389 Now, back to the @file{.emacs} file.
|
|
17390
|
|
17391 @need 800
|
|
17392 Here is the line again; how does it work?
|
|
17393
|
|
17394 @cindex Text Mode turned on
|
|
17395 @smallexample
|
104626
caa79498564a
* subr.el (default-mode-line-format, default-header-line-format)
Stefan Monnier <monnier@iro.umontreal.ca>
diff
changeset
|
17396 (setq major-mode 'text-mode)
|
83955
|
17397 @end smallexample
|
|
17398
|
|
17399 @noindent
|
|
17400 This line is a short, but complete Emacs Lisp expression.
|
|
17401
|
|
17402 We are already familiar with @code{setq}. It sets the following variable,
|
104626
caa79498564a
* subr.el (default-mode-line-format, default-header-line-format)
Stefan Monnier <monnier@iro.umontreal.ca>
diff
changeset
|
17403 @code{major-mode}, to the subsequent value, which is @code{text-mode}.
|
caa79498564a
* subr.el (default-mode-line-format, default-header-line-format)
Stefan Monnier <monnier@iro.umontreal.ca>
diff
changeset
|
17404 The single quote mark before @code{text-mode} tells Emacs to deal directly
|
caa79498564a
* subr.el (default-mode-line-format, default-header-line-format)
Stefan Monnier <monnier@iro.umontreal.ca>
diff
changeset
|
17405 with the @code{text-mode} symbol, not with whatever it might stand for.
|
caa79498564a
* subr.el (default-mode-line-format, default-header-line-format)
Stefan Monnier <monnier@iro.umontreal.ca>
diff
changeset
|
17406 @xref{set & setq, , Setting the Value of a Variable},
|
caa79498564a
* subr.el (default-mode-line-format, default-header-line-format)
Stefan Monnier <monnier@iro.umontreal.ca>
diff
changeset
|
17407 for a reminder of how @code{setq} works.
|
caa79498564a
* subr.el (default-mode-line-format, default-header-line-format)
Stefan Monnier <monnier@iro.umontreal.ca>
diff
changeset
|
17408 The main point is that there is no difference between the procedure you
|
caa79498564a
* subr.el (default-mode-line-format, default-header-line-format)
Stefan Monnier <monnier@iro.umontreal.ca>
diff
changeset
|
17409 use to set a value in your @file{.emacs} file and the procedure you use
|
caa79498564a
* subr.el (default-mode-line-format, default-header-line-format)
Stefan Monnier <monnier@iro.umontreal.ca>
diff
changeset
|
17410 anywhere else in Emacs.
|
83955
|
17411
|
|
17412 @need 800
|
|
17413 Here is the next line:
|
|
17414
|
|
17415 @cindex Auto Fill mode turned on
|
|
17416 @findex add-hook
|
|
17417 @smallexample
|
|
17418 (add-hook 'text-mode-hook 'turn-on-auto-fill)
|
|
17419 @end smallexample
|
|
17420
|
|
17421 @noindent
|
|
17422 In this line, the @code{add-hook} command adds
|
|
17423 @code{turn-on-auto-fill} to the variable.
|
|
17424
|
|
17425 @code{turn-on-auto-fill} is the name of a program, that, you guessed
|
|
17426 it!, turns on Auto Fill mode.
|
|
17427
|
|
17428 Every time Emacs turns on Text mode, Emacs runs the commands `hooked'
|
|
17429 onto Text mode. So every time Emacs turns on Text mode, Emacs also
|
|
17430 turns on Auto Fill mode.
|
|
17431
|
|
17432 In brief, the first line causes Emacs to enter Text mode when you edit a
|
|
17433 file, unless the file name extension, a first non-blank line, or local
|
|
17434 variables to tell Emacs otherwise.
|
|
17435
|
|
17436 Text mode among other actions, sets the syntax table to work
|
|
17437 conveniently for writers. In Text mode, Emacs considers an apostrophe
|
|
17438 as part of a word like a letter; but Emacs does not consider a period
|
|
17439 or a space as part of a word. Thus, @kbd{M-f} moves you over
|
|
17440 @samp{it's}. On the other hand, in C mode, @kbd{M-f} stops just after
|
|
17441 the @samp{t} of @samp{it's}.
|
|
17442
|
|
17443 The second line causes Emacs to turn on Auto Fill mode when it turns
|
|
17444 on Text mode. In Auto Fill mode, Emacs automatically breaks a line
|
|
17445 that is too wide and brings the excessively wide part of the line down
|
|
17446 to the next line. Emacs breaks lines between words, not within them.
|
|
17447
|
|
17448 When Auto Fill mode is turned off, lines continue to the right as you
|
|
17449 type them. Depending on how you set the value of
|
|
17450 @code{truncate-lines}, the words you type either disappear off the
|
|
17451 right side of the screen, or else are shown, in a rather ugly and
|
|
17452 unreadable manner, as a continuation line on the screen.
|
|
17453
|
|
17454 @need 1250
|
|
17455 In addition, in this part of my @file{.emacs} file, I tell the Emacs
|
|
17456 fill commands to insert two spaces after a colon:
|
|
17457
|
|
17458 @smallexample
|
|
17459 (setq colon-double-space t)
|
|
17460 @end smallexample
|
|
17461
|
|
17462 @node Mail Aliases, Indent Tabs Mode, Text and Auto-fill, Emacs Initialization
|
|
17463 @section Mail Aliases
|
|
17464
|
|
17465 Here is a @code{setq} that `turns on' mail aliases, along with more
|
|
17466 reminders.
|
|
17467
|
|
17468 @smallexample
|
|
17469 @group
|
|
17470 ;;; Mail mode
|
|
17471 ; To enter mail mode, type `C-x m'
|
|
17472 ; To enter RMAIL (for reading mail),
|
|
17473 ; type `M-x rmail'
|
|
17474 (setq mail-aliases t)
|
|
17475 @end group
|
|
17476 @end smallexample
|
|
17477
|
|
17478 @cindex Mail aliases
|
|
17479 @noindent
|
|
17480 This @code{setq} command sets the value of the variable
|
|
17481 @code{mail-aliases} to @code{t}. Since @code{t} means true, the line
|
|
17482 says, in effect, ``Yes, use mail aliases.''
|
|
17483
|
|
17484 Mail aliases are convenient short names for long email addresses or
|
|
17485 for lists of email addresses. The file where you keep your `aliases'
|
|
17486 is @file{~/.mailrc}. You write an alias like this:
|
|
17487
|
|
17488 @smallexample
|
|
17489 alias geo george@@foobar.wiz.edu
|
|
17490 @end smallexample
|
|
17491
|
|
17492 @noindent
|
|
17493 When you write a message to George, address it to @samp{geo}; the
|
|
17494 mailer will automatically expand @samp{geo} to the full address.
|
|
17495
|
|
17496 @node Indent Tabs Mode, Keybindings, Mail Aliases, Emacs Initialization
|
|
17497 @section Indent Tabs Mode
|
|
17498 @cindex Tabs, preventing
|
|
17499 @findex indent-tabs-mode
|
|
17500
|
|
17501 By default, Emacs inserts tabs in place of multiple spaces when it
|
|
17502 formats a region. (For example, you might indent many lines of text
|
|
17503 all at once with the @code{indent-region} command.) Tabs look fine on
|
|
17504 a terminal or with ordinary printing, but they produce badly indented
|
|
17505 output when you use @TeX{} or Texinfo since @TeX{} ignores tabs.
|
|
17506
|
|
17507 @need 1250
|
|
17508 The following turns off Indent Tabs mode:
|
|
17509
|
|
17510 @smallexample
|
|
17511 @group
|
|
17512 ;;; Prevent Extraneous Tabs
|
|
17513 (setq-default indent-tabs-mode nil)
|
|
17514 @end group
|
|
17515 @end smallexample
|
|
17516
|
|
17517 Note that this line uses @code{setq-default} rather than the
|
|
17518 @code{setq} command that we have seen before. The @code{setq-default}
|
|
17519 command sets values only in buffers that do not have their own local
|
|
17520 values for the variable.
|
|
17521
|
|
17522 @ifinfo
|
|
17523 @xref{Just Spaces, , Tabs vs. Spaces, emacs, The GNU Emacs Manual}.
|
|
17524
|
|
17525 @xref{File Variables, , Local Variables in Files, emacs, The GNU Emacs
|
|
17526 Manual}.
|
|
17527 @end ifinfo
|
|
17528 @iftex
|
|
17529 See sections ``Tabs vs.@: Spaces'' and ``Local Variables in
|
|
17530 Files'' in @cite{The GNU Emacs Manual}.
|
|
17531 @end iftex
|
|
17532
|
|
17533 @need 1700
|
|
17534 @node Keybindings, Keymaps, Indent Tabs Mode, Emacs Initialization
|
|
17535 @section Some Keybindings
|
|
17536
|
|
17537 Now for some personal keybindings:
|
|
17538
|
|
17539 @smallexample
|
|
17540 @group
|
|
17541 ;;; Compare windows
|
|
17542 (global-set-key "\C-cw" 'compare-windows)
|
|
17543 @end group
|
|
17544 @end smallexample
|
|
17545
|
|
17546 @findex compare-windows
|
|
17547 @code{compare-windows} is a nifty command that compares the text in
|
|
17548 your current window with text in the next window. It makes the
|
|
17549 comparison by starting at point in each window, moving over text in
|
|
17550 each window as far as they match. I use this command all the time.
|
|
17551
|
|
17552 This also shows how to set a key globally, for all modes.
|
|
17553
|
|
17554 @cindex Setting a key globally
|
|
17555 @cindex Global set key
|
|
17556 @cindex Key setting globally
|
|
17557 @findex global-set-key
|
|
17558 The command is @code{global-set-key}. It is followed by the
|
|
17559 keybinding. In a @file{.emacs} file, the keybinding is written as
|
|
17560 shown: @code{\C-c} stands for `control-c', which means `press the
|
|
17561 control key and the @key{c} key at the same time'. The @code{w} means
|
|
17562 `press the @key{w} key'. The keybinding is surrounded by double
|
|
17563 quotation marks. In documentation, you would write this as
|
|
17564 @w{@kbd{C-c w}}. (If you were binding a @key{META} key, such as
|
|
17565 @kbd{M-c}, rather than a @key{CTRL} key, you would write
|
|
17566 @w{@code{\M-c}} in your @file{.emacs} file. @xref{Init Rebinding, ,
|
|
17567 Rebinding Keys in Your Init File, emacs, The GNU Emacs Manual}, for
|
|
17568 details.)
|
|
17569
|
|
17570 The command invoked by the keys is @code{compare-windows}. Note that
|
|
17571 @code{compare-windows} is preceded by a single quote; otherwise, Emacs
|
|
17572 would first try to evaluate the symbol to determine its value.
|
|
17573
|
|
17574 These three things, the double quotation marks, the backslash before
|
|
17575 the @samp{C}, and the single quote mark are necessary parts of
|
|
17576 keybinding that I tend to forget. Fortunately, I have come to
|
|
17577 remember that I should look at my existing @file{.emacs} file, and
|
|
17578 adapt what is there.
|
|
17579
|
|
17580 As for the keybinding itself: @kbd{C-c w}. This combines the prefix
|
|
17581 key, @kbd{C-c}, with a single character, in this case, @kbd{w}. This
|
|
17582 set of keys, @kbd{C-c} followed by a single character, is strictly
|
|
17583 reserved for individuals' own use. (I call these `own' keys, since
|
|
17584 these are for my own use.) You should always be able to create such a
|
|
17585 keybinding for your own use without stomping on someone else's
|
|
17586 keybinding. If you ever write an extension to Emacs, please avoid
|
|
17587 taking any of these keys for public use. Create a key like @kbd{C-c
|
|
17588 C-w} instead. Otherwise, we will run out of `own' keys.
|
|
17589
|
|
17590 @need 1250
|
|
17591 Here is another keybinding, with a comment:
|
|
17592
|
|
17593 @smallexample
|
|
17594 @group
|
|
17595 ;;; Keybinding for `occur'
|
|
17596 ; I use occur a lot, so let's bind it to a key:
|
|
17597 (global-set-key "\C-co" 'occur)
|
|
17598 @end group
|
|
17599 @end smallexample
|
|
17600
|
|
17601 @findex occur
|
|
17602 The @code{occur} command shows all the lines in the current buffer
|
|
17603 that contain a match for a regular expression. Matching lines are
|
|
17604 shown in a buffer called @file{*Occur*}. That buffer serves as a menu
|
|
17605 to jump to occurrences.
|
|
17606
|
|
17607 @findex global-unset-key
|
|
17608 @cindex Unbinding key
|
|
17609 @cindex Key unbinding
|
|
17610 @need 1250
|
|
17611 Here is how to unbind a key, so it does not
|
|
17612 work:
|
|
17613
|
|
17614 @smallexample
|
|
17615 @group
|
|
17616 ;;; Unbind `C-x f'
|
|
17617 (global-unset-key "\C-xf")
|
|
17618 @end group
|
|
17619 @end smallexample
|
|
17620
|
|
17621 There is a reason for this unbinding: I found I inadvertently typed
|
|
17622 @w{@kbd{C-x f}} when I meant to type @kbd{C-x C-f}. Rather than find a
|
|
17623 file, as I intended, I accidentally set the width for filled text,
|
|
17624 almost always to a width I did not want. Since I hardly ever reset my
|
|
17625 default width, I simply unbound the key.
|
|
17626
|
|
17627 @findex list-buffers, @r{rebound}
|
|
17628 @findex buffer-menu, @r{bound to key}
|
|
17629 @need 1250
|
|
17630 The following rebinds an existing key:
|
|
17631
|
|
17632 @smallexample
|
|
17633 @group
|
|
17634 ;;; Rebind `C-x C-b' for `buffer-menu'
|
|
17635 (global-set-key "\C-x\C-b" 'buffer-menu)
|
|
17636 @end group
|
|
17637 @end smallexample
|
|
17638
|
|
17639 By default, @kbd{C-x C-b} runs the
|
|
17640 @code{list-buffers} command. This command lists
|
|
17641 your buffers in @emph{another} window. Since I
|
|
17642 almost always want to do something in that
|
|
17643 window, I prefer the @code{buffer-menu}
|
|
17644 command, which not only lists the buffers,
|
|
17645 but moves point into that window.
|
|
17646
|
|
17647 @node Keymaps, Loading Files, Keybindings, Emacs Initialization
|
|
17648 @section Keymaps
|
|
17649 @cindex Keymaps
|
|
17650 @cindex Rebinding keys
|
|
17651
|
|
17652 Emacs uses @dfn{keymaps} to record which keys call which commands.
|
|
17653 When you use @code{global-set-key} to set the keybinding for a single
|
|
17654 command in all parts of Emacs, you are specifying the keybinding in
|
|
17655 @code{current-global-map}.
|
|
17656
|
|
17657 Specific modes, such as C mode or Text mode, have their own keymaps;
|
|
17658 the mode-specific keymaps override the global map that is shared by
|
|
17659 all buffers.
|
|
17660
|
|
17661 The @code{global-set-key} function binds, or rebinds, the global
|
|
17662 keymap. For example, the following binds the key @kbd{C-x C-b} to the
|
|
17663 function @code{buffer-menu}:
|
|
17664
|
|
17665 @smallexample
|
|
17666 (global-set-key "\C-x\C-b" 'buffer-menu)
|
|
17667 @end smallexample
|
|
17668
|
|
17669 Mode-specific keymaps are bound using the @code{define-key} function,
|
|
17670 which takes a specific keymap as an argument, as well as the key and
|
|
17671 the command. For example, my @file{.emacs} file contains the
|
|
17672 following expression to bind the @code{texinfo-insert-@@group} command
|
|
17673 to @kbd{C-c C-c g}:
|
|
17674
|
|
17675 @smallexample
|
|
17676 @group
|
|
17677 (define-key texinfo-mode-map "\C-c\C-cg" 'texinfo-insert-@@group)
|
|
17678 @end group
|
|
17679 @end smallexample
|
|
17680
|
|
17681 @noindent
|
|
17682 The @code{texinfo-insert-@@group} function itself is a little extension
|
|
17683 to Texinfo mode that inserts @samp{@@group} into a Texinfo file. I
|
|
17684 use this command all the time and prefer to type the three strokes
|
|
17685 @kbd{C-c C-c g} rather than the six strokes @kbd{@@ g r o u p}.
|
|
17686 (@samp{@@group} and its matching @samp{@@end group} are commands that
|
|
17687 keep all enclosed text together on one page; many multi-line examples
|
|
17688 in this book are surrounded by @samp{@@group @dots{} @@end group}.)
|
|
17689
|
|
17690 @need 1250
|
|
17691 Here is the @code{texinfo-insert-@@group} function definition:
|
|
17692
|
|
17693 @smallexample
|
|
17694 @group
|
|
17695 (defun texinfo-insert-@@group ()
|
|
17696 "Insert the string @@group in a Texinfo buffer."
|
|
17697 (interactive)
|
|
17698 (beginning-of-line)
|
|
17699 (insert "@@group\n"))
|
|
17700 @end group
|
|
17701 @end smallexample
|
|
17702
|
|
17703 (Of course, I could have used Abbrev mode to save typing, rather than
|
|
17704 write a function to insert a word; but I prefer key strokes consistent
|
|
17705 with other Texinfo mode key bindings.)
|
|
17706
|
|
17707 You will see numerous @code{define-key} expressions in
|
|
17708 @file{loaddefs.el} as well as in the various mode libraries, such as
|
|
17709 @file{cc-mode.el} and @file{lisp-mode.el}.
|
|
17710
|
|
17711 @xref{Key Bindings, , Customizing Key Bindings, emacs, The GNU Emacs
|
|
17712 Manual}, and @ref{Keymaps, , Keymaps, elisp, The GNU Emacs Lisp
|
|
17713 Reference Manual}, for more information about keymaps.
|
|
17714
|
|
17715 @node Loading Files, Autoload, Keymaps, Emacs Initialization
|
|
17716 @section Loading Files
|
|
17717 @cindex Loading files
|
|
17718 @c findex load
|
|
17719
|
|
17720 Many people in the GNU Emacs community have written extensions to
|
|
17721 Emacs. As time goes by, these extensions are often included in new
|
|
17722 releases. For example, the Calendar and Diary packages are now part
|
|
17723 of the standard GNU Emacs, as is Calc.
|
|
17724
|
|
17725 You can use a @code{load} command to evaluate a complete file and
|
|
17726 thereby install all the functions and variables in the file into Emacs.
|
|
17727 For example:
|
|
17728
|
|
17729 @c (auto-compression-mode t)
|
|
17730
|
|
17731 @smallexample
|
|
17732 (load "~/emacs/slowsplit")
|
|
17733 @end smallexample
|
|
17734
|
|
17735 This evaluates, i.e.@: loads, the @file{slowsplit.el} file or if it
|
|
17736 exists, the faster, byte compiled @file{slowsplit.elc} file from the
|
|
17737 @file{emacs} sub-directory of your home directory. The file contains
|
|
17738 the function @code{split-window-quietly}, which John Robinson wrote in
|
|
17739 1989.
|
|
17740
|
|
17741 The @code{split-window-quietly} function splits a window with the
|
|
17742 minimum of redisplay. I installed it in 1989 because it worked well
|
|
17743 with the slow 1200 baud terminals I was then using. Nowadays, I only
|
|
17744 occasionally come across such a slow connection, but I continue to use
|
|
17745 the function because I like the way it leaves the bottom half of a
|
|
17746 buffer in the lower of the new windows and the top half in the upper
|
|
17747 window.
|
|
17748
|
|
17749 @need 1250
|
|
17750 To replace the key binding for the default
|
|
17751 @code{split-window-vertically}, you must also unset that key and bind
|
|
17752 the keys to @code{split-window-quietly}, like this:
|
|
17753
|
|
17754 @smallexample
|
|
17755 @group
|
|
17756 (global-unset-key "\C-x2")
|
|
17757 (global-set-key "\C-x2" 'split-window-quietly)
|
|
17758 @end group
|
|
17759 @end smallexample
|
|
17760
|
|
17761 @vindex load-path
|
|
17762 If you load many extensions, as I do, then instead of specifying the
|
|
17763 exact location of the extension file, as shown above, you can specify
|
|
17764 that directory as part of Emacs' @code{load-path}. Then, when Emacs
|
|
17765 loads a file, it will search that directory as well as its default
|
|
17766 list of directories. (The default list is specified in @file{paths.h}
|
|
17767 when Emacs is built.)
|
|
17768
|
|
17769 @need 1250
|
|
17770 The following command adds your @file{~/emacs} directory to the
|
|
17771 existing load path:
|
|
17772
|
|
17773 @smallexample
|
|
17774 @group
|
|
17775 ;;; Emacs Load Path
|
|
17776 (setq load-path (cons "~/emacs" load-path))
|
|
17777 @end group
|
|
17778 @end smallexample
|
|
17779
|
|
17780 Incidentally, @code{load-library} is an interactive interface to the
|
|
17781 @code{load} function. The complete function looks like this:
|
|
17782
|
|
17783 @findex load-library
|
|
17784 @smallexample
|
|
17785 @group
|
|
17786 (defun load-library (library)
|
|
17787 "Load the library named LIBRARY.
|
|
17788 This is an interface to the function `load'."
|
|
17789 (interactive
|
|
17790 (list (completing-read "Load library: "
|
94188
|
17791 (apply-partially 'locate-file-completion-table
|
|
17792 load-path
|
|
17793 (get-load-suffixes)))))
|
83955
|
17794 (load library))
|
|
17795 @end group
|
|
17796 @end smallexample
|
|
17797
|
|
17798 The name of the function, @code{load-library}, comes from the use of
|
|
17799 `library' as a conventional synonym for `file'. The source for the
|
|
17800 @code{load-library} command is in the @file{files.el} library.
|
|
17801
|
|
17802 Another interactive command that does a slightly different job is
|
|
17803 @code{load-file}. @xref{Lisp Libraries, , Libraries of Lisp Code for
|
|
17804 Emacs, emacs, The GNU Emacs Manual}, for information on the
|
|
17805 distinction between @code{load-library} and this command.
|
|
17806
|
|
17807 @node Autoload, Simple Extension, Loading Files, Emacs Initialization
|
|
17808 @section Autoloading
|
|
17809 @findex autoload
|
|
17810
|
|
17811 Instead of installing a function by loading the file that contains it,
|
|
17812 or by evaluating the function definition, you can make the function
|
|
17813 available but not actually install it until it is first called. This
|
|
17814 is called @dfn{autoloading}.
|
|
17815
|
|
17816 When you execute an autoloaded function, Emacs automatically evaluates
|
|
17817 the file that contains the definition, and then calls the function.
|
|
17818
|
|
17819 Emacs starts quicker with autoloaded functions, since their libraries
|
|
17820 are not loaded right away; but you need to wait a moment when you
|
|
17821 first use such a function, while its containing file is evaluated.
|
|
17822
|
|
17823 Rarely used functions are frequently autoloaded. The
|
|
17824 @file{loaddefs.el} library contains hundreds of autoloaded functions,
|
|
17825 from @code{bookmark-set} to @code{wordstar-mode}. Of course, you may
|
|
17826 come to use a `rare' function frequently. When you do, you should
|
|
17827 load that function's file with a @code{load} expression in your
|
|
17828 @file{.emacs} file.
|
|
17829
|
|
17830 In my @file{.emacs} file, I load 14 libraries that contain functions
|
|
17831 that would otherwise be autoloaded. (Actually, it would have been
|
|
17832 better to include these files in my `dumped' Emacs, but I forgot.
|
|
17833 @xref{Building Emacs, , Building Emacs, elisp, The GNU Emacs Lisp
|
|
17834 Reference Manual}, and the @file{INSTALL} file for more about
|
|
17835 dumping.)
|
|
17836
|
|
17837 You may also want to include autoloaded expressions in your @file{.emacs}
|
|
17838 file. @code{autoload} is a built-in function that takes up to five
|
|
17839 arguments, the final three of which are optional. The first argument
|
|
17840 is the name of the function to be autoloaded; the second is the name
|
|
17841 of the file to be loaded. The third argument is documentation for the
|
|
17842 function, and the fourth tells whether the function can be called
|
|
17843 interactively. The fifth argument tells what type of
|
|
17844 object---@code{autoload} can handle a keymap or macro as well as a
|
|
17845 function (the default is a function).
|
|
17846
|
|
17847 @need 800
|
|
17848 Here is a typical example:
|
|
17849
|
|
17850 @smallexample
|
|
17851 @group
|
|
17852 (autoload 'html-helper-mode
|
|
17853 "html-helper-mode" "Edit HTML documents" t)
|
|
17854 @end group
|
|
17855 @end smallexample
|
|
17856
|
|
17857 @noindent
|
|
17858 (@code{html-helper-mode} is an older alternative to @code{html-mode},
|
|
17859 which is a standard part of the distribution.)
|
|
17860
|
|
17861 @noindent
|
|
17862 This expression autoloads the @code{html-helper-mode} function. It
|
|
17863 takes it from the @file{html-helper-mode.el} file (or from the byte
|
98525
|
17864 compiled version @file{html-helper-mode.elc}, if that exists.) The
|
|
17865 file must be located in a directory specified by @code{load-path}.
|
|
17866 The documentation says that this is a mode to help you edit documents
|
83955
|
17867 written in the HyperText Markup Language. You can call this mode
|
|
17868 interactively by typing @kbd{M-x html-helper-mode}. (You need to
|
|
17869 duplicate the function's regular documentation in the autoload
|
|
17870 expression because the regular function is not yet loaded, so its
|
|
17871 documentation is not available.)
|
|
17872
|
|
17873 @xref{Autoload, , Autoload, elisp, The GNU Emacs Lisp Reference
|
|
17874 Manual}, for more information.
|
|
17875
|
|
17876 @node Simple Extension, X11 Colors, Autoload, Emacs Initialization
|
|
17877 @section A Simple Extension: @code{line-to-top-of-window}
|
|
17878 @findex line-to-top-of-window
|
|
17879 @cindex Simple extension in @file{.emacs} file
|
|
17880
|
|
17881 Here is a simple extension to Emacs that moves the line point is on to
|
|
17882 the top of the window. I use this all the time, to make text easier
|
|
17883 to read.
|
|
17884
|
|
17885 You can put the following code into a separate file and then load it
|
|
17886 from your @file{.emacs} file, or you can include it within your
|
|
17887 @file{.emacs} file.
|
|
17888
|
|
17889 @need 1250
|
|
17890 Here is the definition:
|
|
17891
|
|
17892 @smallexample
|
|
17893 @group
|
|
17894 ;;; Line to top of window;
|
|
17895 ;;; replace three keystroke sequence C-u 0 C-l
|
|
17896 (defun line-to-top-of-window ()
|
|
17897 "Move the line point is on to top of window."
|
|
17898 (interactive)
|
|
17899 (recenter 0))
|
|
17900 @end group
|
|
17901 @end smallexample
|
|
17902
|
|
17903 @need 1250
|
|
17904 Now for the keybinding.
|
|
17905
|
|
17906 Nowadays, function keys as well as mouse button events and
|
|
17907 non-@sc{ascii} characters are written within square brackets, without
|
|
17908 quotation marks. (In Emacs version 18 and before, you had to write
|
|
17909 different function key bindings for each different make of terminal.)
|
|
17910
|
|
17911 I bind @code{line-to-top-of-window} to my @key{F6} function key like
|
|
17912 this:
|
|
17913
|
|
17914 @smallexample
|
|
17915 (global-set-key [f6] 'line-to-top-of-window)
|
|
17916 @end smallexample
|
|
17917
|
|
17918 For more information, see @ref{Init Rebinding, , Rebinding Keys in
|
|
17919 Your Init File, emacs, The GNU Emacs Manual}.
|
|
17920
|
|
17921 @cindex Conditional 'twixt two versions of Emacs
|
|
17922 @cindex Version of Emacs, choosing
|
|
17923 @cindex Emacs version, choosing
|
104095
5b0ac40cc7c1
* emacs-lisp-intro.texi (Simple Extension): Bump emacs versions in
Chong Yidong <cyd@stupidchicken.com>
diff
changeset
|
17924 If you run two versions of GNU Emacs, such as versions 22 and 23, and
|
83955
|
17925 use one @file{.emacs} file, you can select which code to evaluate with
|
|
17926 the following conditional:
|
|
17927
|
|
17928 @smallexample
|
|
17929 @group
|
|
17930 (cond
|
104095
5b0ac40cc7c1
* emacs-lisp-intro.texi (Simple Extension): Bump emacs versions in
Chong Yidong <cyd@stupidchicken.com>
diff
changeset
|
17931 ((= 22 emacs-major-version)
|
5b0ac40cc7c1
* emacs-lisp-intro.texi (Simple Extension): Bump emacs versions in
Chong Yidong <cyd@stupidchicken.com>
diff
changeset
|
17932 ;; evaluate version 22 code
|
83955
|
17933 ( @dots{} ))
|
104095
5b0ac40cc7c1
* emacs-lisp-intro.texi (Simple Extension): Bump emacs versions in
Chong Yidong <cyd@stupidchicken.com>
diff
changeset
|
17934 ((= 23 emacs-major-version)
|
5b0ac40cc7c1
* emacs-lisp-intro.texi (Simple Extension): Bump emacs versions in
Chong Yidong <cyd@stupidchicken.com>
diff
changeset
|
17935 ;; evaluate version 23 code
|
83955
|
17936 ( @dots{} )))
|
|
17937 @end group
|
|
17938 @end smallexample
|
|
17939
|
|
17940 For example, in contrast to version 20, more recent versions blink
|
|
17941 their cursors by default. I hate such blinking, as well as other
|
|
17942 features, so I placed the following in my @file{.emacs}
|
|
17943 file@footnote{When I start instances of Emacs that do not load my
|
|
17944 @file{.emacs} file or any site file, I also turn off blinking:
|
|
17945
|
|
17946 @smallexample
|
|
17947 emacs -q --no-site-file -eval '(blink-cursor-mode nil)'
|
|
17948
|
|
17949 @exdent Or nowadays, using an even more sophisticated set of options,
|
|
17950
|
|
17951 emacs -Q - D
|
|
17952 @end smallexample
|
|
17953 }:
|
|
17954
|
|
17955 @smallexample
|
|
17956 @group
|
|
17957 (when (>= emacs-major-version 21)
|
|
17958 (blink-cursor-mode 0)
|
104095
5b0ac40cc7c1
* emacs-lisp-intro.texi (Simple Extension): Bump emacs versions in
Chong Yidong <cyd@stupidchicken.com>
diff
changeset
|
17959 ;; Insert newline when you press `C-n' (next-line)
|
5b0ac40cc7c1
* emacs-lisp-intro.texi (Simple Extension): Bump emacs versions in
Chong Yidong <cyd@stupidchicken.com>
diff
changeset
|
17960 ;; at the end of the buffer
|
5b0ac40cc7c1
* emacs-lisp-intro.texi (Simple Extension): Bump emacs versions in
Chong Yidong <cyd@stupidchicken.com>
diff
changeset
|
17961 (setq next-line-add-newlines t)
|
5b0ac40cc7c1
* emacs-lisp-intro.texi (Simple Extension): Bump emacs versions in
Chong Yidong <cyd@stupidchicken.com>
diff
changeset
|
17962 @end group
|
5b0ac40cc7c1
* emacs-lisp-intro.texi (Simple Extension): Bump emacs versions in
Chong Yidong <cyd@stupidchicken.com>
diff
changeset
|
17963 @group
|
5b0ac40cc7c1
* emacs-lisp-intro.texi (Simple Extension): Bump emacs versions in
Chong Yidong <cyd@stupidchicken.com>
diff
changeset
|
17964 ;; Turn on image viewing
|
5b0ac40cc7c1
* emacs-lisp-intro.texi (Simple Extension): Bump emacs versions in
Chong Yidong <cyd@stupidchicken.com>
diff
changeset
|
17965 (auto-image-file-mode t)
|
5b0ac40cc7c1
* emacs-lisp-intro.texi (Simple Extension): Bump emacs versions in
Chong Yidong <cyd@stupidchicken.com>
diff
changeset
|
17966 @end group
|
5b0ac40cc7c1
* emacs-lisp-intro.texi (Simple Extension): Bump emacs versions in
Chong Yidong <cyd@stupidchicken.com>
diff
changeset
|
17967 @group
|
5b0ac40cc7c1
* emacs-lisp-intro.texi (Simple Extension): Bump emacs versions in
Chong Yidong <cyd@stupidchicken.com>
diff
changeset
|
17968 ;; Turn on menu bar (this bar has text)
|
5b0ac40cc7c1
* emacs-lisp-intro.texi (Simple Extension): Bump emacs versions in
Chong Yidong <cyd@stupidchicken.com>
diff
changeset
|
17969 ;; (Use numeric argument to turn on)
|
5b0ac40cc7c1
* emacs-lisp-intro.texi (Simple Extension): Bump emacs versions in
Chong Yidong <cyd@stupidchicken.com>
diff
changeset
|
17970 (menu-bar-mode 1)
|
5b0ac40cc7c1
* emacs-lisp-intro.texi (Simple Extension): Bump emacs versions in
Chong Yidong <cyd@stupidchicken.com>
diff
changeset
|
17971 @end group
|
5b0ac40cc7c1
* emacs-lisp-intro.texi (Simple Extension): Bump emacs versions in
Chong Yidong <cyd@stupidchicken.com>
diff
changeset
|
17972 @group
|
5b0ac40cc7c1
* emacs-lisp-intro.texi (Simple Extension): Bump emacs versions in
Chong Yidong <cyd@stupidchicken.com>
diff
changeset
|
17973 ;; Turn off tool bar (this bar has icons)
|
5b0ac40cc7c1
* emacs-lisp-intro.texi (Simple Extension): Bump emacs versions in
Chong Yidong <cyd@stupidchicken.com>
diff
changeset
|
17974 ;; (Use numeric argument to turn on)
|
5b0ac40cc7c1
* emacs-lisp-intro.texi (Simple Extension): Bump emacs versions in
Chong Yidong <cyd@stupidchicken.com>
diff
changeset
|
17975 (tool-bar-mode nil)
|
5b0ac40cc7c1
* emacs-lisp-intro.texi (Simple Extension): Bump emacs versions in
Chong Yidong <cyd@stupidchicken.com>
diff
changeset
|
17976 @end group
|
5b0ac40cc7c1
* emacs-lisp-intro.texi (Simple Extension): Bump emacs versions in
Chong Yidong <cyd@stupidchicken.com>
diff
changeset
|
17977 @group
|
5b0ac40cc7c1
* emacs-lisp-intro.texi (Simple Extension): Bump emacs versions in
Chong Yidong <cyd@stupidchicken.com>
diff
changeset
|
17978 ;; Turn off tooltip mode for tool bar
|
5b0ac40cc7c1
* emacs-lisp-intro.texi (Simple Extension): Bump emacs versions in
Chong Yidong <cyd@stupidchicken.com>
diff
changeset
|
17979 ;; (This mode causes icon explanations to pop up)
|
5b0ac40cc7c1
* emacs-lisp-intro.texi (Simple Extension): Bump emacs versions in
Chong Yidong <cyd@stupidchicken.com>
diff
changeset
|
17980 ;; (Use numeric argument to turn on)
|
5b0ac40cc7c1
* emacs-lisp-intro.texi (Simple Extension): Bump emacs versions in
Chong Yidong <cyd@stupidchicken.com>
diff
changeset
|
17981 (tooltip-mode nil)
|
5b0ac40cc7c1
* emacs-lisp-intro.texi (Simple Extension): Bump emacs versions in
Chong Yidong <cyd@stupidchicken.com>
diff
changeset
|
17982 ;; If tooltips turned on, make tips appear promptly
|
5b0ac40cc7c1
* emacs-lisp-intro.texi (Simple Extension): Bump emacs versions in
Chong Yidong <cyd@stupidchicken.com>
diff
changeset
|
17983 (setq tooltip-delay 0.1) ; default is 0.7 second
|
5b0ac40cc7c1
* emacs-lisp-intro.texi (Simple Extension): Bump emacs versions in
Chong Yidong <cyd@stupidchicken.com>
diff
changeset
|
17984 )
|
5b0ac40cc7c1
* emacs-lisp-intro.texi (Simple Extension): Bump emacs versions in
Chong Yidong <cyd@stupidchicken.com>
diff
changeset
|
17985 @end group
|
5b0ac40cc7c1
* emacs-lisp-intro.texi (Simple Extension): Bump emacs versions in
Chong Yidong <cyd@stupidchicken.com>
diff
changeset
|
17986 @end smallexample
|
83955
|
17987
|
|
17988 @node X11 Colors, Miscellaneous, Simple Extension, Emacs Initialization
|
|
17989 @section X11 Colors
|
|
17990
|
|
17991 You can specify colors when you use Emacs with the MIT X Windowing
|
|
17992 system.
|
|
17993
|
|
17994 I dislike the default colors and specify my own.
|
|
17995
|
|
17996 @need 1250
|
|
17997 Here are the expressions in my @file{.emacs}
|
|
17998 file that set values:
|
|
17999
|
|
18000 @smallexample
|
|
18001 @group
|
|
18002 ;; Set cursor color
|
|
18003 (set-cursor-color "white")
|
|
18004
|
|
18005 ;; Set mouse color
|
|
18006 (set-mouse-color "white")
|
|
18007
|
|
18008 ;; Set foreground and background
|
|
18009 (set-foreground-color "white")
|
|
18010 (set-background-color "darkblue")
|
|
18011 @end group
|
|
18012
|
|
18013 @group
|
|
18014 ;;; Set highlighting colors for isearch and drag
|
|
18015 (set-face-foreground 'highlight "white")
|
|
18016 (set-face-background 'highlight "blue")
|
|
18017 @end group
|
|
18018
|
|
18019 @group
|
|
18020 (set-face-foreground 'region "cyan")
|
|
18021 (set-face-background 'region "blue")
|
|
18022 @end group
|
|
18023
|
|
18024 @group
|
|
18025 (set-face-foreground 'secondary-selection "skyblue")
|
|
18026 (set-face-background 'secondary-selection "darkblue")
|
|
18027 @end group
|
|
18028
|
|
18029 @group
|
|
18030 ;; Set calendar highlighting colors
|
|
18031 (setq calendar-load-hook
|
|
18032 '(lambda ()
|
|
18033 (set-face-foreground 'diary-face "skyblue")
|
|
18034 (set-face-background 'holiday-face "slate blue")
|
|
18035 (set-face-foreground 'holiday-face "white")))
|
|
18036 @end group
|
|
18037 @end smallexample
|
|
18038
|
|
18039 The various shades of blue soothe my eye and prevent me from seeing
|
|
18040 the screen flicker.
|
|
18041
|
|
18042 Alternatively, I could have set my specifications in various X
|
|
18043 initialization files. For example, I could set the foreground,
|
|
18044 background, cursor, and pointer (i.e., mouse) colors in my
|
|
18045 @file{~/.Xresources} file like this:
|
|
18046
|
|
18047 @smallexample
|
|
18048 @group
|
|
18049 Emacs*foreground: white
|
|
18050 Emacs*background: darkblue
|
|
18051 Emacs*cursorColor: white
|
|
18052 Emacs*pointerColor: white
|
|
18053 @end group
|
|
18054 @end smallexample
|
|
18055
|
|
18056 In any event, since it is not part of Emacs, I set the root color of
|
|
18057 my X window in my @file{~/.xinitrc} file, like this@footnote{I also
|
|
18058 run more modern window managers, such as Enlightenment, Gnome, or KDE;
|
|
18059 in those cases, I often specify an image rather than a plain color.}:
|
|
18060
|
|
18061 @smallexample
|
|
18062 xsetroot -solid Navy -fg white &
|
|
18063 @end smallexample
|
|
18064
|
|
18065 @need 1700
|
|
18066 @node Miscellaneous, Mode Line, X11 Colors, Emacs Initialization
|
|
18067 @section Miscellaneous Settings for a @file{.emacs} File
|
|
18068
|
|
18069 @need 1250
|
|
18070 Here are a few miscellaneous settings:
|
|
18071 @sp 1
|
|
18072
|
|
18073 @itemize @minus
|
|
18074 @item
|
|
18075 Set the shape and color of the mouse cursor:
|
|
18076
|
|
18077 @smallexample
|
|
18078 @group
|
|
18079 ; Cursor shapes are defined in
|
|
18080 ; `/usr/include/X11/cursorfont.h';
|
|
18081 ; for example, the `target' cursor is number 128;
|
|
18082 ; the `top_left_arrow' cursor is number 132.
|
|
18083 @end group
|
|
18084
|
|
18085 @group
|
|
18086 (let ((mpointer (x-get-resource "*mpointer"
|
|
18087 "*emacs*mpointer")))
|
|
18088 ;; If you have not set your mouse pointer
|
|
18089 ;; then set it, otherwise leave as is:
|
|
18090 (if (eq mpointer nil)
|
|
18091 (setq mpointer "132")) ; top_left_arrow
|
|
18092 @end group
|
|
18093 @group
|
|
18094 (setq x-pointer-shape (string-to-int mpointer))
|
|
18095 (set-mouse-color "white"))
|
|
18096 @end group
|
|
18097 @end smallexample
|
|
18098
|
|
18099 @item
|
|
18100 Or you can set the values of a variety of features in an alist, like
|
|
18101 this:
|
|
18102
|
|
18103 @smallexample
|
|
18104 @group
|
|
18105 (setq-default
|
|
18106 default-frame-alist
|
|
18107 '((cursor-color . "white")
|
|
18108 (mouse-color . "white")
|
|
18109 (foreground-color . "white")
|
|
18110 (background-color . "DodgerBlue4")
|
|
18111 ;; (cursor-type . bar)
|
|
18112 (cursor-type . box)
|
|
18113 @end group
|
|
18114 @group
|
|
18115 (tool-bar-lines . 0)
|
|
18116 (menu-bar-lines . 1)
|
|
18117 (width . 80)
|
|
18118 (height . 58)
|
|
18119 (font .
|
|
18120 "-Misc-Fixed-Medium-R-Normal--20-200-75-75-C-100-ISO8859-1")
|
|
18121 ))
|
|
18122 @end group
|
|
18123 @end smallexample
|
|
18124
|
|
18125 @item
|
|
18126 Convert @kbd{@key{CTRL}-h} into @key{DEL} and @key{DEL}
|
|
18127 into @kbd{@key{CTRL}-h}.@*
|
|
18128 (Some older keyboards needed this, although I have not seen the
|
|
18129 problem recently.)
|
|
18130
|
|
18131 @smallexample
|
|
18132 @group
|
|
18133 ;; Translate `C-h' to <DEL>.
|
|
18134 ; (keyboard-translate ?\C-h ?\C-?)
|
|
18135
|
|
18136 ;; Translate <DEL> to `C-h'.
|
|
18137 (keyboard-translate ?\C-? ?\C-h)
|
|
18138 @end group
|
|
18139 @end smallexample
|
|
18140
|
|
18141 @item Turn off a blinking cursor!
|
|
18142
|
|
18143 @smallexample
|
|
18144 @group
|
|
18145 (if (fboundp 'blink-cursor-mode)
|
|
18146 (blink-cursor-mode -1))
|
|
18147 @end group
|
|
18148 @end smallexample
|
|
18149
|
|
18150 @noindent
|
|
18151 or start GNU Emacs with the command @code{emacs -nbc}.
|
|
18152
|
|
18153 @need 1250
|
|
18154 @item When using `grep'@*
|
|
18155 @samp{-i}@w{ } Ignore case distinctions@*
|
|
18156 @samp{-n}@w{ } Prefix each line of output with line number@*
|
|
18157 @samp{-H}@w{ } Print the filename for each match.@*
|
|
18158 @samp{-e}@w{ } Protect patterns beginning with a hyphen character, @samp{-}
|
|
18159
|
|
18160 @smallexample
|
|
18161 (setq grep-command "grep -i -nH -e ")
|
|
18162 @end smallexample
|
|
18163
|
|
18164 @ignore
|
|
18165 @c Evidently, no longer needed in GNU Emacs 22
|
|
18166
|
|
18167 item Automatically uncompress compressed files when visiting them
|
|
18168
|
|
18169 smallexample
|
|
18170 (load "uncompress")
|
|
18171 end smallexample
|
|
18172
|
|
18173 @end ignore
|
|
18174
|
|
18175 @item Find an existing buffer, even if it has a different name@*
|
|
18176 This avoids problems with symbolic links.
|
|
18177
|
|
18178 @smallexample
|
|
18179 (setq find-file-existing-other-name t)
|
|
18180 @end smallexample
|
|
18181
|
|
18182 @item Set your language environment and default input method
|
|
18183
|
|
18184 @smallexample
|
|
18185 @group
|
|
18186 (set-language-environment "latin-1")
|
|
18187 ;; Remember you can enable or disable multilingual text input
|
|
18188 ;; with the @code{toggle-input-method'} (@kbd{C-\}) command
|
|
18189 (setq default-input-method "latin-1-prefix")
|
|
18190 @end group
|
|
18191 @end smallexample
|
|
18192
|
|
18193 If you want to write with Chinese `GB' characters, set this instead:
|
|
18194
|
|
18195 @smallexample
|
|
18196 @group
|
|
18197 (set-language-environment "Chinese-GB")
|
|
18198 (setq default-input-method "chinese-tonepy")
|
|
18199 @end group
|
|
18200 @end smallexample
|
|
18201 @end itemize
|
|
18202
|
|
18203 @subsubheading Fixing Unpleasant Key Bindings
|
|
18204 @cindex Key bindings, fixing
|
|
18205 @cindex Bindings, key, fixing unpleasant
|
|
18206
|
|
18207 Some systems bind keys unpleasantly. Sometimes, for example, the
|
|
18208 @key{CTRL} key appears in an awkward spot rather than at the far left
|
|
18209 of the home row.
|
|
18210
|
|
18211 Usually, when people fix these sorts of keybindings, they do not
|
|
18212 change their @file{~/.emacs} file. Instead, they bind the proper keys
|
|
18213 on their consoles with the @code{loadkeys} or @code{install-keymap}
|
|
18214 commands in their boot script and then include @code{xmodmap} commands
|
|
18215 in their @file{.xinitrc} or @file{.Xsession} file for X Windows.
|
|
18216
|
|
18217 @need 1250
|
|
18218 @noindent
|
|
18219 For a boot script:
|
|
18220
|
|
18221 @smallexample
|
|
18222 @group
|
|
18223 loadkeys /usr/share/keymaps/i386/qwerty/emacs2.kmap.gz
|
|
18224 @exdent or
|
|
18225 install-keymap emacs2
|
|
18226 @end group
|
|
18227 @end smallexample
|
|
18228
|
|
18229 @need 1250
|
|
18230 @noindent
|
|
18231 For a @file{.xinitrc} or @file{.Xsession} file when the @key{Caps
|
|
18232 Lock} key is at the far left of the home row:
|
|
18233
|
|
18234 @smallexample
|
|
18235 @group
|
|
18236 # Bind the key labeled `Caps Lock' to `Control'
|
|
18237 # (Such a broken user interface suggests that keyboard manufacturers
|
|
18238 # think that computers are typewriters from 1885.)
|
|
18239
|
|
18240 xmodmap -e "clear Lock"
|
|
18241 xmodmap -e "add Control = Caps_Lock"
|
|
18242 @end group
|
|
18243 @end smallexample
|
|
18244
|
|
18245 @need 1250
|
|
18246 @noindent
|
|
18247 In a @file{.xinitrc} or @file{.Xsession} file, to convert an @key{ALT}
|
|
18248 key to a @key{META} key:
|
|
18249
|
|
18250 @smallexample
|
|
18251 @group
|
|
18252 # Some ill designed keyboards have a key labeled ALT and no Meta
|
|
18253 xmodmap -e "keysym Alt_L = Meta_L Alt_L"
|
|
18254 @end group
|
|
18255 @end smallexample
|
|
18256
|
|
18257 @need 1700
|
|
18258 @node Mode Line, , Miscellaneous, Emacs Initialization
|
|
18259 @section A Modified Mode Line
|
|
18260 @vindex default-mode-line-format
|
|
18261 @cindex Mode line format
|
|
18262
|
|
18263 Finally, a feature I really like: a modified mode line.
|
|
18264
|
|
18265 When I work over a network, I forget which machine I am using. Also,
|
|
18266 I tend to I lose track of where I am, and which line point is on.
|
|
18267
|
|
18268 So I reset my mode line to look like this:
|
|
18269
|
|
18270 @smallexample
|
|
18271 -:-- foo.texi rattlesnake:/home/bob/ Line 1 (Texinfo Fill) Top
|
|
18272 @end smallexample
|
|
18273
|
|
18274 I am visiting a file called @file{foo.texi}, on my machine
|
|
18275 @file{rattlesnake} in my @file{/home/bob} buffer. I am on line 1, in
|
|
18276 Texinfo mode, and am at the top of the buffer.
|
|
18277
|
|
18278 @need 1200
|
|
18279 My @file{.emacs} file has a section that looks like this:
|
|
18280
|
|
18281 @smallexample
|
|
18282 @group
|
|
18283 ;; Set a Mode Line that tells me which machine, which directory,
|
|
18284 ;; and which line I am on, plus the other customary information.
|
|
18285 (setq default-mode-line-format
|
|
18286 (quote
|
|
18287 (#("-" 0 1
|
|
18288 (help-echo
|
|
18289 "mouse-1: select window, mouse-2: delete others ..."))
|
|
18290 mode-line-mule-info
|
|
18291 mode-line-modified
|
|
18292 mode-line-frame-identification
|
|
18293 " "
|
|
18294 @end group
|
|
18295 @group
|
|
18296 mode-line-buffer-identification
|
|
18297 " "
|
|
18298 (:eval (substring
|
|
18299 (system-name) 0 (string-match "\\..+" (system-name))))
|
|
18300 ":"
|
|
18301 default-directory
|
|
18302 #(" " 0 1
|
|
18303 (help-echo
|
|
18304 "mouse-1: select window, mouse-2: delete others ..."))
|
|
18305 (line-number-mode " Line %l ")
|
|
18306 global-mode-string
|
|
18307 @end group
|
|
18308 @group
|
|
18309 #(" %[(" 0 6
|
|
18310 (help-echo
|
|
18311 "mouse-1: select window, mouse-2: delete others ..."))
|
|
18312 (:eval (mode-line-mode-name))
|
|
18313 mode-line-process
|
|
18314 minor-mode-alist
|
|
18315 #("%n" 0 2 (help-echo "mouse-2: widen" local-map (keymap ...)))
|
|
18316 ")%] "
|
|
18317 (-3 . "%P")
|
|
18318 ;; "-%-"
|
|
18319 )))
|
|
18320 @end group
|
|
18321 @end smallexample
|
|
18322
|
|
18323 @noindent
|
|
18324 Here, I redefine the default mode line. Most of the parts are from
|
|
18325 the original; but I make a few changes. I set the @emph{default} mode
|
|
18326 line format so as to permit various modes, such as Info, to override
|
|
18327 it.
|
|
18328
|
|
18329 Many elements in the list are self-explanatory:
|
|
18330 @code{mode-line-modified} is a variable that tells whether the buffer
|
|
18331 has been modified, @code{mode-name} tells the name of the mode, and so
|
|
18332 on. However, the format looks complicated because of two features we
|
|
18333 have not discussed.
|
|
18334
|
|
18335 @cindex Properties, in mode line example
|
|
18336 The first string in the mode line is a dash or hyphen, @samp{-}. In
|
|
18337 the old days, it would have been specified simply as @code{"-"}. But
|
|
18338 nowadays, Emacs can add properties to a string, such as highlighting
|
|
18339 or, as in this case, a help feature. If you place your mouse cursor
|
|
18340 over the hyphen, some help information appears (By default, you must
|
|
18341 wait seven-tenths of a second before the information appears. You can
|
|
18342 change that timing by changing the value of @code{tooltip-delay}.)
|
|
18343
|
|
18344 @need 1000
|
|
18345 The new string format has a special syntax:
|
|
18346
|
|
18347 @smallexample
|
|
18348 #("-" 0 1 (help-echo "mouse-1: select window, ..."))
|
|
18349 @end smallexample
|
|
18350
|
|
18351 @noindent
|
|
18352 The @code{#(} begins a list. The first element of the list is the
|
|
18353 string itself, just one @samp{-}. The second and third
|
|
18354 elements specify the range over which the fourth element applies. A
|
|
18355 range starts @emph{after} a character, so a zero means the range
|
|
18356 starts just before the first character; a 1 means that the range ends
|
|
18357 just after the first character. The third element is the property for
|
|
18358 the range. It consists of a property list, a
|
|
18359 property name, in this case, @samp{help-echo}, followed by a value, in this
|
|
18360 case, a string. The second, third, and fourth elements of this new
|
|
18361 string format can be repeated.
|
|
18362
|
|
18363 @xref{Text Properties, , Text Properties, elisp, The GNU Emacs Lisp
|
|
18364 Reference Manual}, and see @ref{Mode Line Format, , Mode Line Format,
|
|
18365 elisp, The GNU Emacs Lisp Reference Manual}, for more information.
|
|
18366
|
|
18367 @code{mode-line-buffer-identification}
|
|
18368 displays the current buffer name. It is a list
|
|
18369 beginning @code{(#("%12b" 0 4 @dots{}}.
|
|
18370 The @code{#(} begins the list.
|
|
18371
|
|
18372 The @samp{"%12b"} displays the current buffer name, using the
|
|
18373 @code{buffer-name} function with which we are familiar; the `12'
|
|
18374 specifies the maximum number of characters that will be displayed.
|
|
18375 When a name has fewer characters, whitespace is added to fill out to
|
|
18376 this number. (Buffer names can and often should be longer than 12
|
|
18377 characters; this length works well in a typical 80 column wide
|
|
18378 window.)
|
|
18379
|
|
18380 @code{:eval} says to evaluate the following form and use the result as
|
|
18381 a string to display. In this case, the expression displays the first
|
|
18382 component of the full system name. The end of the first component is
|
|
18383 a @samp{.} (`period'), so I use the @code{string-match} function to
|
|
18384 tell me the length of the first component. The substring from the
|
|
18385 zeroth character to that length is the name of the machine.
|
|
18386
|
|
18387 @need 1250
|
|
18388 This is the expression:
|
|
18389
|
|
18390 @smallexample
|
|
18391 @group
|
|
18392 (:eval (substring
|
|
18393 (system-name) 0 (string-match "\\..+" (system-name))))
|
|
18394 @end group
|
|
18395 @end smallexample
|
|
18396
|
|
18397 @samp{%[} and @samp{%]} cause a pair of square brackets
|
|
18398 to appear for each recursive editing level. @samp{%n} says `Narrow'
|
|
18399 when narrowing is in effect. @samp{%P} tells you the percentage of
|
|
18400 the buffer that is above the bottom of the window, or `Top', `Bottom',
|
|
18401 or `All'. (A lower case @samp{p} tell you the percentage above the
|
|
18402 @emph{top} of the window.) @samp{%-} inserts enough dashes to fill
|
|
18403 out the line.
|
|
18404
|
|
18405 Remember, ``You don't have to like Emacs to like it'' --- your own
|
|
18406 Emacs can have different colors, different commands, and different
|
|
18407 keys than a default Emacs.
|
|
18408
|
|
18409 On the other hand, if you want to bring up a plain `out of the box'
|
|
18410 Emacs, with no customization, type:
|
|
18411
|
|
18412 @smallexample
|
|
18413 emacs -q
|
|
18414 @end smallexample
|
|
18415
|
|
18416 @noindent
|
|
18417 This will start an Emacs that does @emph{not} load your
|
|
18418 @file{~/.emacs} initialization file. A plain, default Emacs. Nothing
|
|
18419 more.
|
|
18420
|
|
18421 @node Debugging, Conclusion, Emacs Initialization, Top
|
|
18422 @chapter Debugging
|
|
18423 @cindex debugging
|
|
18424
|
|
18425 GNU Emacs has two debuggers, @code{debug} and @code{edebug}. The
|
|
18426 first is built into the internals of Emacs and is always with you;
|
|
18427 the second requires that you instrument a function before you can use it.
|
|
18428
|
|
18429 Both debuggers are described extensively in @ref{Debugging, ,
|
|
18430 Debugging Lisp Programs, elisp, The GNU Emacs Lisp Reference Manual}.
|
|
18431 In this chapter, I will walk through a short example of each.
|
|
18432
|
|
18433 @menu
|
|
18434 * debug:: How to use the built-in debugger.
|
|
18435 * debug-on-entry:: Start debugging when you call a function.
|
|
18436 * debug-on-quit:: Start debugging when you quit with @kbd{C-g}.
|
|
18437 * edebug:: How to use Edebug, a source level debugger.
|
|
18438 * Debugging Exercises::
|
|
18439 @end menu
|
|
18440
|
|
18441 @node debug, debug-on-entry, Debugging, Debugging
|
|
18442 @section @code{debug}
|
|
18443 @findex debug
|
|
18444
|
|
18445 Suppose you have written a function definition that is intended to
|
|
18446 return the sum of the numbers 1 through a given number. (This is the
|
|
18447 @code{triangle} function discussed earlier. @xref{Decrementing
|
|
18448 Example, , Example with Decrementing Counter}, for a discussion.)
|
|
18449 @c xref{Decrementing Loop,, Loop with a Decrementing Counter}, for a discussion.)
|
|
18450
|
|
18451 However, your function definition has a bug. You have mistyped
|
|
18452 @samp{1=} for @samp{1-}. Here is the broken definition:
|
|
18453
|
|
18454 @findex triangle-bugged
|
|
18455 @smallexample
|
|
18456 @group
|
|
18457 (defun triangle-bugged (number)
|
|
18458 "Return sum of numbers 1 through NUMBER inclusive."
|
|
18459 (let ((total 0))
|
|
18460 (while (> number 0)
|
|
18461 (setq total (+ total number))
|
|
18462 (setq number (1= number))) ; @r{Error here.}
|
|
18463 total))
|
|
18464 @end group
|
|
18465 @end smallexample
|
|
18466
|
|
18467 If you are reading this in Info, you can evaluate this definition in
|
|
18468 the normal fashion. You will see @code{triangle-bugged} appear in the
|
|
18469 echo area.
|
|
18470
|
|
18471 @need 1250
|
|
18472 Now evaluate the @code{triangle-bugged} function with an
|
|
18473 argument of 4:
|
|
18474
|
|
18475 @smallexample
|
|
18476 (triangle-bugged 4)
|
|
18477 @end smallexample
|
|
18478
|
|
18479 @noindent
|
|
18480 In a recent GNU Emacs, you will create and enter a @file{*Backtrace*}
|
|
18481 buffer that says:
|
|
18482
|
|
18483 @noindent
|
|
18484 @smallexample
|
|
18485 @group
|
|
18486 ---------- Buffer: *Backtrace* ----------
|
|
18487 Debugger entered--Lisp error: (void-function 1=)
|
|
18488 (1= number)
|
|
18489 (setq number (1= number))
|
|
18490 (while (> number 0) (setq total (+ total number))
|
|
18491 (setq number (1= number)))
|
|
18492 (let ((total 0)) (while (> number 0) (setq total ...)
|
|
18493 (setq number ...)) total)
|
|
18494 triangle-bugged(4)
|
|
18495 @end group
|
|
18496 @group
|
|
18497 eval((triangle-bugged 4))
|
|
18498 eval-last-sexp-1(nil)
|
|
18499 eval-last-sexp(nil)
|
|
18500 call-interactively(eval-last-sexp)
|
|
18501 ---------- Buffer: *Backtrace* ----------
|
|
18502 @end group
|
|
18503 @end smallexample
|
|
18504
|
|
18505 @noindent
|
|
18506 (I have reformatted this example slightly; the debugger does not fold
|
|
18507 long lines. As usual, you can quit the debugger by typing @kbd{q} in
|
|
18508 the @file{*Backtrace*} buffer.)
|
|
18509
|
|
18510 In practice, for a bug as simple as this, the `Lisp error' line will
|
|
18511 tell you what you need to know to correct the definition. The
|
|
18512 function @code{1=} is `void'.
|
|
18513
|
|
18514 @ignore
|
|
18515 @need 800
|
|
18516 In GNU Emacs 20 and before, you will see:
|
|
18517
|
|
18518 @smallexample
|
|
18519 Symbol's function definition is void:@: 1=
|
|
18520 @end smallexample
|
|
18521
|
|
18522 @noindent
|
|
18523 which has the same meaning as the @file{*Backtrace*} buffer line in
|
|
18524 version 21.
|
|
18525 @end ignore
|
|
18526
|
|
18527 However, suppose you are not quite certain what is going on?
|
|
18528 You can read the complete backtrace.
|
|
18529
|
|
18530 In this case, you need to run a recent GNU Emacs, which automatically
|
|
18531 starts the debugger that puts you in the @file{*Backtrace*} buffer; or
|
|
18532 else, you need to start the debugger manually as described below.
|
|
18533
|
|
18534 Read the @file{*Backtrace*} buffer from the bottom up; it tells you
|
|
18535 what Emacs did that led to the error. Emacs made an interactive call
|
|
18536 to @kbd{C-x C-e} (@code{eval-last-sexp}), which led to the evaluation
|
|
18537 of the @code{triangle-bugged} expression. Each line above tells you
|
|
18538 what the Lisp interpreter evaluated next.
|
|
18539
|
|
18540 @need 1250
|
|
18541 The third line from the top of the buffer is
|
|
18542
|
|
18543 @smallexample
|
|
18544 (setq number (1= number))
|
|
18545 @end smallexample
|
|
18546
|
|
18547 @noindent
|
|
18548 Emacs tried to evaluate this expression; in order to do so, it tried
|
|
18549 to evaluate the inner expression shown on the second line from the
|
|
18550 top:
|
|
18551
|
|
18552 @smallexample
|
|
18553 (1= number)
|
|
18554 @end smallexample
|
|
18555
|
|
18556 @need 1250
|
|
18557 @noindent
|
|
18558 This is where the error occurred; as the top line says:
|
|
18559
|
|
18560 @smallexample
|
|
18561 Debugger entered--Lisp error: (void-function 1=)
|
|
18562 @end smallexample
|
|
18563
|
|
18564 @noindent
|
|
18565 You can correct the mistake, re-evaluate the function definition, and
|
|
18566 then run your test again.
|
|
18567
|
|
18568 @node debug-on-entry, debug-on-quit, debug, Debugging
|
|
18569 @section @code{debug-on-entry}
|
|
18570 @findex debug-on-entry
|
|
18571
|
|
18572 A recent GNU Emacs starts the debugger automatically when your
|
|
18573 function has an error.
|
|
18574
|
|
18575 @ignore
|
|
18576 GNU Emacs version 20 and before did not; it simply
|
|
18577 presented you with an error message. You had to start the debugger
|
|
18578 manually.
|
|
18579 @end ignore
|
|
18580
|
|
18581 Incidentally, you can start the debugger manually for all versions of
|
|
18582 Emacs; the advantage is that the debugger runs even if you do not have
|
|
18583 a bug in your code. Sometimes your code will be free of bugs!
|
|
18584
|
|
18585 You can enter the debugger when you call the function by calling
|
|
18586 @code{debug-on-entry}.
|
|
18587
|
|
18588 @need 1250
|
|
18589 @noindent
|
|
18590 Type:
|
|
18591
|
|
18592 @smallexample
|
|
18593 M-x debug-on-entry RET triangle-bugged RET
|
|
18594 @end smallexample
|
|
18595
|
|
18596 @need 1250
|
|
18597 @noindent
|
|
18598 Now, evaluate the following:
|
|
18599
|
|
18600 @smallexample
|
|
18601 (triangle-bugged 5)
|
|
18602 @end smallexample
|
|
18603
|
|
18604 @noindent
|
|
18605 All versions of Emacs will create a @file{*Backtrace*} buffer and tell
|
|
18606 you that it is beginning to evaluate the @code{triangle-bugged}
|
|
18607 function:
|
|
18608
|
|
18609 @smallexample
|
|
18610 @group
|
|
18611 ---------- Buffer: *Backtrace* ----------
|
|
18612 Debugger entered--entering a function:
|
|
18613 * triangle-bugged(5)
|
|
18614 eval((triangle-bugged 5))
|
|
18615 @end group
|
|
18616 @group
|
|
18617 eval-last-sexp-1(nil)
|
|
18618 eval-last-sexp(nil)
|
|
18619 call-interactively(eval-last-sexp)
|
|
18620 ---------- Buffer: *Backtrace* ----------
|
|
18621 @end group
|
|
18622 @end smallexample
|
|
18623
|
|
18624 In the @file{*Backtrace*} buffer, type @kbd{d}. Emacs will evaluate
|
|
18625 the first expression in @code{triangle-bugged}; the buffer will look
|
|
18626 like this:
|
|
18627
|
|
18628 @smallexample
|
|
18629 @group
|
|
18630 ---------- Buffer: *Backtrace* ----------
|
|
18631 Debugger entered--beginning evaluation of function call form:
|
|
18632 * (let ((total 0)) (while (> number 0) (setq total ...)
|
|
18633 (setq number ...)) total)
|
|
18634 * triangle-bugged(5)
|
|
18635 eval((triangle-bugged 5))
|
|
18636 @end group
|
|
18637 @group
|
|
18638 eval-last-sexp-1(nil)
|
|
18639 eval-last-sexp(nil)
|
|
18640 call-interactively(eval-last-sexp)
|
|
18641 ---------- Buffer: *Backtrace* ----------
|
|
18642 @end group
|
|
18643 @end smallexample
|
|
18644
|
|
18645 @noindent
|
|
18646 Now, type @kbd{d} again, eight times, slowly. Each time you type
|
|
18647 @kbd{d}, Emacs will evaluate another expression in the function
|
|
18648 definition.
|
|
18649
|
|
18650 @need 1750
|
|
18651 Eventually, the buffer will look like this:
|
|
18652
|
|
18653 @smallexample
|
|
18654 @group
|
|
18655 ---------- Buffer: *Backtrace* ----------
|
|
18656 Debugger entered--beginning evaluation of function call form:
|
|
18657 * (setq number (1= number))
|
|
18658 * (while (> number 0) (setq total (+ total number))
|
|
18659 (setq number (1= number)))
|
|
18660 @group
|
|
18661 @end group
|
|
18662 * (let ((total 0)) (while (> number 0) (setq total ...)
|
|
18663 (setq number ...)) total)
|
|
18664 * triangle-bugged(5)
|
|
18665 eval((triangle-bugged 5))
|
|
18666 @group
|
|
18667 @end group
|
|
18668 eval-last-sexp-1(nil)
|
|
18669 eval-last-sexp(nil)
|
|
18670 call-interactively(eval-last-sexp)
|
|
18671 ---------- Buffer: *Backtrace* ----------
|
|
18672 @end group
|
|
18673 @end smallexample
|
|
18674
|
|
18675 @need 1500
|
|
18676 @noindent
|
|
18677 Finally, after you type @kbd{d} two more times, Emacs will reach the
|
|
18678 error, and the top two lines of the @file{*Backtrace*} buffer will look
|
|
18679 like this:
|
|
18680
|
|
18681 @smallexample
|
|
18682 @group
|
|
18683 ---------- Buffer: *Backtrace* ----------
|
|
18684 Debugger entered--Lisp error: (void-function 1=)
|
|
18685 * (1= number)
|
|
18686 @dots{}
|
|
18687 ---------- Buffer: *Backtrace* ----------
|
|
18688 @end group
|
|
18689 @end smallexample
|
|
18690
|
|
18691 By typing @kbd{d}, you were able to step through the function.
|
|
18692
|
|
18693 You can quit a @file{*Backtrace*} buffer by typing @kbd{q} in it; this
|
|
18694 quits the trace, but does not cancel @code{debug-on-entry}.
|
|
18695
|
|
18696 @findex cancel-debug-on-entry
|
|
18697 To cancel the effect of @code{debug-on-entry}, call
|
|
18698 @code{cancel-debug-on-entry} and the name of the function, like this:
|
|
18699
|
|
18700 @smallexample
|
|
18701 M-x cancel-debug-on-entry RET triangle-bugged RET
|
|
18702 @end smallexample
|
|
18703
|
|
18704 @noindent
|
|
18705 (If you are reading this in Info, cancel @code{debug-on-entry} now.)
|
|
18706
|
|
18707 @node debug-on-quit, edebug, debug-on-entry, Debugging
|
|
18708 @section @code{debug-on-quit} and @code{(debug)}
|
|
18709
|
|
18710 In addition to setting @code{debug-on-error} or calling @code{debug-on-entry},
|
|
18711 there are two other ways to start @code{debug}.
|
|
18712
|
|
18713 @findex debug-on-quit
|
|
18714 You can start @code{debug} whenever you type @kbd{C-g}
|
|
18715 (@code{keyboard-quit}) by setting the variable @code{debug-on-quit} to
|
|
18716 @code{t}. This is useful for debugging infinite loops.
|
|
18717
|
|
18718 @need 1500
|
|
18719 @cindex @code{(debug)} in code
|
|
18720 Or, you can insert a line that says @code{(debug)} into your code
|
|
18721 where you want the debugger to start, like this:
|
|
18722
|
|
18723 @smallexample
|
|
18724 @group
|
|
18725 (defun triangle-bugged (number)
|
|
18726 "Return sum of numbers 1 through NUMBER inclusive."
|
|
18727 (let ((total 0))
|
|
18728 (while (> number 0)
|
|
18729 (setq total (+ total number))
|
|
18730 (debug) ; @r{Start debugger.}
|
|
18731 (setq number (1= number))) ; @r{Error here.}
|
|
18732 total))
|
|
18733 @end group
|
|
18734 @end smallexample
|
|
18735
|
|
18736 The @code{debug} function is described in detail in @ref{Debugger, ,
|
|
18737 The Lisp Debugger, elisp, The GNU Emacs Lisp Reference Manual}.
|
|
18738
|
|
18739 @node edebug, Debugging Exercises, debug-on-quit, Debugging
|
|
18740 @section The @code{edebug} Source Level Debugger
|
|
18741 @cindex Source level debugger
|
|
18742 @findex edebug
|
|
18743
|
|
18744 Edebug is a source level debugger. Edebug normally displays the
|
|
18745 source of the code you are debugging, with an arrow at the left that
|
|
18746 shows which line you are currently executing.
|
|
18747
|
|
18748 You can walk through the execution of a function, line by line, or run
|
|
18749 quickly until reaching a @dfn{breakpoint} where execution stops.
|
|
18750
|
|
18751 Edebug is described in @ref{edebug, , Edebug, elisp, The GNU Emacs
|
|
18752 Lisp Reference Manual}.
|
|
18753
|
|
18754 @need 1250
|
|
18755 Here is a bugged function definition for @code{triangle-recursively}.
|
|
18756 @xref{Recursive triangle function, , Recursion in place of a counter},
|
|
18757 for a review of it.
|
|
18758
|
|
18759 @smallexample
|
|
18760 @group
|
|
18761 (defun triangle-recursively-bugged (number)
|
|
18762 "Return sum of numbers 1 through NUMBER inclusive.
|
|
18763 Uses recursion."
|
|
18764 (if (= number 1)
|
|
18765 1
|
|
18766 (+ number
|
|
18767 (triangle-recursively-bugged
|
|
18768 (1= number))))) ; @r{Error here.}
|
|
18769 @end group
|
|
18770 @end smallexample
|
|
18771
|
|
18772 @noindent
|
|
18773 Normally, you would install this definition by positioning your cursor
|
|
18774 after the function's closing parenthesis and typing @kbd{C-x C-e}
|
|
18775 (@code{eval-last-sexp}) or else by positioning your cursor within the
|
|
18776 definition and typing @kbd{C-M-x} (@code{eval-defun}). (By default,
|
|
18777 the @code{eval-defun} command works only in Emacs Lisp mode or in Lisp
|
103421
|
18778 Interaction mode.)
|
83955
|
18779
|
|
18780 @need 1500
|
|
18781 However, to prepare this function definition for Edebug, you must
|
|
18782 first @dfn{instrument} the code using a different command. You can do
|
|
18783 this by positioning your cursor within or just after the definition
|
|
18784 and typing
|
|
18785
|
|
18786 @smallexample
|
|
18787 M-x edebug-defun RET
|
|
18788 @end smallexample
|
|
18789
|
|
18790 @noindent
|
|
18791 This will cause Emacs to load Edebug automatically if it is not
|
|
18792 already loaded, and properly instrument the function.
|
|
18793
|
|
18794 After instrumenting the function, place your cursor after the
|
|
18795 following expression and type @kbd{C-x C-e} (@code{eval-last-sexp}):
|
|
18796
|
|
18797 @smallexample
|
|
18798 (triangle-recursively-bugged 3)
|
|
18799 @end smallexample
|
|
18800
|
|
18801 @noindent
|
|
18802 You will be jumped back to the source for
|
|
18803 @code{triangle-recursively-bugged} and the cursor positioned at the
|
|
18804 beginning of the @code{if} line of the function. Also, you will see
|
|
18805 an arrowhead at the left hand side of that line. The arrowhead marks
|
|
18806 the line where the function is executing. (In the following examples,
|
|
18807 we show the arrowhead with @samp{=>}; in a windowing system, you may
|
|
18808 see the arrowhead as a solid triangle in the window `fringe'.)
|
|
18809
|
|
18810 @smallexample
|
|
18811 =>@point{}(if (= number 1)
|
|
18812 @end smallexample
|
|
18813
|
|
18814 @noindent
|
|
18815 @iftex
|
|
18816 In the example, the location of point is displayed with a star,
|
|
18817 @samp{@point{}} (in Info, it is displayed as @samp{-!-}).
|
|
18818 @end iftex
|
|
18819 @ifnottex
|
|
18820 In the example, the location of point is displayed as @samp{@point{}}
|
|
18821 (in a printed book, it is displayed with a five pointed star).
|
|
18822 @end ifnottex
|
|
18823
|
|
18824 If you now press @key{SPC}, point will move to the next expression to
|
|
18825 be executed; the line will look like this:
|
|
18826
|
|
18827 @smallexample
|
|
18828 =>(if @point{}(= number 1)
|
|
18829 @end smallexample
|
|
18830
|
|
18831 @noindent
|
|
18832 As you continue to press @key{SPC}, point will move from expression to
|
|
18833 expression. At the same time, whenever an expression returns a value,
|
|
18834 that value will be displayed in the echo area. For example, after you
|
|
18835 move point past @code{number}, you will see the following:
|
|
18836
|
|
18837 @smallexample
|
|
18838 Result: 3 (#o3, #x3, ?\C-c)
|
|
18839 @end smallexample
|
|
18840
|
|
18841 @noindent
|
|
18842 This means the value of @code{number} is 3, which is octal three,
|
|
18843 hexadecimal three, and @sc{ascii} `control-c' (the third letter of the
|
|
18844 alphabet, in case you need to know this information).
|
|
18845
|
|
18846 You can continue moving through the code until you reach the line with
|
|
18847 the error. Before evaluation, that line looks like this:
|
|
18848
|
|
18849 @smallexample
|
|
18850 => @point{}(1= number))))) ; @r{Error here.}
|
|
18851 @end smallexample
|
|
18852
|
|
18853 @need 1250
|
|
18854 @noindent
|
|
18855 When you press @key{SPC} once again, you will produce an error message
|
|
18856 that says:
|
|
18857
|
|
18858 @smallexample
|
|
18859 Symbol's function definition is void:@: 1=
|
|
18860 @end smallexample
|
|
18861
|
|
18862 @noindent
|
|
18863 This is the bug.
|
|
18864
|
|
18865 Press @kbd{q} to quit Edebug.
|
|
18866
|
|
18867 To remove instrumentation from a function definition, simply
|
|
18868 re-evaluate it with a command that does not instrument it.
|
|
18869 For example, you could place your cursor after the definition's
|
|
18870 closing parenthesis and type @kbd{C-x C-e}.
|
|
18871
|
|
18872 Edebug does a great deal more than walk with you through a function.
|
|
18873 You can set it so it races through on its own, stopping only at an
|
|
18874 error or at specified stopping points; you can cause it to display the
|
|
18875 changing values of various expressions; you can find out how many
|
|
18876 times a function is called, and more.
|
|
18877
|
|
18878 Edebug is described in @ref{edebug, , Edebug, elisp, The GNU Emacs
|
|
18879 Lisp Reference Manual}.
|
|
18880
|
|
18881 @need 1500
|
|
18882 @node Debugging Exercises, , edebug, Debugging
|
|
18883 @section Debugging Exercises
|
|
18884
|
|
18885 @itemize @bullet
|
|
18886 @item
|
|
18887 Install the @code{count-words-region} function and then cause it to
|
|
18888 enter the built-in debugger when you call it. Run the command on a
|
|
18889 region containing two words. You will need to press @kbd{d} a
|
|
18890 remarkable number of times. On your system, is a `hook' called after
|
|
18891 the command finishes? (For information on hooks, see @ref{Command
|
|
18892 Overview, , Command Loop Overview, elisp, The GNU Emacs Lisp Reference
|
|
18893 Manual}.)
|
|
18894
|
|
18895 @item
|
|
18896 Copy @code{count-words-region} into the @file{*scratch*} buffer,
|
|
18897 instrument the function for Edebug, and walk through its execution.
|
|
18898 The function does not need to have a bug, although you can introduce
|
|
18899 one if you wish. If the function lacks a bug, the walk-through
|
|
18900 completes without problems.
|
|
18901
|
|
18902 @item
|
|
18903 While running Edebug, type @kbd{?} to see a list of all the Edebug commands.
|
|
18904 (The @code{global-edebug-prefix} is usually @kbd{C-x X}, i.e.@:
|
|
18905 @kbd{@key{CTRL}-x} followed by an upper case @kbd{X}; use this prefix
|
|
18906 for commands made outside of the Edebug debugging buffer.)
|
|
18907
|
|
18908 @item
|
|
18909 In the Edebug debugging buffer, use the @kbd{p}
|
|
18910 (@code{edebug-bounce-point}) command to see where in the region the
|
|
18911 @code{count-words-region} is working.
|
|
18912
|
|
18913 @item
|
|
18914 Move point to some spot further down the function and then type the
|
|
18915 @kbd{h} (@code{edebug-goto-here}) command to jump to that location.
|
|
18916
|
|
18917 @item
|
|
18918 Use the @kbd{t} (@code{edebug-trace-mode}) command to cause Edebug to
|
|
18919 walk through the function on its own; use an upper case @kbd{T} for
|
|
18920 @code{edebug-Trace-fast-mode}.
|
|
18921
|
|
18922 @item
|
|
18923 Set a breakpoint, then run Edebug in Trace mode until it reaches the
|
|
18924 stopping point.
|
|
18925 @end itemize
|
|
18926
|
|
18927 @node Conclusion, the-the, Debugging, Top
|
|
18928 @chapter Conclusion
|
|
18929
|
|
18930 We have now reached the end of this Introduction. You have now
|
|
18931 learned enough about programming in Emacs Lisp to set values, to write
|
|
18932 simple @file{.emacs} files for yourself and your friends, and write
|
|
18933 simple customizations and extensions to Emacs.
|
|
18934
|
|
18935 This is a place to stop. Or, if you wish, you can now go onward, and
|
|
18936 teach yourself.
|
|
18937
|
|
18938 You have learned some of the basic nuts and bolts of programming. But
|
|
18939 only some. There are a great many more brackets and hinges that are
|
|
18940 easy to use that we have not touched.
|
|
18941
|
|
18942 A path you can follow right now lies among the sources to GNU Emacs
|
|
18943 and in
|
|
18944 @ifnotinfo
|
|
18945 @cite{The GNU Emacs Lisp Reference Manual}.
|
|
18946 @end ifnotinfo
|
|
18947 @ifinfo
|
|
18948 @ref{Top, , The GNU Emacs Lisp Reference Manual, elisp, The GNU
|
|
18949 Emacs Lisp Reference Manual}.
|
|
18950 @end ifinfo
|
|
18951
|
|
18952 The Emacs Lisp sources are an adventure. When you read the sources and
|
|
18953 come across a function or expression that is unfamiliar, you need to
|
|
18954 figure out or find out what it does.
|
|
18955
|
|
18956 Go to the Reference Manual. It is a thorough, complete, and fairly
|
|
18957 easy-to-read description of Emacs Lisp. It is written not only for
|
|
18958 experts, but for people who know what you know. (The @cite{Reference
|
|
18959 Manual} comes with the standard GNU Emacs distribution. Like this
|
|
18960 introduction, it comes as a Texinfo source file, so you can read it
|
|
18961 on-line and as a typeset, printed book.)
|
|
18962
|
|
18963 Go to the other on-line help that is part of GNU Emacs: the on-line
|
|
18964 documentation for all functions and variables, and @code{find-tags},
|
|
18965 the program that takes you to sources.
|
|
18966
|
|
18967 Here is an example of how I explore the sources. Because of its name,
|
|
18968 @file{simple.el} is the file I looked at first, a long time ago. As
|
|
18969 it happens some of the functions in @file{simple.el} are complicated,
|
|
18970 or at least look complicated at first sight. The @code{open-line}
|
|
18971 function, for example, looks complicated.
|
|
18972
|
|
18973 You may want to walk through this function slowly, as we did with the
|
|
18974 @code{forward-sentence} function. (@xref{forward-sentence, The
|
|
18975 @code{forward-sentence} function}.) Or you may want to skip that
|
|
18976 function and look at another, such as @code{split-line}. You don't
|
|
18977 need to read all the functions. According to
|
|
18978 @code{count-words-in-defun}, the @code{split-line} function contains
|
|
18979 102 words and symbols.
|
|
18980
|
|
18981 Even though it is short, @code{split-line} contains expressions
|
|
18982 we have not studied: @code{skip-chars-forward}, @code{indent-to},
|
|
18983 @code{current-column} and @code{insert-and-inherit}.
|
|
18984
|
|
18985 Consider the @code{skip-chars-forward} function. (It is part of the
|
|
18986 function definition for @code{back-to-indentation}, which is shown in
|
|
18987 @ref{Review, , Review}.)
|
|
18988
|
|
18989 In GNU Emacs, you can find out more about @code{skip-chars-forward} by
|
|
18990 typing @kbd{C-h f} (@code{describe-function}) and the name of the
|
|
18991 function. This gives you the function documentation.
|
|
18992
|
|
18993 You may be able to guess what is done by a well named function such as
|
|
18994 @code{indent-to}; or you can look it up, too. Incidentally, the
|
|
18995 @code{describe-function} function itself is in @file{help.el}; it is
|
|
18996 one of those long, but decipherable functions. You can look up
|
|
18997 @code{describe-function} using the @kbd{C-h f} command!
|
|
18998
|
|
18999 In this instance, since the code is Lisp, the @file{*Help*} buffer
|
|
19000 contains the name of the library containing the function's source.
|
|
19001 You can put point over the name of the library and press the RET key,
|
|
19002 which in this situation is bound to @code{help-follow}, and be taken
|
|
19003 directly to the source, in the same way as @kbd{M-.}
|
|
19004 (@code{find-tag}).
|
|
19005
|
|
19006 The definition for @code{describe-function} illustrates how to
|
|
19007 customize the @code{interactive} expression without using the standard
|
|
19008 character codes; and it shows how to create a temporary buffer.
|
|
19009
|
|
19010 (The @code{indent-to} function is written in C rather than Emacs Lisp;
|
|
19011 it is a `built-in' function. @code{help-follow} takes you to its
|
|
19012 source as does @code{find-tag}, when properly set up.)
|
|
19013
|
|
19014 You can look at a function's source using @code{find-tag}, which is
|
|
19015 bound to @kbd{M-.} Finally, you can find out what the Reference
|
|
19016 Manual has to say by visiting the manual in Info, and typing @kbd{i}
|
|
19017 (@code{Info-index}) and the name of the function, or by looking up the
|
|
19018 function in the index to a printed copy of the manual.
|
|
19019
|
|
19020 Similarly, you can find out what is meant by
|
|
19021 @code{insert-and-inherit}.
|
|
19022
|
|
19023 Other interesting source files include @file{paragraphs.el},
|
|
19024 @file{loaddefs.el}, and @file{loadup.el}. The @file{paragraphs.el}
|
|
19025 file includes short, easily understood functions as well as longer
|
|
19026 ones. The @file{loaddefs.el} file contains the many standard
|
|
19027 autoloads and many keymaps. I have never looked at it all; only at
|
|
19028 parts. @file{loadup.el} is the file that loads the standard parts of
|
|
19029 Emacs; it tells you a great deal about how Emacs is built.
|
|
19030 (@xref{Building Emacs, , Building Emacs, elisp, The GNU Emacs Lisp
|
|
19031 Reference Manual}, for more about building.)
|
|
19032
|
|
19033 As I said, you have learned some nuts and bolts; however, and very
|
|
19034 importantly, we have hardly touched major aspects of programming; I
|
|
19035 have said nothing about how to sort information, except to use the
|
|
19036 predefined @code{sort} function; I have said nothing about how to store
|
|
19037 information, except to use variables and lists; I have said nothing
|
|
19038 about how to write programs that write programs. These are topics for
|
|
19039 another, and different kind of book, a different kind of learning.
|
|
19040
|
|
19041 What you have done is learn enough for much practical work with GNU
|
|
19042 Emacs. What you have done is get started. This is the end of a
|
|
19043 beginning.
|
|
19044
|
|
19045 @c ================ Appendix ================
|
|
19046
|
|
19047 @node the-the, Kill Ring, Conclusion, Top
|
|
19048 @appendix The @code{the-the} Function
|
|
19049 @findex the-the
|
|
19050 @cindex Duplicated words function
|
|
19051 @cindex Words, duplicated
|
|
19052
|
|
19053 Sometimes when you you write text, you duplicate words---as with ``you
|
|
19054 you'' near the beginning of this sentence. I find that most
|
|
19055 frequently, I duplicate ``the''; hence, I call the function for
|
|
19056 detecting duplicated words, @code{the-the}.
|
|
19057
|
|
19058 @need 1250
|
|
19059 As a first step, you could use the following regular expression to
|
|
19060 search for duplicates:
|
|
19061
|
|
19062 @smallexample
|
|
19063 \\(\\w+[ \t\n]+\\)\\1
|
|
19064 @end smallexample
|
|
19065
|
|
19066 @noindent
|
|
19067 This regexp matches one or more word-constituent characters followed
|
|
19068 by one or more spaces, tabs, or newlines. However, it does not detect
|
|
19069 duplicated words on different lines, since the ending of the first
|
|
19070 word, the end of the line, is different from the ending of the second
|
|
19071 word, a space. (For more information about regular expressions, see
|
|
19072 @ref{Regexp Search, , Regular Expression Searches}, as well as
|
|
19073 @ref{Regexps, , Syntax of Regular Expressions, emacs, The GNU Emacs
|
|
19074 Manual}, and @ref{Regular Expressions, , Regular Expressions, elisp,
|
|
19075 The GNU Emacs Lisp Reference Manual}.)
|
|
19076
|
|
19077 You might try searching just for duplicated word-constituent
|
|
19078 characters but that does not work since the pattern detects doubles
|
|
19079 such as the two occurrences of `th' in `with the'.
|
|
19080
|
|
19081 Another possible regexp searches for word-constituent characters
|
|
19082 followed by non-word-constituent characters, reduplicated. Here,
|
|
19083 @w{@samp{\\w+}} matches one or more word-constituent characters and
|
|
19084 @w{@samp{\\W*}} matches zero or more non-word-constituent characters.
|
|
19085
|
|
19086 @smallexample
|
|
19087 \\(\\(\\w+\\)\\W*\\)\\1
|
|
19088 @end smallexample
|
|
19089
|
|
19090 @noindent
|
|
19091 Again, not useful.
|
|
19092
|
|
19093 Here is the pattern that I use. It is not perfect, but good enough.
|
|
19094 @w{@samp{\\b}} matches the empty string, provided it is at the beginning
|
|
19095 or end of a word; @w{@samp{[^@@ \n\t]+}} matches one or more occurrences of
|
|
19096 any characters that are @emph{not} an @@-sign, space, newline, or tab.
|
|
19097
|
|
19098 @smallexample
|
|
19099 \\b\\([^@@ \n\t]+\\)[ \n\t]+\\1\\b
|
|
19100 @end smallexample
|
|
19101
|
|
19102 One can write more complicated expressions, but I found that this
|
|
19103 expression is good enough, so I use it.
|
|
19104
|
|
19105 Here is the @code{the-the} function, as I include it in my
|
|
19106 @file{.emacs} file, along with a handy global key binding:
|
|
19107
|
|
19108 @smallexample
|
|
19109 @group
|
|
19110 (defun the-the ()
|
|
19111 "Search forward for for a duplicated word."
|
|
19112 (interactive)
|
|
19113 (message "Searching for for duplicated words ...")
|
|
19114 (push-mark)
|
|
19115 @end group
|
|
19116 @group
|
|
19117 ;; This regexp is not perfect
|
|
19118 ;; but is fairly good over all:
|
|
19119 (if (re-search-forward
|
|
19120 "\\b\\([^@@ \n\t]+\\)[ \n\t]+\\1\\b" nil 'move)
|
|
19121 (message "Found duplicated word.")
|
|
19122 (message "End of buffer")))
|
|
19123 @end group
|
|
19124
|
|
19125 @group
|
|
19126 ;; Bind `the-the' to C-c \
|
|
19127 (global-set-key "\C-c\\" 'the-the)
|
|
19128 @end group
|
|
19129 @end smallexample
|
|
19130
|
|
19131 @sp 1
|
|
19132 Here is test text:
|
|
19133
|
|
19134 @smallexample
|
|
19135 @group
|
|
19136 one two two three four five
|
|
19137 five six seven
|
|
19138 @end group
|
|
19139 @end smallexample
|
|
19140
|
|
19141 You can substitute the other regular expressions shown above in the
|
|
19142 function definition and try each of them on this list.
|
|
19143
|
|
19144 @node Kill Ring, Full Graph, the-the, Top
|
|
19145 @appendix Handling the Kill Ring
|
|
19146 @cindex Kill ring handling
|
|
19147 @cindex Handling the kill ring
|
|
19148 @cindex Ring, making a list like a
|
|
19149
|
|
19150 The kill ring is a list that is transformed into a ring by the
|
|
19151 workings of the @code{current-kill} function. The @code{yank} and
|
|
19152 @code{yank-pop} commands use the @code{current-kill} function.
|
|
19153
|
|
19154 This appendix describes the @code{current-kill} function as well as
|
|
19155 both the @code{yank} and the @code{yank-pop} commands, but first,
|
|
19156 consider the workings of the kill ring.
|
|
19157
|
|
19158 @menu
|
|
19159 * What the Kill Ring Does::
|
|
19160 * current-kill::
|
|
19161 * yank:: Paste a copy of a clipped element.
|
|
19162 * yank-pop:: Insert element pointed to.
|
|
19163 * ring file::
|
|
19164 @end menu
|
|
19165
|
|
19166 @node What the Kill Ring Does, current-kill, Kill Ring, Kill Ring
|
|
19167 @ifnottex
|
|
19168 @unnumberedsec What the Kill Ring Does
|
|
19169 @end ifnottex
|
|
19170
|
|
19171 @need 1250
|
|
19172 The kill ring has a default maximum length of sixty items; this number
|
|
19173 is too large for an explanation. Instead, set it to four. Please
|
|
19174 evaluate the following:
|
|
19175
|
|
19176 @smallexample
|
|
19177 @group
|
|
19178 (setq old-kill-ring-max kill-ring-max)
|
|
19179 (setq kill-ring-max 4)
|
|
19180 @end group
|
|
19181 @end smallexample
|
|
19182
|
|
19183 @noindent
|
|
19184 Then, please copy each line of the following indented example into the
|
|
19185 kill ring. You may kill each line with @kbd{C-k} or mark it and copy
|
|
19186 it with @kbd{M-w}.
|
|
19187
|
|
19188 @noindent
|
|
19189 (In a read-only buffer, such as the @file{*info*} buffer, the kill
|
|
19190 command, @kbd{C-k} (@code{kill-line}), will not remove the text,
|
|
19191 merely copy it to the kill ring. However, your machine may beep at
|
|
19192 you. Alternatively, for silence, you may copy the region of each line
|
|
19193 with the @kbd{M-w} (@code{kill-ring-save}) command. You must mark
|
|
19194 each line for this command to succeed, but it does not matter at which
|
|
19195 end you put point or mark.)
|
|
19196
|
|
19197 @need 1250
|
|
19198 @noindent
|
|
19199 Please invoke the calls in order, so that five elements attempt to
|
|
19200 fill the kill ring:
|
|
19201
|
|
19202 @smallexample
|
|
19203 @group
|
|
19204 first some text
|
|
19205 second piece of text
|
|
19206 third line
|
|
19207 fourth line of text
|
|
19208 fifth bit of text
|
|
19209 @end group
|
|
19210 @end smallexample
|
|
19211
|
|
19212 @need 1250
|
|
19213 @noindent
|
|
19214 Then find the value of @code{kill-ring} by evaluating
|
|
19215
|
|
19216 @smallexample
|
|
19217 kill-ring
|
|
19218 @end smallexample
|
|
19219
|
|
19220 @need 800
|
|
19221 @noindent
|
|
19222 It is:
|
|
19223
|
|
19224 @smallexample
|
|
19225 @group
|
|
19226 ("fifth bit of text" "fourth line of text"
|
|
19227 "third line" "second piece of text")
|
|
19228 @end group
|
|
19229 @end smallexample
|
|
19230
|
|
19231 @noindent
|
|
19232 The first element, @samp{first some text}, was dropped.
|
|
19233
|
|
19234 @need 1250
|
|
19235 To return to the old value for the length of the kill ring, evaluate:
|
|
19236
|
|
19237 @smallexample
|
|
19238 (setq kill-ring-max old-kill-ring-max)
|
|
19239 @end smallexample
|
|
19240
|
|
19241 @node current-kill, yank, What the Kill Ring Does, Kill Ring
|
|
19242 @comment node-name, next, previous, up
|
|
19243 @appendixsec The @code{current-kill} Function
|
|
19244 @findex current-kill
|
|
19245
|
|
19246 The @code{current-kill} function changes the element in the kill ring
|
|
19247 to which @code{kill-ring-yank-pointer} points. (Also, the
|
|
19248 @code{kill-new} function sets @code{kill-ring-yank-pointer} to point
|
102151
|
19249 to the latest element of the kill ring. The @code{kill-new}
|
83955
|
19250 function is used directly or indirectly by @code{kill-append},
|
|
19251 @code{copy-region-as-kill}, @code{kill-ring-save}, @code{kill-line},
|
|
19252 and @code{kill-region}.)
|
|
19253
|
|
19254 @menu
|
|
19255 * Code for current-kill::
|
|
19256 * Understanding current-kill::
|
|
19257 @end menu
|
|
19258
|
|
19259 @node Code for current-kill, Understanding current-kill, current-kill, current-kill
|
|
19260 @ifnottex
|
|
19261 @unnumberedsubsec The code for @code{current-kill}
|
|
19262 @end ifnottex
|
|
19263
|
|
19264
|
|
19265 @need 1500
|
|
19266 The @code{current-kill} function is used by @code{yank} and by
|
|
19267 @code{yank-pop}. Here is the code for @code{current-kill}:
|
|
19268
|
|
19269 @smallexample
|
|
19270 @group
|
|
19271 (defun current-kill (n &optional do-not-move)
|
|
19272 "Rotate the yanking point by N places, and then return that kill.
|
|
19273 If N is zero, `interprogram-paste-function' is set, and calling it
|
|
19274 returns a string, then that string is added to the front of the
|
|
19275 kill ring and returned as the latest kill.
|
|
19276 @end group
|
|
19277 @group
|
|
19278 If optional arg DO-NOT-MOVE is non-nil, then don't actually move the
|
|
19279 yanking point; just return the Nth kill forward."
|
|
19280 (let ((interprogram-paste (and (= n 0)
|
|
19281 interprogram-paste-function
|
|
19282 (funcall interprogram-paste-function))))
|
|
19283 @end group
|
|
19284 @group
|
|
19285 (if interprogram-paste
|
|
19286 (progn
|
|
19287 ;; Disable the interprogram cut function when we add the new
|
|
19288 ;; text to the kill ring, so Emacs doesn't try to own the
|
|
19289 ;; selection, with identical text.
|
|
19290 (let ((interprogram-cut-function nil))
|
|
19291 (kill-new interprogram-paste))
|
|
19292 interprogram-paste)
|
|
19293 @end group
|
|
19294 @group
|
|
19295 (or kill-ring (error "Kill ring is empty"))
|
|
19296 (let ((ARGth-kill-element
|
|
19297 (nthcdr (mod (- n (length kill-ring-yank-pointer))
|
|
19298 (length kill-ring))
|
|
19299 kill-ring)))
|
|
19300 (or do-not-move
|
|
19301 (setq kill-ring-yank-pointer ARGth-kill-element))
|
|
19302 (car ARGth-kill-element)))))
|
|
19303 @end group
|
|
19304 @end smallexample
|
|
19305
|
|
19306 Remember also that the @code{kill-new} function sets
|
102151
|
19307 @code{kill-ring-yank-pointer} to the latest element of the kill
|
83955
|
19308 ring, which means that all the functions that call it set the value
|
|
19309 indirectly: @code{kill-append}, @code{copy-region-as-kill},
|
|
19310 @code{kill-ring-save}, @code{kill-line}, and @code{kill-region}.
|
|
19311
|
|
19312 @need 1500
|
|
19313 Here is the line in @code{kill-new}, which is explained in
|
|
19314 @ref{kill-new function, , The @code{kill-new} function}.
|
|
19315
|
|
19316 @smallexample
|
|
19317 (setq kill-ring-yank-pointer kill-ring)
|
|
19318 @end smallexample
|
|
19319
|
|
19320 @node Understanding current-kill, , Code for current-kill, current-kill
|
|
19321 @ifnottex
|
|
19322 @unnumberedsubsec @code{current-kill} in Outline
|
|
19323 @end ifnottex
|
|
19324
|
|
19325 The @code{current-kill} function looks complex, but as usual, it can
|
|
19326 be understood by taking it apart piece by piece. First look at it in
|
|
19327 skeletal form:
|
|
19328
|
|
19329 @smallexample
|
|
19330 @group
|
|
19331 (defun current-kill (n &optional do-not-move)
|
|
19332 "Rotate the yanking point by N places, and then return that kill."
|
|
19333 (let @var{varlist}
|
|
19334 @var{body}@dots{})
|
|
19335 @end group
|
|
19336 @end smallexample
|
|
19337
|
|
19338 This function takes two arguments, one of which is optional. It has a
|
|
19339 documentation string. It is @emph{not} interactive.
|
|
19340
|
|
19341 @menu
|
|
19342 * Body of current-kill::
|
|
19343 * Digression concerning error:: How to mislead humans, but not computers.
|
|
19344 * Determining the Element::
|
|
19345 @end menu
|
|
19346
|
|
19347 @node Body of current-kill, Digression concerning error, Understanding current-kill, Understanding current-kill
|
|
19348 @ifnottex
|
|
19349 @unnumberedsubsubsec The Body of @code{current-kill}
|
|
19350 @end ifnottex
|
|
19351
|
|
19352 The body of the function definition is a @code{let} expression, which
|
|
19353 itself has a body as well as a @var{varlist}.
|
|
19354
|
|
19355 The @code{let} expression declares a variable that will be only usable
|
|
19356 within the bounds of this function. This variable is called
|
|
19357 @code{interprogram-paste} and is for copying to another program. It
|
|
19358 is not for copying within this instance of GNU Emacs. Most window
|
|
19359 systems provide a facility for interprogram pasting. Sadly, that
|
|
19360 facility usually provides only for the last element. Most windowing
|
|
19361 systems have not adopted a ring of many possibilities, even though
|
|
19362 Emacs has provided it for decades.
|
|
19363
|
|
19364 The @code{if} expression has two parts, one if there exists
|
|
19365 @code{interprogram-paste} and one if not.
|
|
19366
|
|
19367 @need 2000
|
|
19368 Let us consider the `if not' or else-part of the @code{current-kill}
|
102151
|
19369 function. (The then-part uses the @code{kill-new} function, which
|
83955
|
19370 we have already described. @xref{kill-new function, , The
|
|
19371 @code{kill-new} function}.)
|
|
19372
|
|
19373 @smallexample
|
|
19374 @group
|
|
19375 (or kill-ring (error "Kill ring is empty"))
|
|
19376 (let ((ARGth-kill-element
|
|
19377 (nthcdr (mod (- n (length kill-ring-yank-pointer))
|
|
19378 (length kill-ring))
|
|
19379 kill-ring)))
|
|
19380 (or do-not-move
|
|
19381 (setq kill-ring-yank-pointer ARGth-kill-element))
|
|
19382 (car ARGth-kill-element))
|
|
19383 @end group
|
|
19384 @end smallexample
|
|
19385
|
|
19386 @noindent
|
|
19387 The code first checks whether the kill ring has content; otherwise it
|
|
19388 signals an error.
|
|
19389
|
|
19390 @need 1000
|
|
19391 Note that the @code{or} expression is very similar to testing length
|
|
19392 with an @code{if}:
|
|
19393
|
|
19394 @findex zerop
|
|
19395 @findex error
|
|
19396 @smallexample
|
|
19397 @group
|
|
19398 (if (zerop (length kill-ring)) ; @r{if-part}
|
|
19399 (error "Kill ring is empty")) ; @r{then-part}
|
|
19400 ;; No else-part
|
|
19401 @end group
|
|
19402 @end smallexample
|
|
19403
|
|
19404 @noindent
|
|
19405 If there is not anything in the kill ring, its length must be zero and
|
|
19406 an error message sent to the user: @samp{Kill ring is empty}. The
|
|
19407 @code{current-kill} function uses an @code{or} expression which is
|
|
19408 simpler. But an @code{if} expression reminds us what goes on.
|
|
19409
|
|
19410 This @code{if} expression uses the function @code{zerop} which returns
|
|
19411 true if the value it is testing is zero. When @code{zerop} tests
|
|
19412 true, the then-part of the @code{if} is evaluated. The then-part is a
|
|
19413 list starting with the function @code{error}, which is a function that
|
|
19414 is similar to the @code{message} function
|
|
19415 (@pxref{message, , The @code{message} Function}) in that
|
|
19416 it prints a one-line message in the echo area. However, in addition
|
|
19417 to printing a message, @code{error} also stops evaluation of the
|
|
19418 function within which it is embedded. This means that the rest of the
|
|
19419 function will not be evaluated if the length of the kill ring is zero.
|
|
19420
|
|
19421 Then the @code{current-kill} function selects the element to return.
|
|
19422 The selection depends on the number of places that @code{current-kill}
|
|
19423 rotates and on where @code{kill-ring-yank-pointer} points.
|
|
19424
|
|
19425 Next, either the optional @code{do-not-move} argument is true or the
|
|
19426 current value of @code{kill-ring-yank-pointer} is set to point to the
|
|
19427 list. Finally, another expression returns the first element of the
|
|
19428 list even if the @code{do-not-move} argument is true.
|
|
19429
|
|
19430 @node Digression concerning error, Determining the Element, Body of current-kill, Understanding current-kill
|
|
19431 @ifnottex
|
|
19432 @unnumberedsubsubsec Digression about the word `error'
|
|
19433 @end ifnottex
|
|
19434
|
|
19435 In my opinion, it is slightly misleading, at least to humans, to use
|
|
19436 the term `error' as the name of the @code{error} function. A better
|
|
19437 term would be `cancel'. Strictly speaking, of course, you cannot
|
|
19438 point to, much less rotate a pointer to a list that has no length, so
|
|
19439 from the point of view of the computer, the word `error' is correct.
|
|
19440 But a human expects to attempt this sort of thing, if only to find out
|
|
19441 whether the kill ring is full or empty. This is an act of
|
|
19442 exploration.
|
|
19443
|
|
19444 From the human point of view, the act of exploration and discovery is
|
|
19445 not necessarily an error, and therefore should not be labelled as one,
|
|
19446 even in the bowels of a computer. As it is, the code in Emacs implies
|
|
19447 that a human who is acting virtuously, by exploring his or her
|
|
19448 environment, is making an error. This is bad. Even though the computer
|
|
19449 takes the same steps as it does when there is an `error', a term such as
|
|
19450 `cancel' would have a clearer connotation.
|
|
19451
|
|
19452 @node Determining the Element, , Digression concerning error, Understanding current-kill
|
|
19453 @ifnottex
|
|
19454 @unnumberedsubsubsec Determining the Element
|
|
19455 @end ifnottex
|
|
19456
|
|
19457 Among other actions, the else-part of the @code{if} expression sets
|
|
19458 the value of @code{kill-ring-yank-pointer} to
|
|
19459 @code{ARGth-kill-element} when the kill ring has something in it and
|
|
19460 the value of @code{do-not-move} is @code{nil}.
|
|
19461
|
|
19462 @need 800
|
|
19463 The code looks like this:
|
|
19464
|
|
19465 @smallexample
|
|
19466 @group
|
|
19467 (nthcdr (mod (- n (length kill-ring-yank-pointer))
|
|
19468 (length kill-ring))
|
|
19469 kill-ring)))
|
|
19470 @end group
|
|
19471 @end smallexample
|
|
19472
|
|
19473 This needs some examination. Unless it is not supposed to move the
|
|
19474 pointer, the @code{current-kill} function changes where
|
|
19475 @code{kill-ring-yank-pointer} points.
|
|
19476 That is what the
|
|
19477 @w{@code{(setq kill-ring-yank-pointer ARGth-kill-element))}}
|
|
19478 expression does. Also, clearly, @code{ARGth-kill-element} is being
|
|
19479 set to be equal to some @sc{cdr} of the kill ring, using the
|
|
19480 @code{nthcdr} function that is described in an earlier section.
|
|
19481 (@xref{copy-region-as-kill}.) How does it do this?
|
|
19482
|
|
19483 As we have seen before (@pxref{nthcdr}), the @code{nthcdr} function
|
|
19484 works by repeatedly taking the @sc{cdr} of a list---it takes the
|
|
19485 @sc{cdr} of the @sc{cdr} of the @sc{cdr} @dots{}
|
|
19486
|
|
19487 @need 800
|
|
19488 The two following expressions produce the same result:
|
|
19489
|
|
19490 @smallexample
|
|
19491 @group
|
|
19492 (setq kill-ring-yank-pointer (cdr kill-ring))
|
|
19493
|
|
19494 (setq kill-ring-yank-pointer (nthcdr 1 kill-ring))
|
|
19495 @end group
|
|
19496 @end smallexample
|
|
19497
|
|
19498 However, the @code{nthcdr} expression is more complicated. It uses
|
|
19499 the @code{mod} function to determine which @sc{cdr} to select.
|
|
19500
|
|
19501 (You will remember to look at inner functions first; indeed, we will
|
|
19502 have to go inside the @code{mod}.)
|
|
19503
|
|
19504 The @code{mod} function returns the value of its first argument modulo
|
|
19505 the second; that is to say, it returns the remainder after dividing
|
|
19506 the first argument by the second. The value returned has the same
|
|
19507 sign as the second argument.
|
|
19508
|
|
19509 @need 800
|
|
19510 Thus,
|
|
19511
|
|
19512 @smallexample
|
|
19513 @group
|
|
19514 (mod 12 4)
|
|
19515 @result{} 0 ;; @r{because there is no remainder}
|
|
19516 (mod 13 4)
|
|
19517 @result{} 1
|
|
19518 @end group
|
|
19519 @end smallexample
|
|
19520
|
|
19521 @need 1250
|
|
19522 In this case, the first argument is often smaller than the second.
|
|
19523 That is fine.
|
|
19524
|
|
19525 @smallexample
|
|
19526 @group
|
|
19527 (mod 0 4)
|
|
19528 @result{} 0
|
|
19529 (mod 1 4)
|
|
19530 @result{} 1
|
|
19531 @end group
|
|
19532 @end smallexample
|
|
19533
|
|
19534 We can guess what the @code{-} function does. It is like @code{+} but
|
|
19535 subtracts instead of adds; the @code{-} function subtracts its second
|
|
19536 argument from its first. Also, we already know what the @code{length}
|
|
19537 function does (@pxref{length}). It returns the length of a list.
|
|
19538
|
|
19539 And @code{n} is the name of the required argument to the
|
|
19540 @code{current-kill} function.
|
|
19541
|
|
19542 @need 1250
|
|
19543 So when the first argument to @code{nthcdr} is zero, the @code{nthcdr}
|
|
19544 expression returns the whole list, as you can see by evaluating the
|
|
19545 following:
|
|
19546
|
|
19547 @smallexample
|
|
19548 @group
|
|
19549 ;; kill-ring-yank-pointer @r{and} kill-ring @r{have a length of four}
|
|
19550 ;; @r{and} (mod (- 0 4) 4) @result{} 0
|
|
19551 (nthcdr (mod (- 0 4) 4)
|
|
19552 '("fourth line of text"
|
|
19553 "third line"
|
|
19554 "second piece of text"
|
|
19555 "first some text"))
|
|
19556 @end group
|
|
19557 @end smallexample
|
|
19558
|
|
19559 @need 1250
|
|
19560 When the first argument to the @code{current-kill} function is one,
|
|
19561 the @code{nthcdr} expression returns the list without its first
|
|
19562 element.
|
|
19563
|
|
19564 @smallexample
|
|
19565 @group
|
|
19566 (nthcdr (mod (- 1 4) 4)
|
|
19567 '("fourth line of text"
|
|
19568 "third line"
|
|
19569 "second piece of text"
|
|
19570 "first some text"))
|
|
19571 @end group
|
|
19572 @end smallexample
|
|
19573
|
|
19574 @cindex @samp{global variable} defined
|
|
19575 @cindex @samp{variable, global}, defined
|
|
19576 Incidentally, both @code{kill-ring} and @code{kill-ring-yank-pointer}
|
|
19577 are @dfn{global variables}. That means that any expression in Emacs
|
|
19578 Lisp can access them. They are not like the local variables set by
|
|
19579 @code{let} or like the symbols in an argument list.
|
|
19580 Local variables can only be accessed
|
|
19581 within the @code{let} that defines them or the function that specifies
|
|
19582 them in an argument list (and within expressions called by them).
|
|
19583
|
|
19584 @ignore
|
|
19585 @c texi2dvi fails when the name of the section is within ifnottex ...
|
|
19586 (@xref{Prevent confusion, , @code{let} Prevents Confusion}, and
|
|
19587 @ref{defun, , The @code{defun} Special Form}.)
|
|
19588 @end ignore
|
|
19589
|
|
19590 @node yank, yank-pop, current-kill, Kill Ring
|
|
19591 @comment node-name, next, previous, up
|
|
19592 @appendixsec @code{yank}
|
|
19593 @findex yank
|
|
19594
|
|
19595 After learning about @code{current-kill}, the code for the
|
|
19596 @code{yank} function is almost easy.
|
|
19597
|
|
19598 The @code{yank} function does not use the
|
|
19599 @code{kill-ring-yank-pointer} variable directly. It calls
|
|
19600 @code{insert-for-yank} which calls @code{current-kill} which sets the
|
|
19601 @code{kill-ring-yank-pointer} variable.
|
|
19602
|
|
19603 @need 1250
|
|
19604 The code looks like this:
|
|
19605
|
|
19606 @c in GNU Emacs 22
|
|
19607 @smallexample
|
|
19608 @group
|
|
19609 (defun yank (&optional arg)
|
|
19610 "Reinsert (\"paste\") the last stretch of killed text.
|
|
19611 More precisely, reinsert the stretch of killed text most recently
|
|
19612 killed OR yanked. Put point at end, and set mark at beginning.
|
|
19613 With just \\[universal-argument] as argument, same but put point at
|
|
19614 beginning (and mark at end). With argument N, reinsert the Nth most
|
|
19615 recently killed stretch of killed text.
|
|
19616
|
|
19617 When this command inserts killed text into the buffer, it honors
|
|
19618 `yank-excluded-properties' and `yank-handler' as described in the
|
|
19619 doc string for `insert-for-yank-1', which see.
|
|
19620
|
|
19621 See also the command \\[yank-pop]."
|
|
19622 @end group
|
|
19623 @group
|
|
19624 (interactive "*P")
|
|
19625 (setq yank-window-start (window-start))
|
|
19626 ;; If we don't get all the way thru, make last-command indicate that
|
|
19627 ;; for the following command.
|
|
19628 (setq this-command t)
|
|
19629 (push-mark (point))
|
|
19630 @end group
|
|
19631 @group
|
|
19632 (insert-for-yank (current-kill (cond
|
|
19633 ((listp arg) 0)
|
|
19634 ((eq arg '-) -2)
|
|
19635 (t (1- arg)))))
|
|
19636 (if (consp arg)
|
|
19637 ;; This is like exchange-point-and-mark,
|
|
19638 ;; but doesn't activate the mark.
|
|
19639 ;; It is cleaner to avoid activation, even though the command
|
|
19640 ;; loop would deactivate the mark because we inserted text.
|
|
19641 (goto-char (prog1 (mark t)
|
|
19642 (set-marker (mark-marker) (point) (current-buffer)))))
|
|
19643 @end group
|
|
19644 @group
|
|
19645 ;; If we do get all the way thru, make this-command indicate that.
|
|
19646 (if (eq this-command t)
|
|
19647 (setq this-command 'yank))
|
|
19648 nil)
|
|
19649 @end group
|
|
19650 @end smallexample
|
|
19651
|
|
19652 The key expression is @code{insert-for-yank}, which inserts the string
|
|
19653 returned by @code{current-kill}, but removes some text properties from
|
|
19654 it.
|
|
19655
|
|
19656 However, before getting to that expression, the function sets the value
|
|
19657 of @code{yank-window-start} to the position returned by the
|
|
19658 @code{(window-start)} expression, the position at which the display
|
|
19659 currently starts. The @code{yank} function also sets
|
|
19660 @code{this-command} and pushes the mark.
|
|
19661
|
|
19662 After it yanks the appropriate element, if the optional argument is a
|
|
19663 @sc{cons} rather than a number or nothing, it puts point at beginning
|
|
19664 of the yanked text and mark at its end.
|
|
19665
|
|
19666 (The @code{prog1} function is like @code{progn} but returns the value
|
|
19667 of its first argument rather than the value of its last argument. Its
|
|
19668 first argument is forced to return the buffer's mark as an integer.
|
|
19669 You can see the documentation for these functions by placing point
|
|
19670 over them in this buffer and then typing @kbd{C-h f}
|
|
19671 (@code{describe-function}) followed by a @kbd{RET}; the default is the
|
|
19672 function.)
|
|
19673
|
|
19674 The last part of the function tells what to do when it succeeds.
|
|
19675
|
|
19676 @node yank-pop, ring file, yank, Kill Ring
|
|
19677 @comment node-name, next, previous, up
|
|
19678 @appendixsec @code{yank-pop}
|
|
19679 @findex yank-pop
|
|
19680
|
|
19681 After understanding @code{yank} and @code{current-kill}, you know how
|
|
19682 to approach the @code{yank-pop} function. Leaving out the
|
|
19683 documentation to save space, it looks like this:
|
|
19684
|
|
19685 @c GNU Emacs 22
|
|
19686 @smallexample
|
|
19687 @group
|
|
19688 (defun yank-pop (&optional arg)
|
|
19689 "@dots{}"
|
|
19690 (interactive "*p")
|
|
19691 (if (not (eq last-command 'yank))
|
|
19692 (error "Previous command was not a yank"))
|
|
19693 @end group
|
|
19694 @group
|
|
19695 (setq this-command 'yank)
|
|
19696 (unless arg (setq arg 1))
|
|
19697 (let ((inhibit-read-only t)
|
|
19698 (before (< (point) (mark t))))
|
|
19699 @end group
|
|
19700 @group
|
|
19701 (if before
|
|
19702 (funcall (or yank-undo-function 'delete-region) (point) (mark t))
|
|
19703 (funcall (or yank-undo-function 'delete-region) (mark t) (point)))
|
|
19704 (setq yank-undo-function nil)
|
|
19705 @end group
|
|
19706 @group
|
|
19707 (set-marker (mark-marker) (point) (current-buffer))
|
|
19708 (insert-for-yank (current-kill arg))
|
|
19709 ;; Set the window start back where it was in the yank command,
|
|
19710 ;; if possible.
|
|
19711 (set-window-start (selected-window) yank-window-start t)
|
|
19712 @end group
|
|
19713 @group
|
|
19714 (if before
|
|
19715 ;; This is like exchange-point-and-mark,
|
|
19716 ;; but doesn't activate the mark.
|
|
19717 ;; It is cleaner to avoid activation, even though the command
|
|
19718 ;; loop would deactivate the mark because we inserted text.
|
|
19719 (goto-char (prog1 (mark t)
|
|
19720 (set-marker (mark-marker)
|
|
19721 (point)
|
|
19722 (current-buffer))))))
|
|
19723 nil)
|
|
19724 @end group
|
|
19725 @end smallexample
|
|
19726
|
|
19727 The function is interactive with a small @samp{p} so the prefix
|
|
19728 argument is processed and passed to the function. The command can
|
|
19729 only be used after a previous yank; otherwise an error message is
|
|
19730 sent. This check uses the variable @code{last-command} which is set
|
|
19731 by @code{yank} and is discussed elsewhere.
|
|
19732 (@xref{copy-region-as-kill}.)
|
|
19733
|
|
19734 The @code{let} clause sets the variable @code{before} to true or false
|
|
19735 depending whether point is before or after mark and then the region
|
|
19736 between point and mark is deleted. This is the region that was just
|
|
19737 inserted by the previous yank and it is this text that will be
|
|
19738 replaced.
|
|
19739
|
|
19740 @code{funcall} calls its first argument as a function, passing
|
|
19741 remaining arguments to it. The first argument is whatever the
|
|
19742 @code{or} expression returns. The two remaining arguments are the
|
|
19743 positions of point and mark set by the preceding @code{yank} command.
|
|
19744
|
|
19745 There is more, but that is the hardest part.
|
|
19746
|
|
19747 @node ring file, , yank-pop, Kill Ring
|
|
19748 @comment node-name, next, previous, up
|
|
19749 @appendixsec The @file{ring.el} File
|
|
19750 @cindex @file{ring.el} file
|
|
19751
|
|
19752 Interestingly, GNU Emacs posses a file called @file{ring.el} that
|
|
19753 provides many of the features we just discussed. But functions such
|
|
19754 as @code{kill-ring-yank-pointer} do not use this library, possibly
|
|
19755 because they were written earlier.
|
|
19756
|
|
19757 @node Full Graph, Free Software and Free Manuals, Kill Ring, Top
|
|
19758 @appendix A Graph with Labelled Axes
|
|
19759
|
|
19760 Printed axes help you understand a graph. They convey scale. In an
|
|
19761 earlier chapter (@pxref{Readying a Graph, , Readying a Graph}), we
|
|
19762 wrote the code to print the body of a graph. Here we write the code
|
|
19763 for printing and labelling vertical and horizontal axes, along with the
|
|
19764 body itself.
|
|
19765
|
|
19766 @menu
|
|
19767 * Labelled Example::
|
|
19768 * print-graph Varlist:: @code{let} expression in @code{print-graph}.
|
|
19769 * print-Y-axis:: Print a label for the vertical axis.
|
|
19770 * print-X-axis:: Print a horizontal label.
|
|
19771 * Print Whole Graph:: The function to print a complete graph.
|
|
19772 @end menu
|
|
19773
|
|
19774 @node Labelled Example, print-graph Varlist, Full Graph, Full Graph
|
|
19775 @ifnottex
|
|
19776 @unnumberedsec Labelled Example Graph
|
|
19777 @end ifnottex
|
|
19778
|
|
19779 Since insertions fill a buffer to the right and below point, the new
|
|
19780 graph printing function should first print the Y or vertical axis,
|
|
19781 then the body of the graph, and finally the X or horizontal axis.
|
|
19782 This sequence lays out for us the contents of the function:
|
|
19783
|
|
19784 @enumerate
|
|
19785 @item
|
|
19786 Set up code.
|
|
19787
|
|
19788 @item
|
|
19789 Print Y axis.
|
|
19790
|
|
19791 @item
|
|
19792 Print body of graph.
|
|
19793
|
|
19794 @item
|
|
19795 Print X axis.
|
|
19796 @end enumerate
|
|
19797
|
|
19798 @need 800
|
|
19799 Here is an example of how a finished graph should look:
|
|
19800
|
|
19801 @smallexample
|
|
19802 @group
|
|
19803 10 -
|
|
19804 *
|
|
19805 * *
|
|
19806 * **
|
|
19807 * ***
|
|
19808 5 - * *******
|
|
19809 * *** *******
|
|
19810 *************
|
|
19811 ***************
|
|
19812 1 - ****************
|
|
19813 | | | |
|
|
19814 1 5 10 15
|
|
19815 @end group
|
|
19816 @end smallexample
|
|
19817
|
|
19818 @noindent
|
|
19819 In this graph, both the vertical and the horizontal axes are labelled
|
|
19820 with numbers. However, in some graphs, the horizontal axis is time
|
|
19821 and would be better labelled with months, like this:
|
|
19822
|
|
19823 @smallexample
|
|
19824 @group
|
|
19825 5 - *
|
|
19826 * ** *
|
|
19827 *******
|
|
19828 ********** **
|
|
19829 1 - **************
|
|
19830 | ^ |
|
|
19831 Jan June Jan
|
|
19832 @end group
|
|
19833 @end smallexample
|
|
19834
|
|
19835 Indeed, with a little thought, we can easily come up with a variety of
|
|
19836 vertical and horizontal labelling schemes. Our task could become
|
|
19837 complicated. But complications breed confusion. Rather than permit
|
|
19838 this, it is better choose a simple labelling scheme for our first
|
|
19839 effort, and to modify or replace it later.
|
|
19840
|
|
19841 @need 1200
|
|
19842 These considerations suggest the following outline for the
|
|
19843 @code{print-graph} function:
|
|
19844
|
|
19845 @smallexample
|
|
19846 @group
|
|
19847 (defun print-graph (numbers-list)
|
|
19848 "@var{documentation}@dots{}"
|
|
19849 (let ((height @dots{}
|
|
19850 @dots{}))
|
|
19851 @end group
|
|
19852 @group
|
|
19853 (print-Y-axis height @dots{} )
|
|
19854 (graph-body-print numbers-list)
|
|
19855 (print-X-axis @dots{} )))
|
|
19856 @end group
|
|
19857 @end smallexample
|
|
19858
|
|
19859 We can work on each part of the @code{print-graph} function definition
|
|
19860 in turn.
|
|
19861
|
|
19862 @node print-graph Varlist, print-Y-axis, Labelled Example, Full Graph
|
|
19863 @comment node-name, next, previous, up
|
|
19864 @appendixsec The @code{print-graph} Varlist
|
|
19865 @cindex @code{print-graph} varlist
|
|
19866
|
|
19867 In writing the @code{print-graph} function, the first task is to write
|
|
19868 the varlist in the @code{let} expression. (We will leave aside for the
|
|
19869 moment any thoughts about making the function interactive or about the
|
|
19870 contents of its documentation string.)
|
|
19871
|
|
19872 The varlist should set several values. Clearly, the top of the label
|
|
19873 for the vertical axis must be at least the height of the graph, which
|
|
19874 means that we must obtain this information here. Note that the
|
|
19875 @code{print-graph-body} function also requires this information. There
|
|
19876 is no reason to calculate the height of the graph in two different
|
|
19877 places, so we should change @code{print-graph-body} from the way we
|
|
19878 defined it earlier to take advantage of the calculation.
|
|
19879
|
|
19880 Similarly, both the function for printing the X axis labels and the
|
|
19881 @code{print-graph-body} function need to learn the value of the width of
|
|
19882 each symbol. We can perform the calculation here and change the
|
|
19883 definition for @code{print-graph-body} from the way we defined it in the
|
|
19884 previous chapter.
|
|
19885
|
|
19886 The length of the label for the horizontal axis must be at least as long
|
|
19887 as the graph. However, this information is used only in the function
|
|
19888 that prints the horizontal axis, so it does not need to be calculated here.
|
|
19889
|
|
19890 These thoughts lead us directly to the following form for the varlist
|
|
19891 in the @code{let} for @code{print-graph}:
|
|
19892
|
|
19893 @smallexample
|
|
19894 @group
|
|
19895 (let ((height (apply 'max numbers-list)) ; @r{First version.}
|
|
19896 (symbol-width (length graph-blank)))
|
|
19897 @end group
|
|
19898 @end smallexample
|
|
19899
|
|
19900 @noindent
|
|
19901 As we shall see, this expression is not quite right.
|
|
19902
|
|
19903 @need 2000
|
|
19904 @node print-Y-axis, print-X-axis, print-graph Varlist, Full Graph
|
|
19905 @comment node-name, next, previous, up
|
|
19906 @appendixsec The @code{print-Y-axis} Function
|
|
19907 @cindex Axis, print vertical
|
|
19908 @cindex Y axis printing
|
|
19909 @cindex Vertical axis printing
|
|
19910 @cindex Print vertical axis
|
|
19911
|
|
19912 The job of the @code{print-Y-axis} function is to print a label for
|
|
19913 the vertical axis that looks like this:
|
|
19914
|
|
19915 @smallexample
|
|
19916 @group
|
|
19917 10 -
|
|
19918
|
|
19919
|
|
19920
|
|
19921
|
|
19922 5 -
|
|
19923
|
|
19924
|
|
19925
|
|
19926 1 -
|
|
19927 @end group
|
|
19928 @end smallexample
|
|
19929
|
|
19930 @noindent
|
|
19931 The function should be passed the height of the graph, and then should
|
|
19932 construct and insert the appropriate numbers and marks.
|
|
19933
|
|
19934 @menu
|
|
19935 * print-Y-axis in Detail::
|
|
19936 * Height of label:: What height for the Y axis?
|
|
19937 * Compute a Remainder:: How to compute the remainder of a division.
|
|
19938 * Y Axis Element:: Construct a line for the Y axis.
|
|
19939 * Y-axis-column:: Generate a list of Y axis labels.
|
|
19940 * print-Y-axis Penultimate:: A not quite final version.
|
|
19941 @end menu
|
|
19942
|
|
19943 @node print-Y-axis in Detail, Height of label, print-Y-axis, print-Y-axis
|
|
19944 @ifnottex
|
|
19945 @unnumberedsubsec The @code{print-Y-axis} Function in Detail
|
|
19946 @end ifnottex
|
|
19947
|
|
19948 It is easy enough to see in the figure what the Y axis label should
|
|
19949 look like; but to say in words, and then to write a function
|
|
19950 definition to do the job is another matter. It is not quite true to
|
|
19951 say that we want a number and a tic every five lines: there are only
|
|
19952 three lines between the @samp{1} and the @samp{5} (lines 2, 3, and 4),
|
|
19953 but four lines between the @samp{5} and the @samp{10} (lines 6, 7, 8,
|
|
19954 and 9). It is better to say that we want a number and a tic mark on
|
|
19955 the base line (number 1) and then that we want a number and a tic on
|
|
19956 the fifth line from the bottom and on every line that is a multiple of
|
|
19957 five.
|
|
19958
|
|
19959 @node Height of label, Compute a Remainder, print-Y-axis in Detail, print-Y-axis
|
|
19960 @ifnottex
|
|
19961 @unnumberedsubsec What height should the label be?
|
|
19962 @end ifnottex
|
|
19963
|
|
19964 The next issue is what height the label should be? Suppose the maximum
|
|
19965 height of tallest column of the graph is seven. Should the highest
|
|
19966 label on the Y axis be @samp{5 -}, and should the graph stick up above
|
|
19967 the label? Or should the highest label be @samp{7 -}, and mark the peak
|
|
19968 of the graph? Or should the highest label be @code{10 -}, which is a
|
|
19969 multiple of five, and be higher than the topmost value of the graph?
|
|
19970
|
|
19971 The latter form is preferred. Most graphs are drawn within rectangles
|
|
19972 whose sides are an integral number of steps long---5, 10, 15, and so
|
|
19973 on for a step distance of five. But as soon as we decide to use a
|
|
19974 step height for the vertical axis, we discover that the simple
|
|
19975 expression in the varlist for computing the height is wrong. The
|
|
19976 expression is @code{(apply 'max numbers-list)}. This returns the
|
|
19977 precise height, not the maximum height plus whatever is necessary to
|
|
19978 round up to the nearest multiple of five. A more complex expression
|
|
19979 is required.
|
|
19980
|
|
19981 As usual in cases like this, a complex problem becomes simpler if it is
|
|
19982 divided into several smaller problems.
|
|
19983
|
|
19984 First, consider the case when the highest value of the graph is an
|
|
19985 integral multiple of five---when it is 5, 10, 15, or some higher
|
|
19986 multiple of five. We can use this value as the Y axis height.
|
|
19987
|
|
19988 A fairly simply way to determine whether a number is a multiple of
|
|
19989 five is to divide it by five and see if the division results in a
|
|
19990 remainder. If there is no remainder, the number is a multiple of
|
|
19991 five. Thus, seven divided by five has a remainder of two, and seven
|
|
19992 is not an integral multiple of five. Put in slightly different
|
|
19993 language, more reminiscent of the classroom, five goes into seven
|
|
19994 once, with a remainder of two. However, five goes into ten twice,
|
|
19995 with no remainder: ten is an integral multiple of five.
|
|
19996
|
|
19997 @node Compute a Remainder, Y Axis Element, Height of label, print-Y-axis
|
|
19998 @appendixsubsec Side Trip: Compute a Remainder
|
|
19999
|
|
20000 @findex % @r{(remainder function)}
|
|
20001 @cindex Remainder function, @code{%}
|
|
20002 In Lisp, the function for computing a remainder is @code{%}. The
|
|
20003 function returns the remainder of its first argument divided by its
|
|
20004 second argument. As it happens, @code{%} is a function in Emacs Lisp
|
|
20005 that you cannot discover using @code{apropos}: you find nothing if you
|
|
20006 type @kbd{M-x apropos @key{RET} remainder @key{RET}}. The only way to
|
|
20007 learn of the existence of @code{%} is to read about it in a book such
|
|
20008 as this or in the Emacs Lisp sources.
|
|
20009
|
|
20010 You can try the @code{%} function by evaluating the following two
|
|
20011 expressions:
|
|
20012
|
|
20013 @smallexample
|
|
20014 @group
|
|
20015 (% 7 5)
|
|
20016
|
|
20017 (% 10 5)
|
|
20018 @end group
|
|
20019 @end smallexample
|
|
20020
|
|
20021 @noindent
|
|
20022 The first expression returns 2 and the second expression returns 0.
|
|
20023
|
|
20024 To test whether the returned value is zero or some other number, we
|
|
20025 can use the @code{zerop} function. This function returns @code{t} if
|
|
20026 its argument, which must be a number, is zero.
|
|
20027
|
|
20028 @smallexample
|
|
20029 @group
|
|
20030 (zerop (% 7 5))
|
|
20031 @result{} nil
|
|
20032
|
|
20033 (zerop (% 10 5))
|
|
20034 @result{} t
|
|
20035 @end group
|
|
20036 @end smallexample
|
|
20037
|
|
20038 Thus, the following expression will return @code{t} if the height
|
|
20039 of the graph is evenly divisible by five:
|
|
20040
|
|
20041 @smallexample
|
|
20042 (zerop (% height 5))
|
|
20043 @end smallexample
|
|
20044
|
|
20045 @noindent
|
|
20046 (The value of @code{height}, of course, can be found from @code{(apply
|
|
20047 'max numbers-list)}.)
|
|
20048
|
|
20049 On the other hand, if the value of @code{height} is not a multiple of
|
|
20050 five, we want to reset the value to the next higher multiple of five.
|
|
20051 This is straightforward arithmetic using functions with which we are
|
|
20052 already familiar. First, we divide the value of @code{height} by five
|
|
20053 to determine how many times five goes into the number. Thus, five
|
|
20054 goes into twelve twice. If we add one to this quotient and multiply by
|
|
20055 five, we will obtain the value of the next multiple of five that is
|
|
20056 larger than the height. Five goes into twelve twice. Add one to two,
|
|
20057 and multiply by five; the result is fifteen, which is the next multiple
|
|
20058 of five that is higher than twelve. The Lisp expression for this is:
|
|
20059
|
|
20060 @smallexample
|
|
20061 (* (1+ (/ height 5)) 5)
|
|
20062 @end smallexample
|
|
20063
|
|
20064 @noindent
|
|
20065 For example, if you evaluate the following, the result is 15:
|
|
20066
|
|
20067 @smallexample
|
|
20068 (* (1+ (/ 12 5)) 5)
|
|
20069 @end smallexample
|
|
20070
|
|
20071 All through this discussion, we have been using `five' as the value
|
|
20072 for spacing labels on the Y axis; but we may want to use some other
|
|
20073 value. For generality, we should replace `five' with a variable to
|
|
20074 which we can assign a value. The best name I can think of for this
|
|
20075 variable is @code{Y-axis-label-spacing}.
|
|
20076
|
|
20077 @need 1250
|
|
20078 Using this term, and an @code{if} expression, we produce the
|
|
20079 following:
|
|
20080
|
|
20081 @smallexample
|
|
20082 @group
|
|
20083 (if (zerop (% height Y-axis-label-spacing))
|
|
20084 height
|
|
20085 ;; @r{else}
|
|
20086 (* (1+ (/ height Y-axis-label-spacing))
|
|
20087 Y-axis-label-spacing))
|
|
20088 @end group
|
|
20089 @end smallexample
|
|
20090
|
|
20091 @noindent
|
|
20092 This expression returns the value of @code{height} itself if the height
|
|
20093 is an even multiple of the value of the @code{Y-axis-label-spacing} or
|
|
20094 else it computes and returns a value of @code{height} that is equal to
|
|
20095 the next higher multiple of the value of the @code{Y-axis-label-spacing}.
|
|
20096
|
|
20097 We can now include this expression in the @code{let} expression of the
|
|
20098 @code{print-graph} function (after first setting the value of
|
|
20099 @code{Y-axis-label-spacing}):
|
|
20100 @vindex Y-axis-label-spacing
|
|
20101
|
|
20102 @smallexample
|
|
20103 @group
|
|
20104 (defvar Y-axis-label-spacing 5
|
|
20105 "Number of lines from one Y axis label to next.")
|
|
20106 @end group
|
|
20107
|
|
20108 @group
|
|
20109 @dots{}
|
|
20110 (let* ((height (apply 'max numbers-list))
|
|
20111 (height-of-top-line
|
|
20112 (if (zerop (% height Y-axis-label-spacing))
|
|
20113 height
|
|
20114 @end group
|
|
20115 @group
|
|
20116 ;; @r{else}
|
|
20117 (* (1+ (/ height Y-axis-label-spacing))
|
|
20118 Y-axis-label-spacing)))
|
|
20119 (symbol-width (length graph-blank))))
|
|
20120 @dots{}
|
|
20121 @end group
|
|
20122 @end smallexample
|
|
20123
|
|
20124 @noindent
|
|
20125 (Note use of the @code{let*} function: the initial value of height is
|
|
20126 computed once by the @code{(apply 'max numbers-list)} expression and
|
|
20127 then the resulting value of @code{height} is used to compute its
|
|
20128 final value. @xref{fwd-para let, , The @code{let*} expression}, for
|
|
20129 more about @code{let*}.)
|
|
20130
|
|
20131 @node Y Axis Element, Y-axis-column, Compute a Remainder, print-Y-axis
|
|
20132 @appendixsubsec Construct a Y Axis Element
|
|
20133
|
|
20134 When we print the vertical axis, we want to insert strings such as
|
|
20135 @w{@samp{5 -}} and @w{@samp{10 - }} every five lines.
|
|
20136 Moreover, we want the numbers and dashes to line up, so shorter
|
|
20137 numbers must be padded with leading spaces. If some of the strings
|
|
20138 use two digit numbers, the strings with single digit numbers must
|
|
20139 include a leading blank space before the number.
|
|
20140
|
|
20141 @findex number-to-string
|
|
20142 To figure out the length of the number, the @code{length} function is
|
|
20143 used. But the @code{length} function works only with a string, not with
|
|
20144 a number. So the number has to be converted from being a number to
|
|
20145 being a string. This is done with the @code{number-to-string} function.
|
|
20146 For example,
|
|
20147
|
|
20148 @smallexample
|
|
20149 @group
|
|
20150 (length (number-to-string 35))
|
|
20151 @result{} 2
|
|
20152
|
|
20153 (length (number-to-string 100))
|
|
20154 @result{} 3
|
|
20155 @end group
|
|
20156 @end smallexample
|
|
20157
|
|
20158 @noindent
|
|
20159 (@code{number-to-string} is also called @code{int-to-string}; you will
|
|
20160 see this alternative name in various sources.)
|
|
20161
|
|
20162 In addition, in each label, each number is followed by a string such
|
|
20163 as @w{@samp{ - }}, which we will call the @code{Y-axis-tic} marker.
|
|
20164 This variable is defined with @code{defvar}:
|
|
20165
|
|
20166 @vindex Y-axis-tic
|
|
20167 @smallexample
|
|
20168 @group
|
|
20169 (defvar Y-axis-tic " - "
|
|
20170 "String that follows number in a Y axis label.")
|
|
20171 @end group
|
|
20172 @end smallexample
|
|
20173
|
|
20174 The length of the Y label is the sum of the length of the Y axis tic
|
|
20175 mark and the length of the number of the top of the graph.
|
|
20176
|
|
20177 @smallexample
|
|
20178 (length (concat (number-to-string height) Y-axis-tic)))
|
|
20179 @end smallexample
|
|
20180
|
|
20181 This value will be calculated by the @code{print-graph} function in
|
|
20182 its varlist as @code{full-Y-label-width} and passed on. (Note that we
|
|
20183 did not think to include this in the varlist when we first proposed it.)
|
|
20184
|
|
20185 To make a complete vertical axis label, a tic mark is concatenated
|
|
20186 with a number; and the two together may be preceded by one or more
|
|
20187 spaces depending on how long the number is. The label consists of
|
|
20188 three parts: the (optional) leading spaces, the number, and the tic
|
|
20189 mark. The function is passed the value of the number for the specific
|
|
20190 row, and the value of the width of the top line, which is calculated
|
|
20191 (just once) by @code{print-graph}.
|
|
20192
|
|
20193 @smallexample
|
|
20194 @group
|
|
20195 (defun Y-axis-element (number full-Y-label-width)
|
|
20196 "Construct a NUMBERed label element.
|
|
20197 A numbered element looks like this ` 5 - ',
|
|
20198 and is padded as needed so all line up with
|
|
20199 the element for the largest number."
|
|
20200 @end group
|
|
20201 @group
|
|
20202 (let* ((leading-spaces
|
|
20203 (- full-Y-label-width
|
|
20204 (length
|
|
20205 (concat (number-to-string number)
|
|
20206 Y-axis-tic)))))
|
|
20207 @end group
|
|
20208 @group
|
|
20209 (concat
|
|
20210 (make-string leading-spaces ? )
|
|
20211 (number-to-string number)
|
|
20212 Y-axis-tic)))
|
|
20213 @end group
|
|
20214 @end smallexample
|
|
20215
|
|
20216 The @code{Y-axis-element} function concatenates together the leading
|
|
20217 spaces, if any; the number, as a string; and the tic mark.
|
|
20218
|
|
20219 To figure out how many leading spaces the label will need, the
|
|
20220 function subtracts the actual length of the label---the length of the
|
|
20221 number plus the length of the tic mark---from the desired label width.
|
|
20222
|
|
20223 @findex make-string
|
|
20224 Blank spaces are inserted using the @code{make-string} function. This
|
|
20225 function takes two arguments: the first tells it how long the string
|
|
20226 will be and the second is a symbol for the character to insert, in a
|
|
20227 special format. The format is a question mark followed by a blank
|
|
20228 space, like this, @samp{? }. @xref{Character Type, , Character Type,
|
|
20229 elisp, The GNU Emacs Lisp Reference Manual}, for a description of the
|
|
20230 syntax for characters. (Of course, you might want to replace the
|
|
20231 blank space by some other character @dots{} You know what to do.)
|
|
20232
|
|
20233 The @code{number-to-string} function is used in the concatenation
|
|
20234 expression, to convert the number to a string that is concatenated
|
|
20235 with the leading spaces and the tic mark.
|
|
20236
|
|
20237 @node Y-axis-column, print-Y-axis Penultimate, Y Axis Element, print-Y-axis
|
|
20238 @appendixsubsec Create a Y Axis Column
|
|
20239
|
|
20240 The preceding functions provide all the tools needed to construct a
|
|
20241 function that generates a list of numbered and blank strings to insert
|
|
20242 as the label for the vertical axis:
|
|
20243
|
|
20244 @findex Y-axis-column
|
|
20245 @smallexample
|
|
20246 @group
|
|
20247 (defun Y-axis-column (height width-of-label)
|
|
20248 "Construct list of Y axis labels and blank strings.
|
|
20249 For HEIGHT of line above base and WIDTH-OF-LABEL."
|
|
20250 (let (Y-axis)
|
|
20251 @group
|
|
20252 @end group
|
|
20253 (while (> height 1)
|
|
20254 (if (zerop (% height Y-axis-label-spacing))
|
|
20255 ;; @r{Insert label.}
|
|
20256 (setq Y-axis
|
|
20257 (cons
|
|
20258 (Y-axis-element height width-of-label)
|
|
20259 Y-axis))
|
|
20260 @group
|
|
20261 @end group
|
|
20262 ;; @r{Else, insert blanks.}
|
|
20263 (setq Y-axis
|
|
20264 (cons
|
|
20265 (make-string width-of-label ? )
|
|
20266 Y-axis)))
|
|
20267 (setq height (1- height)))
|
|
20268 ;; @r{Insert base line.}
|
|
20269 (setq Y-axis
|
|
20270 (cons (Y-axis-element 1 width-of-label) Y-axis))
|
|
20271 (nreverse Y-axis)))
|
|
20272 @end group
|
|
20273 @end smallexample
|
|
20274
|
|
20275 In this function, we start with the value of @code{height} and
|
|
20276 repetitively subtract one from its value. After each subtraction, we
|
|
20277 test to see whether the value is an integral multiple of the
|
|
20278 @code{Y-axis-label-spacing}. If it is, we construct a numbered label
|
|
20279 using the @code{Y-axis-element} function; if not, we construct a
|
|
20280 blank label using the @code{make-string} function. The base line
|
|
20281 consists of the number one followed by a tic mark.
|
|
20282
|
|
20283 @need 2000
|
|
20284 @node print-Y-axis Penultimate, , Y-axis-column, print-Y-axis
|
|
20285 @appendixsubsec The Not Quite Final Version of @code{print-Y-axis}
|
|
20286
|
|
20287 The list constructed by the @code{Y-axis-column} function is passed to
|
|
20288 the @code{print-Y-axis} function, which inserts the list as a column.
|
|
20289
|
|
20290 @findex print-Y-axis
|
|
20291 @smallexample
|
|
20292 @group
|
|
20293 (defun print-Y-axis (height full-Y-label-width)
|
|
20294 "Insert Y axis using HEIGHT and FULL-Y-LABEL-WIDTH.
|
|
20295 Height must be the maximum height of the graph.
|
|
20296 Full width is the width of the highest label element."
|
|
20297 ;; Value of height and full-Y-label-width
|
|
20298 ;; are passed by `print-graph'.
|
|
20299 @end group
|
|
20300 @group
|
|
20301 (let ((start (point)))
|
|
20302 (insert-rectangle
|
|
20303 (Y-axis-column height full-Y-label-width))
|
|
20304 ;; @r{Place point ready for inserting graph.}
|
|
20305 (goto-char start)
|
|
20306 ;; @r{Move point forward by value of} full-Y-label-width
|
|
20307 (forward-char full-Y-label-width)))
|
|
20308 @end group
|
|
20309 @end smallexample
|
|
20310
|
|
20311 The @code{print-Y-axis} uses the @code{insert-rectangle} function to
|
|
20312 insert the Y axis labels created by the @code{Y-axis-column} function.
|
|
20313 In addition, it places point at the correct position for printing the body of
|
|
20314 the graph.
|
|
20315
|
|
20316 You can test @code{print-Y-axis}:
|
|
20317
|
|
20318 @enumerate
|
|
20319 @item
|
|
20320 Install
|
|
20321
|
|
20322 @smallexample
|
|
20323 @group
|
|
20324 Y-axis-label-spacing
|
|
20325 Y-axis-tic
|
|
20326 Y-axis-element
|
|
20327 Y-axis-column
|
|
20328 print-Y-axis
|
|
20329 @end group
|
|
20330 @end smallexample
|
|
20331
|
|
20332 @item
|
|
20333 Copy the following expression:
|
|
20334
|
|
20335 @smallexample
|
|
20336 (print-Y-axis 12 5)
|
|
20337 @end smallexample
|
|
20338
|
|
20339 @item
|
|
20340 Switch to the @file{*scratch*} buffer and place the cursor where you
|
|
20341 want the axis labels to start.
|
|
20342
|
|
20343 @item
|
|
20344 Type @kbd{M-:} (@code{eval-expression}).
|
|
20345
|
|
20346 @item
|
|
20347 Yank the @code{graph-body-print} expression into the minibuffer
|
|
20348 with @kbd{C-y} (@code{yank)}.
|
|
20349
|
|
20350 @item
|
|
20351 Press @key{RET} to evaluate the expression.
|
|
20352 @end enumerate
|
|
20353
|
|
20354 Emacs will print labels vertically, the top one being @w{@samp{10 -@w{
|
|
20355 }}}. (The @code{print-graph} function will pass the value of
|
|
20356 @code{height-of-top-line}, which in this case will end up as 15,
|
|
20357 thereby getting rid of what might appear as a bug.)
|
|
20358
|
|
20359 @need 2000
|
|
20360 @node print-X-axis, Print Whole Graph, print-Y-axis, Full Graph
|
|
20361 @appendixsec The @code{print-X-axis} Function
|
|
20362 @cindex Axis, print horizontal
|
|
20363 @cindex X axis printing
|
|
20364 @cindex Print horizontal axis
|
|
20365 @cindex Horizontal axis printing
|
|
20366
|
|
20367 X axis labels are much like Y axis labels, except that the ticks are on a
|
|
20368 line above the numbers. Labels should look like this:
|
|
20369
|
|
20370 @smallexample
|
|
20371 @group
|
|
20372 | | | |
|
|
20373 1 5 10 15
|
|
20374 @end group
|
|
20375 @end smallexample
|
|
20376
|
|
20377 The first tic is under the first column of the graph and is preceded by
|
|
20378 several blank spaces. These spaces provide room in rows above for the Y
|
|
20379 axis labels. The second, third, fourth, and subsequent ticks are all
|
|
20380 spaced equally, according to the value of @code{X-axis-label-spacing}.
|
|
20381
|
|
20382 The second row of the X axis consists of numbers, preceded by several
|
|
20383 blank spaces and also separated according to the value of the variable
|
|
20384 @code{X-axis-label-spacing}.
|
|
20385
|
|
20386 The value of the variable @code{X-axis-label-spacing} should itself be
|
|
20387 measured in units of @code{symbol-width}, since you may want to change
|
|
20388 the width of the symbols that you are using to print the body of the
|
|
20389 graph without changing the ways the graph is labelled.
|
|
20390
|
|
20391 @menu
|
|
20392 * Similarities differences:: Much like @code{print-Y-axis}, but not exactly.
|
|
20393 * X Axis Tic Marks:: Create tic marks for the horizontal axis.
|
|
20394 @end menu
|
|
20395
|
|
20396 @node Similarities differences, X Axis Tic Marks, print-X-axis, print-X-axis
|
|
20397 @ifnottex
|
|
20398 @unnumberedsubsec Similarities and differences
|
|
20399 @end ifnottex
|
|
20400
|
|
20401 The @code{print-X-axis} function is constructed in more or less the
|
|
20402 same fashion as the @code{print-Y-axis} function except that it has
|
|
20403 two lines: the line of tic marks and the numbers. We will write a
|
|
20404 separate function to print each line and then combine them within the
|
|
20405 @code{print-X-axis} function.
|
|
20406
|
|
20407 This is a three step process:
|
|
20408
|
|
20409 @enumerate
|
|
20410 @item
|
|
20411 Write a function to print the X axis tic marks, @code{print-X-axis-tic-line}.
|
|
20412
|
|
20413 @item
|
|
20414 Write a function to print the X numbers, @code{print-X-axis-numbered-line}.
|
|
20415
|
|
20416 @item
|
|
20417 Write a function to print both lines, the @code{print-X-axis} function,
|
|
20418 using @code{print-X-axis-tic-line} and
|
|
20419 @code{print-X-axis-numbered-line}.
|
|
20420 @end enumerate
|
|
20421
|
|
20422 @node X Axis Tic Marks, , Similarities differences, print-X-axis
|
|
20423 @appendixsubsec X Axis Tic Marks
|
|
20424
|
|
20425 The first function should print the X axis tic marks. We must specify
|
|
20426 the tic marks themselves and their spacing:
|
|
20427
|
|
20428 @smallexample
|
|
20429 @group
|
|
20430 (defvar X-axis-label-spacing
|
|
20431 (if (boundp 'graph-blank)
|
|
20432 (* 5 (length graph-blank)) 5)
|
|
20433 "Number of units from one X axis label to next.")
|
|
20434 @end group
|
|
20435 @end smallexample
|
|
20436
|
|
20437 @noindent
|
|
20438 (Note that the value of @code{graph-blank} is set by another
|
|
20439 @code{defvar}. The @code{boundp} predicate checks whether it has
|
|
20440 already been set; @code{boundp} returns @code{nil} if it has not. If
|
|
20441 @code{graph-blank} were unbound and we did not use this conditional
|
|
20442 construction, in a recent GNU Emacs, we would enter the debugger and
|
|
20443 see an error message saying @samp{@w{Debugger entered--Lisp error:}
|
|
20444 @w{(void-variable graph-blank)}}.)
|
|
20445
|
|
20446 @need 1200
|
|
20447 Here is the @code{defvar} for @code{X-axis-tic-symbol}:
|
|
20448
|
|
20449 @smallexample
|
|
20450 @group
|
|
20451 (defvar X-axis-tic-symbol "|"
|
|
20452 "String to insert to point to a column in X axis.")
|
|
20453 @end group
|
|
20454 @end smallexample
|
|
20455
|
|
20456 @need 1250
|
|
20457 The goal is to make a line that looks like this:
|
|
20458
|
|
20459 @smallexample
|
|
20460 | | | |
|
|
20461 @end smallexample
|
|
20462
|
|
20463 The first tic is indented so that it is under the first column, which is
|
|
20464 indented to provide space for the Y axis labels.
|
|
20465
|
|
20466 A tic element consists of the blank spaces that stretch from one tic to
|
|
20467 the next plus a tic symbol. The number of blanks is determined by the
|
|
20468 width of the tic symbol and the @code{X-axis-label-spacing}.
|
|
20469
|
|
20470 @need 1250
|
|
20471 The code looks like this:
|
|
20472
|
|
20473 @smallexample
|
|
20474 @group
|
|
20475 ;;; X-axis-tic-element
|
|
20476 @dots{}
|
|
20477 (concat
|
|
20478 (make-string
|
|
20479 ;; @r{Make a string of blanks.}
|
|
20480 (- (* symbol-width X-axis-label-spacing)
|
|
20481 (length X-axis-tic-symbol))
|
|
20482 ? )
|
|
20483 ;; @r{Concatenate blanks with tic symbol.}
|
|
20484 X-axis-tic-symbol)
|
|
20485 @dots{}
|
|
20486 @end group
|
|
20487 @end smallexample
|
|
20488
|
|
20489 Next, we determine how many blanks are needed to indent the first tic
|
|
20490 mark to the first column of the graph. This uses the value of
|
|
20491 @code{full-Y-label-width} passed it by the @code{print-graph} function.
|
|
20492
|
|
20493 @need 1250
|
|
20494 The code to make @code{X-axis-leading-spaces}
|
|
20495 looks like this:
|
|
20496
|
|
20497 @smallexample
|
|
20498 @group
|
|
20499 ;; X-axis-leading-spaces
|
|
20500 @dots{}
|
|
20501 (make-string full-Y-label-width ? )
|
|
20502 @dots{}
|
|
20503 @end group
|
|
20504 @end smallexample
|
|
20505
|
|
20506 We also need to determine the length of the horizontal axis, which is
|
|
20507 the length of the numbers list, and the number of ticks in the horizontal
|
|
20508 axis:
|
|
20509
|
|
20510 @smallexample
|
|
20511 @group
|
|
20512 ;; X-length
|
|
20513 @dots{}
|
|
20514 (length numbers-list)
|
|
20515 @end group
|
|
20516
|
|
20517 @group
|
|
20518 ;; tic-width
|
|
20519 @dots{}
|
|
20520 (* symbol-width X-axis-label-spacing)
|
|
20521 @end group
|
|
20522
|
|
20523 @group
|
|
20524 ;; number-of-X-ticks
|
|
20525 (if (zerop (% (X-length tic-width)))
|
|
20526 (/ (X-length tic-width))
|
|
20527 (1+ (/ (X-length tic-width))))
|
|
20528 @end group
|
|
20529 @end smallexample
|
|
20530
|
|
20531 @need 1250
|
|
20532 All this leads us directly to the function for printing the X axis tic line:
|
|
20533
|
|
20534 @findex print-X-axis-tic-line
|
|
20535 @smallexample
|
|
20536 @group
|
|
20537 (defun print-X-axis-tic-line
|
|
20538 (number-of-X-tics X-axis-leading-spaces X-axis-tic-element)
|
|
20539 "Print ticks for X axis."
|
|
20540 (insert X-axis-leading-spaces)
|
|
20541 (insert X-axis-tic-symbol) ; @r{Under first column.}
|
|
20542 @end group
|
|
20543 @group
|
|
20544 ;; @r{Insert second tic in the right spot.}
|
|
20545 (insert (concat
|
|
20546 (make-string
|
|
20547 (- (* symbol-width X-axis-label-spacing)
|
|
20548 ;; @r{Insert white space up to second tic symbol.}
|
|
20549 (* 2 (length X-axis-tic-symbol)))
|
|
20550 ? )
|
|
20551 X-axis-tic-symbol))
|
|
20552 @end group
|
|
20553 @group
|
|
20554 ;; @r{Insert remaining ticks.}
|
|
20555 (while (> number-of-X-tics 1)
|
|
20556 (insert X-axis-tic-element)
|
|
20557 (setq number-of-X-tics (1- number-of-X-tics))))
|
|
20558 @end group
|
|
20559 @end smallexample
|
|
20560
|
|
20561 The line of numbers is equally straightforward:
|
|
20562
|
|
20563 @need 1250
|
|
20564 First, we create a numbered element with blank spaces before each number:
|
|
20565
|
|
20566 @findex X-axis-element
|
|
20567 @smallexample
|
|
20568 @group
|
|
20569 (defun X-axis-element (number)
|
|
20570 "Construct a numbered X axis element."
|
|
20571 (let ((leading-spaces
|
|
20572 (- (* symbol-width X-axis-label-spacing)
|
|
20573 (length (number-to-string number)))))
|
|
20574 (concat (make-string leading-spaces ? )
|
|
20575 (number-to-string number))))
|
|
20576 @end group
|
|
20577 @end smallexample
|
|
20578
|
|
20579 Next, we create the function to print the numbered line, starting with
|
|
20580 the number ``1'' under the first column:
|
|
20581
|
|
20582 @findex print-X-axis-numbered-line
|
|
20583 @smallexample
|
|
20584 @group
|
|
20585 (defun print-X-axis-numbered-line
|
|
20586 (number-of-X-tics X-axis-leading-spaces)
|
|
20587 "Print line of X-axis numbers"
|
|
20588 (let ((number X-axis-label-spacing))
|
|
20589 (insert X-axis-leading-spaces)
|
|
20590 (insert "1")
|
|
20591 @end group
|
|
20592 @group
|
|
20593 (insert (concat
|
|
20594 (make-string
|
|
20595 ;; @r{Insert white space up to next number.}
|
|
20596 (- (* symbol-width X-axis-label-spacing) 2)
|
|
20597 ? )
|
|
20598 (number-to-string number)))
|
|
20599 @end group
|
|
20600 @group
|
|
20601 ;; @r{Insert remaining numbers.}
|
|
20602 (setq number (+ number X-axis-label-spacing))
|
|
20603 (while (> number-of-X-tics 1)
|
|
20604 (insert (X-axis-element number))
|
|
20605 (setq number (+ number X-axis-label-spacing))
|
|
20606 (setq number-of-X-tics (1- number-of-X-tics)))))
|
|
20607 @end group
|
|
20608 @end smallexample
|
|
20609
|
|
20610 Finally, we need to write the @code{print-X-axis} that uses
|
|
20611 @code{print-X-axis-tic-line} and
|
|
20612 @code{print-X-axis-numbered-line}.
|
|
20613
|
|
20614 The function must determine the local values of the variables used by both
|
|
20615 @code{print-X-axis-tic-line} and @code{print-X-axis-numbered-line}, and
|
|
20616 then it must call them. Also, it must print the carriage return that
|
|
20617 separates the two lines.
|
|
20618
|
|
20619 The function consists of a varlist that specifies five local variables,
|
|
20620 and calls to each of the two line printing functions:
|
|
20621
|
|
20622 @findex print-X-axis
|
|
20623 @smallexample
|
|
20624 @group
|
|
20625 (defun print-X-axis (numbers-list)
|
|
20626 "Print X axis labels to length of NUMBERS-LIST."
|
|
20627 (let* ((leading-spaces
|
|
20628 (make-string full-Y-label-width ? ))
|
|
20629 @end group
|
|
20630 @group
|
|
20631 ;; symbol-width @r{is provided by} graph-body-print
|
|
20632 (tic-width (* symbol-width X-axis-label-spacing))
|
|
20633 (X-length (length numbers-list))
|
|
20634 @end group
|
|
20635 @group
|
|
20636 (X-tic
|
|
20637 (concat
|
|
20638 (make-string
|
|
20639 @end group
|
|
20640 @group
|
|
20641 ;; @r{Make a string of blanks.}
|
|
20642 (- (* symbol-width X-axis-label-spacing)
|
|
20643 (length X-axis-tic-symbol))
|
|
20644 ? )
|
|
20645 @end group
|
|
20646 @group
|
|
20647 ;; @r{Concatenate blanks with tic symbol.}
|
|
20648 X-axis-tic-symbol))
|
|
20649 @end group
|
|
20650 @group
|
|
20651 (tic-number
|
|
20652 (if (zerop (% X-length tic-width))
|
|
20653 (/ X-length tic-width)
|
|
20654 (1+ (/ X-length tic-width)))))
|
|
20655 @end group
|
|
20656 @group
|
|
20657 (print-X-axis-tic-line tic-number leading-spaces X-tic)
|
|
20658 (insert "\n")
|
|
20659 (print-X-axis-numbered-line tic-number leading-spaces)))
|
|
20660 @end group
|
|
20661 @end smallexample
|
|
20662
|
|
20663 @need 1250
|
|
20664 You can test @code{print-X-axis}:
|
|
20665
|
|
20666 @enumerate
|
|
20667 @item
|
|
20668 Install @code{X-axis-tic-symbol}, @code{X-axis-label-spacing},
|
|
20669 @code{print-X-axis-tic-line}, as well as @code{X-axis-element},
|
|
20670 @code{print-X-axis-numbered-line}, and @code{print-X-axis}.
|
|
20671
|
|
20672 @item
|
|
20673 Copy the following expression:
|
|
20674
|
|
20675 @smallexample
|
|
20676 @group
|
|
20677 (progn
|
|
20678 (let ((full-Y-label-width 5)
|
|
20679 (symbol-width 1))
|
|
20680 (print-X-axis
|
|
20681 '(1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16))))
|
|
20682 @end group
|
|
20683 @end smallexample
|
|
20684
|
|
20685 @item
|
|
20686 Switch to the @file{*scratch*} buffer and place the cursor where you
|
|
20687 want the axis labels to start.
|
|
20688
|
|
20689 @item
|
|
20690 Type @kbd{M-:} (@code{eval-expression}).
|
|
20691
|
|
20692 @item
|
|
20693 Yank the test expression into the minibuffer
|
|
20694 with @kbd{C-y} (@code{yank)}.
|
|
20695
|
|
20696 @item
|
|
20697 Press @key{RET} to evaluate the expression.
|
|
20698 @end enumerate
|
|
20699
|
|
20700 @need 1250
|
|
20701 Emacs will print the horizontal axis like this:
|
|
20702 @sp 1
|
|
20703
|
|
20704 @smallexample
|
|
20705 @group
|
|
20706 | | | | |
|
|
20707 1 5 10 15 20
|
|
20708 @end group
|
|
20709 @end smallexample
|
|
20710
|
|
20711 @node Print Whole Graph, , print-X-axis, Full Graph
|
|
20712 @appendixsec Printing the Whole Graph
|
|
20713 @cindex Printing the whole graph
|
|
20714 @cindex Whole graph printing
|
|
20715 @cindex Graph, printing all
|
|
20716
|
|
20717 Now we are nearly ready to print the whole graph.
|
|
20718
|
|
20719 The function to print the graph with the proper labels follows the
|
|
20720 outline we created earlier (@pxref{Full Graph, , A Graph with Labelled
|
|
20721 Axes}), but with additions.
|
|
20722
|
|
20723 @need 1250
|
|
20724 Here is the outline:
|
|
20725
|
|
20726 @smallexample
|
|
20727 @group
|
|
20728 (defun print-graph (numbers-list)
|
|
20729 "@var{documentation}@dots{}"
|
|
20730 (let ((height @dots{}
|
|
20731 @dots{}))
|
|
20732 @end group
|
|
20733 @group
|
|
20734 (print-Y-axis height @dots{} )
|
|
20735 (graph-body-print numbers-list)
|
|
20736 (print-X-axis @dots{} )))
|
|
20737 @end group
|
|
20738 @end smallexample
|
|
20739
|
|
20740 @menu
|
|
20741 * The final version:: A few changes.
|
|
20742 * Test print-graph:: Run a short test.
|
|
20743 * Graphing words in defuns:: Executing the final code.
|
|
20744 * lambda:: How to write an anonymous function.
|
|
20745 * mapcar:: Apply a function to elements of a list.
|
|
20746 * Another Bug:: Yet another bug @dots{} most insidious.
|
|
20747 * Final printed graph:: The graph itself!
|
|
20748 @end menu
|
|
20749
|
|
20750 @node The final version, Test print-graph, Print Whole Graph, Print Whole Graph
|
|
20751 @ifnottex
|
|
20752 @unnumberedsubsec Changes for the Final Version
|
|
20753 @end ifnottex
|
|
20754
|
|
20755 The final version is different from what we planned in two ways:
|
|
20756 first, it contains additional values calculated once in the varlist;
|
|
20757 second, it carries an option to specify the labels' increment per row.
|
|
20758 This latter feature turns out to be essential; otherwise, a graph may
|
|
20759 have more rows than fit on a display or on a sheet of paper.
|
|
20760
|
|
20761 @need 1500
|
|
20762 This new feature requires a change to the @code{Y-axis-column}
|
|
20763 function, to add @code{vertical-step} to it. The function looks like
|
|
20764 this:
|
|
20765
|
|
20766 @findex Y-axis-column @r{Final version.}
|
|
20767 @smallexample
|
|
20768 @group
|
|
20769 ;;; @r{Final version.}
|
|
20770 (defun Y-axis-column
|
|
20771 (height width-of-label &optional vertical-step)
|
|
20772 "Construct list of labels for Y axis.
|
|
20773 HEIGHT is maximum height of graph.
|
|
20774 WIDTH-OF-LABEL is maximum width of label.
|
|
20775 VERTICAL-STEP, an option, is a positive integer
|
|
20776 that specifies how much a Y axis label increments
|
|
20777 for each line. For example, a step of 5 means
|
|
20778 that each line is five units of the graph."
|
|
20779 @end group
|
|
20780 @group
|
|
20781 (let (Y-axis
|
|
20782 (number-per-line (or vertical-step 1)))
|
|
20783 (while (> height 1)
|
|
20784 (if (zerop (% height Y-axis-label-spacing))
|
|
20785 @end group
|
|
20786 @group
|
|
20787 ;; @r{Insert label.}
|
|
20788 (setq Y-axis
|
|
20789 (cons
|
|
20790 (Y-axis-element
|
|
20791 (* height number-per-line)
|
|
20792 width-of-label)
|
|
20793 Y-axis))
|
|
20794 @end group
|
|
20795 @group
|
|
20796 ;; @r{Else, insert blanks.}
|
|
20797 (setq Y-axis
|
|
20798 (cons
|
|
20799 (make-string width-of-label ? )
|
|
20800 Y-axis)))
|
|
20801 (setq height (1- height)))
|
|
20802 @end group
|
|
20803 @group
|
|
20804 ;; @r{Insert base line.}
|
|
20805 (setq Y-axis (cons (Y-axis-element
|
|
20806 (or vertical-step 1)
|
|
20807 width-of-label)
|
|
20808 Y-axis))
|
|
20809 (nreverse Y-axis)))
|
|
20810 @end group
|
|
20811 @end smallexample
|
|
20812
|
|
20813 The values for the maximum height of graph and the width of a symbol
|
|
20814 are computed by @code{print-graph} in its @code{let} expression; so
|
|
20815 @code{graph-body-print} must be changed to accept them.
|
|
20816
|
|
20817 @findex graph-body-print @r{Final version.}
|
|
20818 @smallexample
|
|
20819 @group
|
|
20820 ;;; @r{Final version.}
|
|
20821 (defun graph-body-print (numbers-list height symbol-width)
|
|
20822 "Print a bar graph of the NUMBERS-LIST.
|
|
20823 The numbers-list consists of the Y-axis values.
|
|
20824 HEIGHT is maximum height of graph.
|
|
20825 SYMBOL-WIDTH is number of each column."
|
|
20826 @end group
|
|
20827 @group
|
|
20828 (let (from-position)
|
|
20829 (while numbers-list
|
|
20830 (setq from-position (point))
|
|
20831 (insert-rectangle
|
|
20832 (column-of-graph height (car numbers-list)))
|
|
20833 (goto-char from-position)
|
|
20834 (forward-char symbol-width)
|
|
20835 @end group
|
|
20836 @group
|
|
20837 ;; @r{Draw graph column by column.}
|
|
20838 (sit-for 0)
|
|
20839 (setq numbers-list (cdr numbers-list)))
|
|
20840 ;; @r{Place point for X axis labels.}
|
|
20841 (forward-line height)
|
|
20842 (insert "\n")))
|
|
20843 @end group
|
|
20844 @end smallexample
|
|
20845
|
|
20846 @need 1250
|
|
20847 Finally, the code for the @code{print-graph} function:
|
|
20848
|
|
20849 @findex print-graph @r{Final version.}
|
|
20850 @smallexample
|
|
20851 @group
|
|
20852 ;;; @r{Final version.}
|
|
20853 (defun print-graph
|
|
20854 (numbers-list &optional vertical-step)
|
|
20855 "Print labelled bar graph of the NUMBERS-LIST.
|
|
20856 The numbers-list consists of the Y-axis values.
|
|
20857 @end group
|
|
20858
|
|
20859 @group
|
|
20860 Optionally, VERTICAL-STEP, a positive integer,
|
|
20861 specifies how much a Y axis label increments for
|
|
20862 each line. For example, a step of 5 means that
|
|
20863 each row is five units."
|
|
20864 @end group
|
|
20865 @group
|
|
20866 (let* ((symbol-width (length graph-blank))
|
|
20867 ;; @code{height} @r{is both the largest number}
|
|
20868 ;; @r{and the number with the most digits.}
|
|
20869 (height (apply 'max numbers-list))
|
|
20870 @end group
|
|
20871 @group
|
|
20872 (height-of-top-line
|
|
20873 (if (zerop (% height Y-axis-label-spacing))
|
|
20874 height
|
|
20875 ;; @r{else}
|
|
20876 (* (1+ (/ height Y-axis-label-spacing))
|
|
20877 Y-axis-label-spacing)))
|
|
20878 @end group
|
|
20879 @group
|
|
20880 (vertical-step (or vertical-step 1))
|
|
20881 (full-Y-label-width
|
|
20882 (length
|
|
20883 @end group
|
|
20884 @group
|
|
20885 (concat
|
|
20886 (number-to-string
|
|
20887 (* height-of-top-line vertical-step))
|
|
20888 Y-axis-tic))))
|
|
20889 @end group
|
|
20890
|
|
20891 @group
|
|
20892 (print-Y-axis
|
|
20893 height-of-top-line full-Y-label-width vertical-step)
|
|
20894 @end group
|
|
20895 @group
|
|
20896 (graph-body-print
|
|
20897 numbers-list height-of-top-line symbol-width)
|
|
20898 (print-X-axis numbers-list)))
|
|
20899 @end group
|
|
20900 @end smallexample
|
|
20901
|
|
20902 @node Test print-graph, Graphing words in defuns, The final version, Print Whole Graph
|
|
20903 @appendixsubsec Testing @code{print-graph}
|
|
20904
|
|
20905 @need 1250
|
|
20906 We can test the @code{print-graph} function with a short list of numbers:
|
|
20907
|
|
20908 @enumerate
|
|
20909 @item
|
|
20910 Install the final versions of @code{Y-axis-column},
|
|
20911 @code{graph-body-print}, and @code{print-graph} (in addition to the
|
|
20912 rest of the code.)
|
|
20913
|
|
20914 @item
|
|
20915 Copy the following expression:
|
|
20916
|
|
20917 @smallexample
|
|
20918 (print-graph '(3 2 5 6 7 5 3 4 6 4 3 2 1))
|
|
20919 @end smallexample
|
|
20920
|
|
20921 @item
|
|
20922 Switch to the @file{*scratch*} buffer and place the cursor where you
|
|
20923 want the axis labels to start.
|
|
20924
|
|
20925 @item
|
|
20926 Type @kbd{M-:} (@code{eval-expression}).
|
|
20927
|
|
20928 @item
|
|
20929 Yank the test expression into the minibuffer
|
|
20930 with @kbd{C-y} (@code{yank)}.
|
|
20931
|
|
20932 @item
|
|
20933 Press @key{RET} to evaluate the expression.
|
|
20934 @end enumerate
|
|
20935
|
|
20936 @need 1250
|
|
20937 Emacs will print a graph that looks like this:
|
|
20938
|
|
20939 @smallexample
|
|
20940 @group
|
|
20941 10 -
|
|
20942
|
|
20943
|
|
20944 *
|
|
20945 ** *
|
|
20946 5 - **** *
|
|
20947 **** ***
|
|
20948 * *********
|
|
20949 ************
|
|
20950 1 - *************
|
|
20951
|
|
20952 | | | |
|
|
20953 1 5 10 15
|
|
20954 @end group
|
|
20955 @end smallexample
|
|
20956
|
|
20957 @need 1200
|
|
20958 On the other hand, if you pass @code{print-graph} a
|
|
20959 @code{vertical-step} value of 2, by evaluating this expression:
|
|
20960
|
|
20961 @smallexample
|
|
20962 (print-graph '(3 2 5 6 7 5 3 4 6 4 3 2 1) 2)
|
|
20963 @end smallexample
|
|
20964
|
|
20965 @need 1250
|
|
20966 @noindent
|
|
20967 The graph looks like this:
|
|
20968
|
|
20969 @smallexample
|
|
20970 @group
|
|
20971 20 -
|
|
20972
|
|
20973
|
|
20974 *
|
|
20975 ** *
|
|
20976 10 - **** *
|
|
20977 **** ***
|
|
20978 * *********
|
|
20979 ************
|
|
20980 2 - *************
|
|
20981
|
|
20982 | | | |
|
|
20983 1 5 10 15
|
|
20984 @end group
|
|
20985 @end smallexample
|
|
20986
|
|
20987 @noindent
|
|
20988 (A question: is the `2' on the bottom of the vertical axis a bug or a
|
|
20989 feature? If you think it is a bug, and should be a `1' instead, (or
|
|
20990 even a `0'), you can modify the sources.)
|
|
20991
|
|
20992 @node Graphing words in defuns, lambda, Test print-graph, Print Whole Graph
|
|
20993 @appendixsubsec Graphing Numbers of Words and Symbols
|
|
20994
|
|
20995 Now for the graph for which all this code was written: a graph that
|
|
20996 shows how many function definitions contain fewer than 10 words and
|
|
20997 symbols, how many contain between 10 and 19 words and symbols, how
|
|
20998 many contain between 20 and 29 words and symbols, and so on.
|
|
20999
|
|
21000 This is a multi-step process. First make sure you have loaded all the
|
|
21001 requisite code.
|
|
21002
|
|
21003 @need 1500
|
|
21004 It is a good idea to reset the value of @code{top-of-ranges} in case
|
|
21005 you have set it to some different value. You can evaluate the
|
|
21006 following:
|
|
21007
|
|
21008 @smallexample
|
|
21009 @group
|
|
21010 (setq top-of-ranges
|
|
21011 '(10 20 30 40 50
|
|
21012 60 70 80 90 100
|
|
21013 110 120 130 140 150
|
|
21014 160 170 180 190 200
|
|
21015 210 220 230 240 250
|
|
21016 260 270 280 290 300)
|
|
21017 @end group
|
|
21018 @end smallexample
|
|
21019
|
|
21020 @noindent
|
|
21021 Next create a list of the number of words and symbols in each range.
|
|
21022
|
|
21023 @need 1500
|
|
21024 @noindent
|
|
21025 Evaluate the following:
|
|
21026
|
|
21027 @smallexample
|
|
21028 @group
|
|
21029 (setq list-for-graph
|
|
21030 (defuns-per-range
|
|
21031 (sort
|
|
21032 (recursive-lengths-list-many-files
|
|
21033 (directory-files "/usr/local/emacs/lisp"
|
|
21034 t ".+el$"))
|
|
21035 '<)
|
|
21036 top-of-ranges))
|
|
21037 @end group
|
|
21038 @end smallexample
|
|
21039
|
|
21040 @noindent
|
|
21041 On my old machine, this took about an hour. It looked though 303 Lisp
|
|
21042 files in my copy of Emacs version 19.23. After all that computing,
|
|
21043 the @code{list-for-graph} had this value:
|
|
21044
|
|
21045 @smallexample
|
|
21046 @group
|
|
21047 (537 1027 955 785 594 483 349 292 224 199 166 120 116 99
|
|
21048 90 80 67 48 52 45 41 33 28 26 25 20 12 28 11 13 220)
|
|
21049 @end group
|
|
21050 @end smallexample
|
|
21051
|
|
21052 @noindent
|
|
21053 This means that my copy of Emacs had 537 function definitions with
|
|
21054 fewer than 10 words or symbols in them, 1,027 function definitions
|
|
21055 with 10 to 19 words or symbols in them, 955 function definitions with
|
|
21056 20 to 29 words or symbols in them, and so on.
|
|
21057
|
|
21058 Clearly, just by looking at this list we can see that most function
|
|
21059 definitions contain ten to thirty words and symbols.
|
|
21060
|
|
21061 Now for printing. We do @emph{not} want to print a graph that is
|
|
21062 1,030 lines high @dots{} Instead, we should print a graph that is
|
|
21063 fewer than twenty-five lines high. A graph that height can be
|
|
21064 displayed on almost any monitor, and easily printed on a sheet of paper.
|
|
21065
|
|
21066 This means that each value in @code{list-for-graph} must be reduced to
|
|
21067 one-fiftieth its present value.
|
|
21068
|
|
21069 Here is a short function to do just that, using two functions we have
|
|
21070 not yet seen, @code{mapcar} and @code{lambda}.
|
|
21071
|
|
21072 @smallexample
|
|
21073 @group
|
|
21074 (defun one-fiftieth (full-range)
|
|
21075 "Return list, each number one-fiftieth of previous."
|
|
21076 (mapcar '(lambda (arg) (/ arg 50)) full-range))
|
|
21077 @end group
|
|
21078 @end smallexample
|
|
21079
|
|
21080 @node lambda, mapcar, Graphing words in defuns, Print Whole Graph
|
|
21081 @appendixsubsec A @code{lambda} Expression: Useful Anonymity
|
|
21082 @cindex Anonymous function
|
|
21083 @findex lambda
|
|
21084
|
|
21085 @code{lambda} is the symbol for an anonymous function, a function
|
|
21086 without a name. Every time you use an anonymous function, you need to
|
|
21087 include its whole body.
|
|
21088
|
|
21089 @need 1250
|
|
21090 @noindent
|
|
21091 Thus,
|
|
21092
|
|
21093 @smallexample
|
|
21094 (lambda (arg) (/ arg 50))
|
|
21095 @end smallexample
|
|
21096
|
|
21097 @noindent
|
|
21098 is a function definition that says `return the value resulting from
|
|
21099 dividing whatever is passed to me as @code{arg} by 50'.
|
|
21100
|
|
21101 @need 1200
|
|
21102 Earlier, for example, we had a function @code{multiply-by-seven}; it
|
|
21103 multiplied its argument by 7. This function is similar, except it
|
|
21104 divides its argument by 50; and, it has no name. The anonymous
|
|
21105 equivalent of @code{multiply-by-seven} is:
|
|
21106
|
|
21107 @smallexample
|
|
21108 (lambda (number) (* 7 number))
|
|
21109 @end smallexample
|
|
21110
|
|
21111 @noindent
|
|
21112 (@xref{defun, , The @code{defun} Special Form}.)
|
|
21113
|
|
21114 @need 1250
|
|
21115 @noindent
|
|
21116 If we want to multiply 3 by 7, we can write:
|
|
21117
|
|
21118 @c !!! Clear print-postscript-figures if the computer formatting this
|
|
21119 @c document is too small and cannot handle all the diagrams and figures.
|
|
21120 @c clear print-postscript-figures
|
|
21121 @c set print-postscript-figures
|
|
21122 @c lambda example diagram #1
|
|
21123 @ifnottex
|
|
21124 @smallexample
|
|
21125 @group
|
|
21126 (multiply-by-seven 3)
|
|
21127 \_______________/ ^
|
|
21128 | |
|
|
21129 function argument
|
|
21130 @end group
|
|
21131 @end smallexample
|
|
21132 @end ifnottex
|
|
21133 @ifset print-postscript-figures
|
|
21134 @sp 1
|
|
21135 @tex
|
|
21136 @center @image{lambda-1}
|
|
21137 %%%% old method of including an image
|
|
21138 % \input /usr/local/lib/tex/inputs/psfig.tex
|
|
21139 % \centerline{\psfig{figure=/usr/local/lib/emacs/man/lambda-1.eps}}
|
|
21140 % \catcode`\@=0 %
|
|
21141 @end tex
|
|
21142 @sp 1
|
|
21143 @end ifset
|
|
21144 @ifclear print-postscript-figures
|
|
21145 @iftex
|
|
21146 @smallexample
|
|
21147 @group
|
|
21148 (multiply-by-seven 3)
|
|
21149 \_______________/ ^
|
|
21150 | |
|
|
21151 function argument
|
|
21152 @end group
|
|
21153 @end smallexample
|
|
21154 @end iftex
|
|
21155 @end ifclear
|
|
21156
|
|
21157 @noindent
|
|
21158 This expression returns 21.
|
|
21159
|
|
21160 @need 1250
|
|
21161 @noindent
|
|
21162 Similarly, we can write:
|
|
21163
|
|
21164 @c lambda example diagram #2
|
|
21165 @ifnottex
|
|
21166 @smallexample
|
|
21167 @group
|
|
21168 ((lambda (number) (* 7 number)) 3)
|
|
21169 \____________________________/ ^
|
|
21170 | |
|
|
21171 anonymous function argument
|
|
21172 @end group
|
|
21173 @end smallexample
|
|
21174 @end ifnottex
|
|
21175 @ifset print-postscript-figures
|
|
21176 @sp 1
|
|
21177 @tex
|
|
21178 @center @image{lambda-2}
|
|
21179 %%%% old method of including an image
|
|
21180 % \input /usr/local/lib/tex/inputs/psfig.tex
|
|
21181 % \centerline{\psfig{figure=/usr/local/lib/emacs/man/lambda-2.eps}}
|
|
21182 % \catcode`\@=0 %
|
|
21183 @end tex
|
|
21184 @sp 1
|
|
21185 @end ifset
|
|
21186 @ifclear print-postscript-figures
|
|
21187 @iftex
|
|
21188 @smallexample
|
|
21189 @group
|
|
21190 ((lambda (number) (* 7 number)) 3)
|
|
21191 \____________________________/ ^
|
|
21192 | |
|
|
21193 anonymous function argument
|
|
21194 @end group
|
|
21195 @end smallexample
|
|
21196 @end iftex
|
|
21197 @end ifclear
|
|
21198
|
|
21199 @need 1250
|
|
21200 @noindent
|
|
21201 If we want to divide 100 by 50, we can write:
|
|
21202
|
|
21203 @c lambda example diagram #3
|
|
21204 @ifnottex
|
|
21205 @smallexample
|
|
21206 @group
|
|
21207 ((lambda (arg) (/ arg 50)) 100)
|
|
21208 \______________________/ \_/
|
|
21209 | |
|
|
21210 anonymous function argument
|
|
21211 @end group
|
|
21212 @end smallexample
|
|
21213 @end ifnottex
|
|
21214 @ifset print-postscript-figures
|
|
21215 @sp 1
|
|
21216 @tex
|
|
21217 @center @image{lambda-3}
|
|
21218 %%%% old method of including an image
|
|
21219 % \input /usr/local/lib/tex/inputs/psfig.tex
|
|
21220 % \centerline{\psfig{figure=/usr/local/lib/emacs/man/lambda-3.eps}}
|
|
21221 % \catcode`\@=0 %
|
|
21222 @end tex
|
|
21223 @sp 1
|
|
21224 @end ifset
|
|
21225 @ifclear print-postscript-figures
|
|
21226 @iftex
|
|
21227 @smallexample
|
|
21228 @group
|
|
21229 ((lambda (arg) (/ arg 50)) 100)
|
|
21230 \______________________/ \_/
|
|
21231 | |
|
|
21232 anonymous function argument
|
|
21233 @end group
|
|
21234 @end smallexample
|
|
21235 @end iftex
|
|
21236 @end ifclear
|
|
21237
|
|
21238 @noindent
|
|
21239 This expression returns 2. The 100 is passed to the function, which
|
|
21240 divides that number by 50.
|
|
21241
|
|
21242 @xref{Lambda Expressions, , Lambda Expressions, elisp, The GNU Emacs
|
|
21243 Lisp Reference Manual}, for more about @code{lambda}. Lisp and lambda
|
|
21244 expressions derive from the Lambda Calculus.
|
|
21245
|
|
21246 @node mapcar, Another Bug, lambda, Print Whole Graph
|
|
21247 @appendixsubsec The @code{mapcar} Function
|
|
21248 @findex mapcar
|
|
21249
|
|
21250 @code{mapcar} is a function that calls its first argument with each
|
|
21251 element of its second argument, in turn. The second argument must be
|
|
21252 a sequence.
|
|
21253
|
|
21254 The @samp{map} part of the name comes from the mathematical phrase,
|
|
21255 `mapping over a domain', meaning to apply a function to each of the
|
|
21256 elements in a domain. The mathematical phrase is based on the
|
|
21257 metaphor of a surveyor walking, one step at a time, over an area he is
|
|
21258 mapping. And @samp{car}, of course, comes from the Lisp notion of the
|
|
21259 first of a list.
|
|
21260
|
|
21261 @need 1250
|
|
21262 @noindent
|
|
21263 For example,
|
|
21264
|
|
21265 @smallexample
|
|
21266 @group
|
|
21267 (mapcar '1+ '(2 4 6))
|
|
21268 @result{} (3 5 7)
|
|
21269 @end group
|
|
21270 @end smallexample
|
|
21271
|
|
21272 @noindent
|
|
21273 The function @code{1+} which adds one to its argument, is executed on
|
|
21274 @emph{each} element of the list, and a new list is returned.
|
|
21275
|
|
21276 Contrast this with @code{apply}, which applies its first argument to
|
|
21277 all the remaining.
|
|
21278 (@xref{Readying a Graph, , Readying a Graph}, for a explanation of
|
|
21279 @code{apply}.)
|
|
21280
|
|
21281 @need 1250
|
|
21282 In the definition of @code{one-fiftieth}, the first argument is the
|
|
21283 anonymous function:
|
|
21284
|
|
21285 @smallexample
|
|
21286 (lambda (arg) (/ arg 50))
|
|
21287 @end smallexample
|
|
21288
|
|
21289 @noindent
|
|
21290 and the second argument is @code{full-range}, which will be bound to
|
|
21291 @code{list-for-graph}.
|
|
21292
|
|
21293 @need 1250
|
|
21294 The whole expression looks like this:
|
|
21295
|
|
21296 @smallexample
|
|
21297 (mapcar '(lambda (arg) (/ arg 50)) full-range))
|
|
21298 @end smallexample
|
|
21299
|
|
21300 @xref{Mapping Functions, , Mapping Functions, elisp, The GNU Emacs
|
|
21301 Lisp Reference Manual}, for more about @code{mapcar}.
|
|
21302
|
|
21303 Using the @code{one-fiftieth} function, we can generate a list in
|
|
21304 which each element is one-fiftieth the size of the corresponding
|
|
21305 element in @code{list-for-graph}.
|
|
21306
|
|
21307 @smallexample
|
|
21308 @group
|
|
21309 (setq fiftieth-list-for-graph
|
|
21310 (one-fiftieth list-for-graph))
|
|
21311 @end group
|
|
21312 @end smallexample
|
|
21313
|
|
21314 @need 1250
|
|
21315 The resulting list looks like this:
|
|
21316
|
|
21317 @smallexample
|
|
21318 @group
|
|
21319 (10 20 19 15 11 9 6 5 4 3 3 2 2
|
|
21320 1 1 1 1 0 1 0 0 0 0 0 0 0 0 0 0 0 4)
|
|
21321 @end group
|
|
21322 @end smallexample
|
|
21323
|
|
21324 @noindent
|
|
21325 This, we are almost ready to print! (We also notice the loss of
|
|
21326 information: many of the higher ranges are 0, meaning that fewer than
|
|
21327 50 defuns had that many words or symbols---but not necessarily meaning
|
|
21328 that none had that many words or symbols.)
|
|
21329
|
|
21330 @node Another Bug, Final printed graph, mapcar, Print Whole Graph
|
|
21331 @appendixsubsec Another Bug @dots{} Most Insidious
|
|
21332 @cindex Bug, most insidious type
|
|
21333 @cindex Insidious type of bug
|
|
21334
|
|
21335 I said `almost ready to print'! Of course, there is a bug in the
|
|
21336 @code{print-graph} function @dots{} It has a @code{vertical-step}
|
|
21337 option, but not a @code{horizontal-step} option. The
|
|
21338 @code{top-of-range} scale goes from 10 to 300 by tens. But the
|
|
21339 @code{print-graph} function will print only by ones.
|
|
21340
|
|
21341 This is a classic example of what some consider the most insidious
|
|
21342 type of bug, the bug of omission. This is not the kind of bug you can
|
|
21343 find by studying the code, for it is not in the code; it is an omitted
|
|
21344 feature. Your best actions are to try your program early and often;
|
|
21345 and try to arrange, as much as you can, to write code that is easy to
|
|
21346 understand and easy to change. Try to be aware, whenever you can,
|
|
21347 that whatever you have written, @emph{will} be rewritten, if not soon,
|
|
21348 eventually. A hard maxim to follow.
|
|
21349
|
|
21350 It is the @code{print-X-axis-numbered-line} function that needs the
|
|
21351 work; and then the @code{print-X-axis} and the @code{print-graph}
|
|
21352 functions need to be adapted. Not much needs to be done; there is one
|
|
21353 nicety: the numbers ought to line up under the tic marks. This takes
|
|
21354 a little thought.
|
|
21355
|
|
21356 @need 1250
|
|
21357 Here is the corrected @code{print-X-axis-numbered-line}:
|
|
21358
|
|
21359 @smallexample
|
|
21360 @group
|
|
21361 (defun print-X-axis-numbered-line
|
|
21362 (number-of-X-tics X-axis-leading-spaces
|
|
21363 &optional horizontal-step)
|
|
21364 "Print line of X-axis numbers"
|
|
21365 (let ((number X-axis-label-spacing)
|
|
21366 (horizontal-step (or horizontal-step 1)))
|
|
21367 @end group
|
|
21368 @group
|
|
21369 (insert X-axis-leading-spaces)
|
|
21370 ;; @r{Delete extra leading spaces.}
|
|
21371 (delete-char
|
|
21372 (- (1-
|
|
21373 (length (number-to-string horizontal-step)))))
|
|
21374 (insert (concat
|
|
21375 (make-string
|
|
21376 @end group
|
|
21377 @group
|
|
21378 ;; @r{Insert white space.}
|
|
21379 (- (* symbol-width
|
|
21380 X-axis-label-spacing)
|
|
21381 (1-
|
|
21382 (length
|
|
21383 (number-to-string horizontal-step)))
|
|
21384 2)
|
|
21385 ? )
|
|
21386 (number-to-string
|
|
21387 (* number horizontal-step))))
|
|
21388 @end group
|
|
21389 @group
|
|
21390 ;; @r{Insert remaining numbers.}
|
|
21391 (setq number (+ number X-axis-label-spacing))
|
|
21392 (while (> number-of-X-tics 1)
|
|
21393 (insert (X-axis-element
|
|
21394 (* number horizontal-step)))
|
|
21395 (setq number (+ number X-axis-label-spacing))
|
|
21396 (setq number-of-X-tics (1- number-of-X-tics)))))
|
|
21397 @end group
|
|
21398 @end smallexample
|
|
21399
|
|
21400 @need 1500
|
|
21401 If you are reading this in Info, you can see the new versions of
|
|
21402 @code{print-X-axis} @code{print-graph} and evaluate them. If you are
|
|
21403 reading this in a printed book, you can see the changed lines here
|
|
21404 (the full text is too much to print).
|
|
21405
|
|
21406 @iftex
|
|
21407 @smallexample
|
|
21408 @group
|
|
21409 (defun print-X-axis (numbers-list horizontal-step)
|
|
21410 @dots{}
|
|
21411 (print-X-axis-numbered-line
|
|
21412 tic-number leading-spaces horizontal-step))
|
|
21413 @end group
|
|
21414 @end smallexample
|
|
21415
|
|
21416 @smallexample
|
|
21417 @group
|
|
21418 (defun print-graph
|
|
21419 (numbers-list
|
|
21420 &optional vertical-step horizontal-step)
|
|
21421 @dots{}
|
|
21422 (print-X-axis numbers-list horizontal-step))
|
|
21423 @end group
|
|
21424 @end smallexample
|
|
21425 @end iftex
|
|
21426
|
|
21427 @ifnottex
|
|
21428 @smallexample
|
|
21429 @group
|
|
21430 (defun print-X-axis (numbers-list horizontal-step)
|
|
21431 "Print X axis labels to length of NUMBERS-LIST.
|
|
21432 Optionally, HORIZONTAL-STEP, a positive integer,
|
|
21433 specifies how much an X axis label increments for
|
|
21434 each column."
|
|
21435 @end group
|
|
21436 @group
|
|
21437 ;; Value of symbol-width and full-Y-label-width
|
|
21438 ;; are passed by `print-graph'.
|
|
21439 (let* ((leading-spaces
|
|
21440 (make-string full-Y-label-width ? ))
|
|
21441 ;; symbol-width @r{is provided by} graph-body-print
|
|
21442 (tic-width (* symbol-width X-axis-label-spacing))
|
|
21443 (X-length (length numbers-list))
|
|
21444 @end group
|
|
21445 @group
|
|
21446 (X-tic
|
|
21447 (concat
|
|
21448 (make-string
|
|
21449 ;; @r{Make a string of blanks.}
|
|
21450 (- (* symbol-width X-axis-label-spacing)
|
|
21451 (length X-axis-tic-symbol))
|
|
21452 ? )
|
|
21453 @end group
|
|
21454 @group
|
|
21455 ;; @r{Concatenate blanks with tic symbol.}
|
|
21456 X-axis-tic-symbol))
|
|
21457 (tic-number
|
|
21458 (if (zerop (% X-length tic-width))
|
|
21459 (/ X-length tic-width)
|
|
21460 (1+ (/ X-length tic-width)))))
|
|
21461 @end group
|
|
21462
|
|
21463 @group
|
|
21464 (print-X-axis-tic-line
|
|
21465 tic-number leading-spaces X-tic)
|
|
21466 (insert "\n")
|
|
21467 (print-X-axis-numbered-line
|
|
21468 tic-number leading-spaces horizontal-step)))
|
|
21469 @end group
|
|
21470 @end smallexample
|
|
21471
|
|
21472 @smallexample
|
|
21473 @group
|
|
21474 (defun print-graph
|
|
21475 (numbers-list &optional vertical-step horizontal-step)
|
|
21476 "Print labelled bar graph of the NUMBERS-LIST.
|
|
21477 The numbers-list consists of the Y-axis values.
|
|
21478 @end group
|
|
21479
|
|
21480 @group
|
|
21481 Optionally, VERTICAL-STEP, a positive integer,
|
|
21482 specifies how much a Y axis label increments for
|
|
21483 each line. For example, a step of 5 means that
|
|
21484 each row is five units.
|
|
21485 @end group
|
|
21486
|
|
21487 @group
|
|
21488 Optionally, HORIZONTAL-STEP, a positive integer,
|
|
21489 specifies how much an X axis label increments for
|
|
21490 each column."
|
|
21491 (let* ((symbol-width (length graph-blank))
|
|
21492 ;; @code{height} @r{is both the largest number}
|
|
21493 ;; @r{and the number with the most digits.}
|
|
21494 (height (apply 'max numbers-list))
|
|
21495 @end group
|
|
21496 @group
|
|
21497 (height-of-top-line
|
|
21498 (if (zerop (% height Y-axis-label-spacing))
|
|
21499 height
|
|
21500 ;; @r{else}
|
|
21501 (* (1+ (/ height Y-axis-label-spacing))
|
|
21502 Y-axis-label-spacing)))
|
|
21503 @end group
|
|
21504 @group
|
|
21505 (vertical-step (or vertical-step 1))
|
|
21506 (full-Y-label-width
|
|
21507 (length
|
|
21508 (concat
|
|
21509 (number-to-string
|
|
21510 (* height-of-top-line vertical-step))
|
|
21511 Y-axis-tic))))
|
|
21512 @end group
|
|
21513 @group
|
|
21514 (print-Y-axis
|
|
21515 height-of-top-line full-Y-label-width vertical-step)
|
|
21516 (graph-body-print
|
|
21517 numbers-list height-of-top-line symbol-width)
|
|
21518 (print-X-axis numbers-list horizontal-step)))
|
|
21519 @end group
|
|
21520 @end smallexample
|
|
21521 @end ifnottex
|
|
21522
|
|
21523 @c qqq
|
|
21524 @ignore
|
|
21525 Graphing Definitions Re-listed
|
|
21526
|
|
21527 @need 1250
|
|
21528 Here are all the graphing definitions in their final form:
|
|
21529
|
|
21530 @smallexample
|
|
21531 @group
|
|
21532 (defvar top-of-ranges
|
|
21533 '(10 20 30 40 50
|
|
21534 60 70 80 90 100
|
|
21535 110 120 130 140 150
|
|
21536 160 170 180 190 200
|
|
21537 210 220 230 240 250)
|
|
21538 "List specifying ranges for `defuns-per-range'.")
|
|
21539 @end group
|
|
21540
|
|
21541 @group
|
|
21542 (defvar graph-symbol "*"
|
|
21543 "String used as symbol in graph, usually an asterisk.")
|
|
21544 @end group
|
|
21545
|
|
21546 @group
|
|
21547 (defvar graph-blank " "
|
|
21548 "String used as blank in graph, usually a blank space.
|
|
21549 graph-blank must be the same number of columns wide
|
|
21550 as graph-symbol.")
|
|
21551 @end group
|
|
21552
|
|
21553 @group
|
|
21554 (defvar Y-axis-tic " - "
|
|
21555 "String that follows number in a Y axis label.")
|
|
21556 @end group
|
|
21557
|
|
21558 @group
|
|
21559 (defvar Y-axis-label-spacing 5
|
|
21560 "Number of lines from one Y axis label to next.")
|
|
21561 @end group
|
|
21562
|
|
21563 @group
|
|
21564 (defvar X-axis-tic-symbol "|"
|
|
21565 "String to insert to point to a column in X axis.")
|
|
21566 @end group
|
|
21567
|
|
21568 @group
|
|
21569 (defvar X-axis-label-spacing
|
|
21570 (if (boundp 'graph-blank)
|
|
21571 (* 5 (length graph-blank)) 5)
|
|
21572 "Number of units from one X axis label to next.")
|
|
21573 @end group
|
|
21574 @end smallexample
|
|
21575
|
|
21576 @smallexample
|
|
21577 @group
|
|
21578 (defun count-words-in-defun ()
|
|
21579 "Return the number of words and symbols in a defun."
|
|
21580 (beginning-of-defun)
|
|
21581 (let ((count 0)
|
|
21582 (end (save-excursion (end-of-defun) (point))))
|
|
21583 @end group
|
|
21584
|
|
21585 @group
|
|
21586 (while
|
|
21587 (and (< (point) end)
|
|
21588 (re-search-forward
|
|
21589 "\\(\\w\\|\\s_\\)+[^ \t\n]*[ \t\n]*"
|
|
21590 end t))
|
|
21591 (setq count (1+ count)))
|
|
21592 count))
|
|
21593 @end group
|
|
21594 @end smallexample
|
|
21595
|
|
21596 @smallexample
|
|
21597 @group
|
|
21598 (defun lengths-list-file (filename)
|
|
21599 "Return list of definitions' lengths within FILE.
|
|
21600 The returned list is a list of numbers.
|
|
21601 Each number is the number of words or
|
|
21602 symbols in one function definition."
|
|
21603 @end group
|
|
21604
|
|
21605 @group
|
|
21606 (message "Working on `%s' ... " filename)
|
|
21607 (save-excursion
|
|
21608 (let ((buffer (find-file-noselect filename))
|
|
21609 (lengths-list))
|
|
21610 (set-buffer buffer)
|
|
21611 (setq buffer-read-only t)
|
|
21612 (widen)
|
|
21613 (goto-char (point-min))
|
|
21614 @end group
|
|
21615
|
|
21616 @group
|
|
21617 (while (re-search-forward "^(defun" nil t)
|
|
21618 (setq lengths-list
|
|
21619 (cons (count-words-in-defun) lengths-list)))
|
|
21620 (kill-buffer buffer)
|
|
21621 lengths-list)))
|
|
21622 @end group
|
|
21623 @end smallexample
|
|
21624
|
|
21625 @smallexample
|
|
21626 @group
|
|
21627 (defun lengths-list-many-files (list-of-files)
|
|
21628 "Return list of lengths of defuns in LIST-OF-FILES."
|
|
21629 (let (lengths-list)
|
|
21630 ;;; @r{true-or-false-test}
|
|
21631 (while list-of-files
|
|
21632 (setq lengths-list
|
|
21633 (append
|
|
21634 lengths-list
|
|
21635 @end group
|
|
21636 @group
|
|
21637 ;;; @r{Generate a lengths' list.}
|
|
21638 (lengths-list-file
|
|
21639 (expand-file-name (car list-of-files)))))
|
|
21640 ;;; @r{Make files' list shorter.}
|
|
21641 (setq list-of-files (cdr list-of-files)))
|
|
21642 ;;; @r{Return final value of lengths' list.}
|
|
21643 lengths-list))
|
|
21644 @end group
|
|
21645 @end smallexample
|
|
21646
|
|
21647 @smallexample
|
|
21648 @group
|
|
21649 (defun defuns-per-range (sorted-lengths top-of-ranges)
|
|
21650 "SORTED-LENGTHS defuns in each TOP-OF-RANGES range."
|
|
21651 (let ((top-of-range (car top-of-ranges))
|
|
21652 (number-within-range 0)
|
|
21653 defuns-per-range-list)
|
|
21654 @end group
|
|
21655
|
|
21656 @group
|
|
21657 ;; @r{Outer loop.}
|
|
21658 (while top-of-ranges
|
|
21659
|
|
21660 ;; @r{Inner loop.}
|
|
21661 (while (and
|
|
21662 ;; @r{Need number for numeric test.}
|
|
21663 (car sorted-lengths)
|
|
21664 (< (car sorted-lengths) top-of-range))
|
|
21665
|
|
21666 ;; @r{Count number of definitions within current range.}
|
|
21667 (setq number-within-range (1+ number-within-range))
|
|
21668 (setq sorted-lengths (cdr sorted-lengths)))
|
|
21669 @end group
|
|
21670
|
|
21671 @group
|
|
21672 ;; @r{Exit inner loop but remain within outer loop.}
|
|
21673
|
|
21674 (setq defuns-per-range-list
|
|
21675 (cons number-within-range defuns-per-range-list))
|
|
21676 (setq number-within-range 0) ; @r{Reset count to zero.}
|
|
21677
|
|
21678 ;; @r{Move to next range.}
|
|
21679 (setq top-of-ranges (cdr top-of-ranges))
|
|
21680 ;; @r{Specify next top of range value.}
|
|
21681 (setq top-of-range (car top-of-ranges)))
|
|
21682 @end group
|
|
21683
|
|
21684 @group
|
|
21685 ;; @r{Exit outer loop and count the number of defuns larger than}
|
|
21686 ;; @r{ the largest top-of-range value.}
|
|
21687 (setq defuns-per-range-list
|
|
21688 (cons
|
|
21689 (length sorted-lengths)
|
|
21690 defuns-per-range-list))
|
|
21691
|
|
21692 ;; @r{Return a list of the number of definitions within each range,}
|
|
21693 ;; @r{ smallest to largest.}
|
|
21694 (nreverse defuns-per-range-list)))
|
|
21695 @end group
|
|
21696 @end smallexample
|
|
21697
|
|
21698 @smallexample
|
|
21699 @group
|
|
21700 (defun column-of-graph (max-graph-height actual-height)
|
|
21701 "Return list of MAX-GRAPH-HEIGHT strings;
|
|
21702 ACTUAL-HEIGHT are graph-symbols.
|
|
21703 The graph-symbols are contiguous entries at the end
|
|
21704 of the list.
|
|
21705 The list will be inserted as one column of a graph.
|
|
21706 The strings are either graph-blank or graph-symbol."
|
|
21707 @end group
|
|
21708
|
|
21709 @group
|
|
21710 (let ((insert-list nil)
|
|
21711 (number-of-top-blanks
|
|
21712 (- max-graph-height actual-height)))
|
|
21713
|
|
21714 ;; @r{Fill in @code{graph-symbols}.}
|
|
21715 (while (> actual-height 0)
|
|
21716 (setq insert-list (cons graph-symbol insert-list))
|
|
21717 (setq actual-height (1- actual-height)))
|
|
21718 @end group
|
|
21719
|
|
21720 @group
|
|
21721 ;; @r{Fill in @code{graph-blanks}.}
|
|
21722 (while (> number-of-top-blanks 0)
|
|
21723 (setq insert-list (cons graph-blank insert-list))
|
|
21724 (setq number-of-top-blanks
|
|
21725 (1- number-of-top-blanks)))
|
|
21726
|
|
21727 ;; @r{Return whole list.}
|
|
21728 insert-list))
|
|
21729 @end group
|
|
21730 @end smallexample
|
|
21731
|
|
21732 @smallexample
|
|
21733 @group
|
|
21734 (defun Y-axis-element (number full-Y-label-width)
|
|
21735 "Construct a NUMBERed label element.
|
|
21736 A numbered element looks like this ` 5 - ',
|
|
21737 and is padded as needed so all line up with
|
|
21738 the element for the largest number."
|
|
21739 @end group
|
|
21740 @group
|
|
21741 (let* ((leading-spaces
|
|
21742 (- full-Y-label-width
|
|
21743 (length
|
|
21744 (concat (number-to-string number)
|
|
21745 Y-axis-tic)))))
|
|
21746 @end group
|
|
21747 @group
|
|
21748 (concat
|
|
21749 (make-string leading-spaces ? )
|
|
21750 (number-to-string number)
|
|
21751 Y-axis-tic)))
|
|
21752 @end group
|
|
21753 @end smallexample
|
|
21754
|
|
21755 @smallexample
|
|
21756 @group
|
|
21757 (defun print-Y-axis
|
|
21758 (height full-Y-label-width &optional vertical-step)
|
|
21759 "Insert Y axis by HEIGHT and FULL-Y-LABEL-WIDTH.
|
|
21760 Height must be the maximum height of the graph.
|
|
21761 Full width is the width of the highest label element.
|
|
21762 Optionally, print according to VERTICAL-STEP."
|
|
21763 @end group
|
|
21764 @group
|
|
21765 ;; Value of height and full-Y-label-width
|
|
21766 ;; are passed by `print-graph'.
|
|
21767 (let ((start (point)))
|
|
21768 (insert-rectangle
|
|
21769 (Y-axis-column height full-Y-label-width vertical-step))
|
|
21770 @end group
|
|
21771 @group
|
|
21772 ;; @r{Place point ready for inserting graph.}
|
|
21773 (goto-char start)
|
|
21774 ;; @r{Move point forward by value of} full-Y-label-width
|
|
21775 (forward-char full-Y-label-width)))
|
|
21776 @end group
|
|
21777 @end smallexample
|
|
21778
|
|
21779 @smallexample
|
|
21780 @group
|
|
21781 (defun print-X-axis-tic-line
|
|
21782 (number-of-X-tics X-axis-leading-spaces X-axis-tic-element)
|
|
21783 "Print ticks for X axis."
|
|
21784 (insert X-axis-leading-spaces)
|
|
21785 (insert X-axis-tic-symbol) ; @r{Under first column.}
|
|
21786 @end group
|
|
21787 @group
|
|
21788 ;; @r{Insert second tic in the right spot.}
|
|
21789 (insert (concat
|
|
21790 (make-string
|
|
21791 (- (* symbol-width X-axis-label-spacing)
|
|
21792 ;; @r{Insert white space up to second tic symbol.}
|
|
21793 (* 2 (length X-axis-tic-symbol)))
|
|
21794 ? )
|
|
21795 X-axis-tic-symbol))
|
|
21796 @end group
|
|
21797 @group
|
|
21798 ;; @r{Insert remaining ticks.}
|
|
21799 (while (> number-of-X-tics 1)
|
|
21800 (insert X-axis-tic-element)
|
|
21801 (setq number-of-X-tics (1- number-of-X-tics))))
|
|
21802 @end group
|
|
21803 @end smallexample
|
|
21804
|
|
21805 @smallexample
|
|
21806 @group
|
|
21807 (defun X-axis-element (number)
|
|
21808 "Construct a numbered X axis element."
|
|
21809 (let ((leading-spaces
|
|
21810 (- (* symbol-width X-axis-label-spacing)
|
|
21811 (length (number-to-string number)))))
|
|
21812 (concat (make-string leading-spaces ? )
|
|
21813 (number-to-string number))))
|
|
21814 @end group
|
|
21815 @end smallexample
|
|
21816
|
|
21817 @smallexample
|
|
21818 @group
|
|
21819 (defun graph-body-print (numbers-list height symbol-width)
|
|
21820 "Print a bar graph of the NUMBERS-LIST.
|
|
21821 The numbers-list consists of the Y-axis values.
|
|
21822 HEIGHT is maximum height of graph.
|
|
21823 SYMBOL-WIDTH is number of each column."
|
|
21824 @end group
|
|
21825 @group
|
|
21826 (let (from-position)
|
|
21827 (while numbers-list
|
|
21828 (setq from-position (point))
|
|
21829 (insert-rectangle
|
|
21830 (column-of-graph height (car numbers-list)))
|
|
21831 (goto-char from-position)
|
|
21832 (forward-char symbol-width)
|
|
21833 @end group
|
|
21834 @group
|
|
21835 ;; @r{Draw graph column by column.}
|
|
21836 (sit-for 0)
|
|
21837 (setq numbers-list (cdr numbers-list)))
|
|
21838 ;; @r{Place point for X axis labels.}
|
|
21839 (forward-line height)
|
|
21840 (insert "\n")))
|
|
21841 @end group
|
|
21842 @end smallexample
|
|
21843
|
|
21844 @smallexample
|
|
21845 @group
|
|
21846 (defun Y-axis-column
|
|
21847 (height width-of-label &optional vertical-step)
|
|
21848 "Construct list of labels for Y axis.
|
|
21849 HEIGHT is maximum height of graph.
|
|
21850 WIDTH-OF-LABEL is maximum width of label.
|
|
21851 @end group
|
|
21852 @group
|
|
21853 VERTICAL-STEP, an option, is a positive integer
|
|
21854 that specifies how much a Y axis label increments
|
|
21855 for each line. For example, a step of 5 means
|
|
21856 that each line is five units of the graph."
|
|
21857 (let (Y-axis
|
|
21858 (number-per-line (or vertical-step 1)))
|
|
21859 @end group
|
|
21860 @group
|
|
21861 (while (> height 1)
|
|
21862 (if (zerop (% height Y-axis-label-spacing))
|
|
21863 ;; @r{Insert label.}
|
|
21864 (setq Y-axis
|
|
21865 (cons
|
|
21866 (Y-axis-element
|
|
21867 (* height number-per-line)
|
|
21868 width-of-label)
|
|
21869 Y-axis))
|
|
21870 @end group
|
|
21871 @group
|
|
21872 ;; @r{Else, insert blanks.}
|
|
21873 (setq Y-axis
|
|
21874 (cons
|
|
21875 (make-string width-of-label ? )
|
|
21876 Y-axis)))
|
|
21877 (setq height (1- height)))
|
|
21878 @end group
|
|
21879 @group
|
|
21880 ;; @r{Insert base line.}
|
|
21881 (setq Y-axis (cons (Y-axis-element
|
|
21882 (or vertical-step 1)
|
|
21883 width-of-label)
|
|
21884 Y-axis))
|
|
21885 (nreverse Y-axis)))
|
|
21886 @end group
|
|
21887 @end smallexample
|
|
21888
|
|
21889 @smallexample
|
|
21890 @group
|
|
21891 (defun print-X-axis-numbered-line
|
|
21892 (number-of-X-tics X-axis-leading-spaces
|
|
21893 &optional horizontal-step)
|
|
21894 "Print line of X-axis numbers"
|
|
21895 (let ((number X-axis-label-spacing)
|
|
21896 (horizontal-step (or horizontal-step 1)))
|
|
21897 @end group
|
|
21898 @group
|
|
21899 (insert X-axis-leading-spaces)
|
|
21900 ;; line up number
|
|
21901 (delete-char (- (1- (length (number-to-string horizontal-step)))))
|
|
21902 (insert (concat
|
|
21903 (make-string
|
|
21904 ;; @r{Insert white space up to next number.}
|
|
21905 (- (* symbol-width X-axis-label-spacing)
|
|
21906 (1- (length (number-to-string horizontal-step)))
|
|
21907 2)
|
|
21908 ? )
|
|
21909 (number-to-string (* number horizontal-step))))
|
|
21910 @end group
|
|
21911 @group
|
|
21912 ;; @r{Insert remaining numbers.}
|
|
21913 (setq number (+ number X-axis-label-spacing))
|
|
21914 (while (> number-of-X-tics 1)
|
|
21915 (insert (X-axis-element (* number horizontal-step)))
|
|
21916 (setq number (+ number X-axis-label-spacing))
|
|
21917 (setq number-of-X-tics (1- number-of-X-tics)))))
|
|
21918 @end group
|
|
21919 @end smallexample
|
|
21920
|
|
21921 @smallexample
|
|
21922 @group
|
|
21923 (defun print-X-axis (numbers-list horizontal-step)
|
|
21924 "Print X axis labels to length of NUMBERS-LIST.
|
|
21925 Optionally, HORIZONTAL-STEP, a positive integer,
|
|
21926 specifies how much an X axis label increments for
|
|
21927 each column."
|
|
21928 @end group
|
|
21929 @group
|
|
21930 ;; Value of symbol-width and full-Y-label-width
|
|
21931 ;; are passed by `print-graph'.
|
|
21932 (let* ((leading-spaces
|
|
21933 (make-string full-Y-label-width ? ))
|
|
21934 ;; symbol-width @r{is provided by} graph-body-print
|
|
21935 (tic-width (* symbol-width X-axis-label-spacing))
|
|
21936 (X-length (length numbers-list))
|
|
21937 @end group
|
|
21938 @group
|
|
21939 (X-tic
|
|
21940 (concat
|
|
21941 (make-string
|
|
21942 ;; @r{Make a string of blanks.}
|
|
21943 (- (* symbol-width X-axis-label-spacing)
|
|
21944 (length X-axis-tic-symbol))
|
|
21945 ? )
|
|
21946 @end group
|
|
21947 @group
|
|
21948 ;; @r{Concatenate blanks with tic symbol.}
|
|
21949 X-axis-tic-symbol))
|
|
21950 (tic-number
|
|
21951 (if (zerop (% X-length tic-width))
|
|
21952 (/ X-length tic-width)
|
|
21953 (1+ (/ X-length tic-width)))))
|
|
21954 @end group
|
|
21955
|
|
21956 @group
|
|
21957 (print-X-axis-tic-line
|
|
21958 tic-number leading-spaces X-tic)
|
|
21959 (insert "\n")
|
|
21960 (print-X-axis-numbered-line
|
|
21961 tic-number leading-spaces horizontal-step)))
|
|
21962 @end group
|
|
21963 @end smallexample
|
|
21964
|
|
21965 @smallexample
|
|
21966 @group
|
|
21967 (defun one-fiftieth (full-range)
|
|
21968 "Return list, each number of which is 1/50th previous."
|
|
21969 (mapcar '(lambda (arg) (/ arg 50)) full-range))
|
|
21970 @end group
|
|
21971 @end smallexample
|
|
21972
|
|
21973 @smallexample
|
|
21974 @group
|
|
21975 (defun print-graph
|
|
21976 (numbers-list &optional vertical-step horizontal-step)
|
|
21977 "Print labelled bar graph of the NUMBERS-LIST.
|
|
21978 The numbers-list consists of the Y-axis values.
|
|
21979 @end group
|
|
21980
|
|
21981 @group
|
|
21982 Optionally, VERTICAL-STEP, a positive integer,
|
|
21983 specifies how much a Y axis label increments for
|
|
21984 each line. For example, a step of 5 means that
|
|
21985 each row is five units.
|
|
21986 @end group
|
|
21987
|
|
21988 @group
|
|
21989 Optionally, HORIZONTAL-STEP, a positive integer,
|
|
21990 specifies how much an X axis label increments for
|
|
21991 each column."
|
|
21992 (let* ((symbol-width (length graph-blank))
|
|
21993 ;; @code{height} @r{is both the largest number}
|
|
21994 ;; @r{and the number with the most digits.}
|
|
21995 (height (apply 'max numbers-list))
|
|
21996 @end group
|
|
21997 @group
|
|
21998 (height-of-top-line
|
|
21999 (if (zerop (% height Y-axis-label-spacing))
|
|
22000 height
|
|
22001 ;; @r{else}
|
|
22002 (* (1+ (/ height Y-axis-label-spacing))
|
|
22003 Y-axis-label-spacing)))
|
|
22004 @end group
|
|
22005 @group
|
|
22006 (vertical-step (or vertical-step 1))
|
|
22007 (full-Y-label-width
|
|
22008 (length
|
|
22009 (concat
|
|
22010 (number-to-string
|
|
22011 (* height-of-top-line vertical-step))
|
|
22012 Y-axis-tic))))
|
|
22013 @end group
|
|
22014 @group
|
|
22015
|
|
22016 (print-Y-axis
|
|
22017 height-of-top-line full-Y-label-width vertical-step)
|
|
22018 (graph-body-print
|
|
22019 numbers-list height-of-top-line symbol-width)
|
|
22020 (print-X-axis numbers-list horizontal-step)))
|
|
22021 @end group
|
|
22022 @end smallexample
|
|
22023 @c qqq
|
|
22024 @end ignore
|
|
22025
|
|
22026 @page
|
|
22027 @node Final printed graph, , Another Bug, Print Whole Graph
|
|
22028 @appendixsubsec The Printed Graph
|
|
22029
|
|
22030 When made and installed, you can call the @code{print-graph} command
|
|
22031 like this:
|
|
22032 @sp 1
|
|
22033
|
|
22034 @smallexample
|
|
22035 @group
|
|
22036 (print-graph fiftieth-list-for-graph 50 10)
|
|
22037 @end group
|
|
22038 @end smallexample
|
|
22039 @sp 1
|
|
22040
|
|
22041 @noindent
|
|
22042 Here is the graph:
|
|
22043 @sp 2
|
|
22044
|
|
22045 @smallexample
|
|
22046 @group
|
|
22047 1000 - *
|
|
22048 **
|
|
22049 **
|
|
22050 **
|
|
22051 **
|
|
22052 750 - ***
|
|
22053 ***
|
|
22054 ***
|
|
22055 ***
|
|
22056 ****
|
|
22057 500 - *****
|
|
22058 ******
|
|
22059 ******
|
|
22060 ******
|
|
22061 *******
|
|
22062 250 - ********
|
|
22063 ********* *
|
|
22064 *********** *
|
|
22065 ************* *
|
|
22066 50 - ***************** * *
|
|
22067 | | | | | | | |
|
|
22068 10 50 100 150 200 250 300 350
|
|
22069 @end group
|
|
22070 @end smallexample
|
|
22071
|
|
22072 @sp 2
|
|
22073
|
|
22074 @noindent
|
|
22075 The largest group of functions contain 10 -- 19 words and symbols each.
|
|
22076
|
|
22077 @node Free Software and Free Manuals, GNU Free Documentation License, Full Graph, Top
|
|
22078 @appendix Free Software and Free Manuals
|
|
22079
|
|
22080 @strong{by Richard M. Stallman}
|
|
22081 @sp 1
|
|
22082
|
|
22083 The biggest deficiency in free operating systems is not in the
|
|
22084 software---it is the lack of good free manuals that we can include in
|
|
22085 these systems. Many of our most important programs do not come with
|
|
22086 full manuals. Documentation is an essential part of any software
|
|
22087 package; when an important free software package does not come with a
|
|
22088 free manual, that is a major gap. We have many such gaps today.
|
|
22089
|
|
22090 Once upon a time, many years ago, I thought I would learn Perl. I got
|
|
22091 a copy of a free manual, but I found it hard to read. When I asked
|
|
22092 Perl users about alternatives, they told me that there were better
|
|
22093 introductory manuals---but those were not free.
|
|
22094
|
|
22095 Why was this? The authors of the good manuals had written them for
|
|
22096 O'Reilly Associates, which published them with restrictive terms---no
|
|
22097 copying, no modification, source files not available---which exclude
|
|
22098 them from the free software community.
|
|
22099
|
|
22100 That wasn't the first time this sort of thing has happened, and (to
|
|
22101 our community's great loss) it was far from the last. Proprietary
|
|
22102 manual publishers have enticed a great many authors to restrict their
|
|
22103 manuals since then. Many times I have heard a GNU user eagerly tell me
|
|
22104 about a manual that he is writing, with which he expects to help the
|
|
22105 GNU project---and then had my hopes dashed, as he proceeded to explain
|
|
22106 that he had signed a contract with a publisher that would restrict it
|
|
22107 so that we cannot use it.
|
|
22108
|
|
22109 Given that writing good English is a rare skill among programmers, we
|
|
22110 can ill afford to lose manuals this way.
|
|
22111
|
|
22112 Free documentation, like free software, is a matter of freedom, not
|
|
22113 price. The problem with these manuals was not that O'Reilly Associates
|
106382
2ae01aa75e84
(Free Software and Free Manuals): Update URL, and remove duplicate text.
Glenn Morris <rgm@gnu.org>
diff
changeset
|
22114 charged a price for printed copies---that in itself is fine. The Free
|
2ae01aa75e84
(Free Software and Free Manuals): Update URL, and remove duplicate text.
Glenn Morris <rgm@gnu.org>
diff
changeset
|
22115 Software Foundation @uref{http://shop.fsf.org, sells printed copies} of
|
2ae01aa75e84
(Free Software and Free Manuals): Update URL, and remove duplicate text.
Glenn Morris <rgm@gnu.org>
diff
changeset
|
22116 free @uref{http://www.gnu.org/doc/doc.html, GNU manuals}, too.
|
83955
|
22117 But GNU manuals are available in source code form, while these manuals
|
|
22118 are available only on paper. GNU manuals come with permission to copy
|
|
22119 and modify; the Perl manuals do not. These restrictions are the
|
|
22120 problems.
|
|
22121
|
|
22122 The criterion for a free manual is pretty much the same as for free
|
|
22123 software: it is a matter of giving all users certain
|
|
22124 freedoms. Redistribution (including commercial redistribution) must be
|
|
22125 permitted, so that the manual can accompany every copy of the program,
|
|
22126 on-line or on paper. Permission for modification is crucial too.
|
|
22127
|
|
22128 As a general rule, I don't believe that it is essential for people to
|
|
22129 have permission to modify all sorts of articles and books. The issues
|
|
22130 for writings are not necessarily the same as those for software. For
|
|
22131 example, I don't think you or I are obliged to give permission to
|
|
22132 modify articles like this one, which describe our actions and our
|
|
22133 views.
|
|
22134
|
|
22135 But there is a particular reason why the freedom to modify is crucial
|
|
22136 for documentation for free software. When people exercise their right
|
|
22137 to modify the software, and add or change its features, if they are
|
|
22138 conscientious they will change the manual too---so they can provide
|
|
22139 accurate and usable documentation with the modified program. A manual
|
|
22140 which forbids programmers to be conscientious and finish the job, or
|
|
22141 more precisely requires them to write a new manual from scratch if
|
|
22142 they change the program, does not fill our community's needs.
|
|
22143
|
|
22144 While a blanket prohibition on modification is unacceptable, some
|
|
22145 kinds of limits on the method of modification pose no problem. For
|
|
22146 example, requirements to preserve the original author's copyright
|
|
22147 notice, the distribution terms, or the list of authors, are ok. It is
|
|
22148 also no problem to require modified versions to include notice that
|
|
22149 they were modified, even to have entire sections that may not be
|
|
22150 deleted or changed, as long as these sections deal with nontechnical
|
|
22151 topics. (Some GNU manuals have them.)
|
|
22152
|
|
22153 These kinds of restrictions are not a problem because, as a practical
|
|
22154 matter, they don't stop the conscientious programmer from adapting the
|
|
22155 manual to fit the modified program. In other words, they don't block
|
|
22156 the free software community from making full use of the manual.
|
|
22157
|
|
22158 However, it must be possible to modify all the technical content of
|
|
22159 the manual, and then distribute the result in all the usual media,
|
|
22160 through all the usual channels; otherwise, the restrictions do block
|
|
22161 the community, the manual is not free, and so we need another manual.
|
|
22162
|
|
22163 Unfortunately, it is often hard to find someone to write another
|
|
22164 manual when a proprietary manual exists. The obstacle is that many
|
|
22165 users think that a proprietary manual is good enough---so they don't
|
|
22166 see the need to write a free manual. They do not see that the free
|
|
22167 operating system has a gap that needs filling.
|
|
22168
|
|
22169 Why do users think that proprietary manuals are good enough? Some have
|
|
22170 not considered the issue. I hope this article will do something to
|
|
22171 change that.
|
|
22172
|
|
22173 Other users consider proprietary manuals acceptable for the same
|
|
22174 reason so many people consider proprietary software acceptable: they
|
|
22175 judge in purely practical terms, not using freedom as a
|
|
22176 criterion. These people are entitled to their opinions, but since
|
|
22177 those opinions spring from values which do not include freedom, they
|
|
22178 are no guide for those of us who do value freedom.
|
|
22179
|
|
22180 Please spread the word about this issue. We continue to lose manuals
|
|
22181 to proprietary publishing. If we spread the word that proprietary
|
|
22182 manuals are not sufficient, perhaps the next person who wants to help
|
|
22183 GNU by writing documentation will realize, before it is too late, that
|
|
22184 he must above all make it free.
|
|
22185
|
|
22186 We can also encourage commercial publishers to sell free, copylefted
|
|
22187 manuals instead of proprietary ones. One way you can help this is to
|
|
22188 check the distribution terms of a manual before you buy it, and prefer
|
|
22189 copylefted manuals to non-copylefted ones.
|
|
22190
|
|
22191 @sp 2
|
|
22192 @noindent
|
|
22193 Note: The Free Software Foundation maintains a page on its Web site
|
|
22194 that lists free books available from other publishers:@*
|
|
22195 @uref{http://www.gnu.org/doc/other-free-books.html}
|
|
22196
|
|
22197 @node GNU Free Documentation License, Index, Free Software and Free Manuals, Top
|
|
22198 @appendix GNU Free Documentation License
|
|
22199
|
|
22200 @cindex FDL, GNU Free Documentation License
|
99703
|
22201 @include doclicense.texi
|
83955
|
22202
|
|
22203 @node Index, About the Author, GNU Free Documentation License, Top
|
|
22204 @comment node-name, next, previous, up
|
|
22205 @unnumbered Index
|
|
22206
|
|
22207 @ignore
|
|
22208 MENU ENTRY: NODE NAME.
|
|
22209 @end ignore
|
|
22210
|
|
22211 @printindex cp
|
|
22212
|
|
22213 @iftex
|
|
22214 @c Place biographical information on right-hand (verso) page
|
|
22215
|
|
22216 @tex
|
98525
|
22217 \par\vfill\supereject
|
83955
|
22218 \ifodd\pageno
|
|
22219 \global\evenheadline={\hfil} \global\evenfootline={\hfil}
|
|
22220 \global\oddheadline={\hfil} \global\oddfootline={\hfil}
|
98525
|
22221 %\page\hbox{}\page
|
83955
|
22222 \else
|
98525
|
22223 % \par\vfill\supereject
|
83955
|
22224 \global\evenheadline={\hfil} \global\evenfootline={\hfil}
|
|
22225 \global\oddheadline={\hfil} \global\oddfootline={\hfil}
|
98525
|
22226 %\page\hbox{}%\page
|
|
22227 %\page\hbox{}%\page
|
83955
|
22228 \fi
|
|
22229 @end tex
|
|
22230
|
98525
|
22231 @c page
|
83955
|
22232 @w{ }
|
|
22233
|
|
22234 @c ================ Biographical information ================
|
|
22235
|
|
22236 @w{ }
|
|
22237 @sp 8
|
|
22238 @center About the Author
|
|
22239 @sp 1
|
|
22240 @end iftex
|
|
22241
|
|
22242 @ifnottex
|
|
22243 @node About the Author, , Index, Top
|
|
22244 @unnumbered About the Author
|
|
22245 @end ifnottex
|
|
22246
|
|
22247 @quotation
|
|
22248 Robert J. Chassell has worked with GNU Emacs since 1985. He writes
|
|
22249 and edits, teaches Emacs and Emacs Lisp, and speaks throughout the
|
|
22250 world on software freedom. Chassell was a founding Director and
|
|
22251 Treasurer of the Free Software Foundation, Inc. He is co-author of
|
|
22252 the @cite{Texinfo} manual, and has edited more than a dozen other
|
|
22253 books. He graduated from Cambridge University, in England. He has an
|
|
22254 abiding interest in social and economic history and flies his own
|
|
22255 airplane.
|
|
22256 @end quotation
|
|
22257
|
98525
|
22258 @c @page
|
|
22259 @c @w{ }
|
|
22260 @c
|
|
22261 @c @c Prevent page number on blank verso, so eject it first.
|
|
22262 @c @tex
|
|
22263 @c \par\vfill\supereject
|
|
22264 @c @end tex
|
|
22265
|
|
22266 @c @iftex
|
|
22267 @c @headings off
|
|
22268 @c @evenheading @thispage @| @| @thistitle
|
|
22269 @c @oddheading @| @| @thispage
|
|
22270 @c @end iftex
|
83955
|
22271
|
|
22272 @bye
|
|
22273
|
|
22274 @ignore
|
|
22275 arch-tag: da1a2154-531f-43a8-8e33-fc7faad10acf
|
|
22276 @end ignore
|