--- /dev/null
+This is ../info/eintr, produced by makeinfo version 4.8 from
+emacs-lisp-intro.texi.
+
+INFO-DIR-SECTION Emacs
+START-INFO-DIR-ENTRY
+* Emacs Lisp Intro: (eintr).
+ A simple introduction to Emacs Lisp programming.
+END-INFO-DIR-ENTRY
+
+This is an `Introduction to Programming in Emacs Lisp', for people who
+are not programmers.
+
+Edition 3.00, 2006 Oct 31
+
+Copyright (C) 1990, 1991, 1992, 1993, 1994, 1995, 1997, 2001, 2002,
+2003, 2004, 2005, 2006 Free Software Foundation, Inc.
+
+Published by the:
+
+ GNU Press, Website: http://www.gnupress.org
+ a division of the General: press@gnu.org
+ Free Software Foundation, Inc. Orders: sales@gnu.org
+ 51 Franklin Street, Fifth Floor Tel: +1 (617) 542-5942
+ Boston, MA 02110-1301 USA Fax: +1 (617) 542-2652
+
+
+ISBN 1-882114-43-4
+
+Permission is granted to copy, distribute and/or modify this document
+under the terms of the GNU Free Documentation License, Version 1.2 or
+any later version published by the Free Software Foundation; there
+being no Invariant Section, with the Front-Cover Texts being "A GNU
+Manual", and with the Back-Cover Texts as in (a) below. A copy of the
+license is included in the section entitled "GNU Free Documentation
+License".
+
+(a) The FSF's Back-Cover Text is: "You have freedom to copy and modify
+this GNU Manual, like GNU software. Copies published by the Free
+Software Foundation raise funds for GNU development."
+
+\1f
+File: eintr, Node: Understanding current-kill, Prev: current-kill, Up: current-kill
+
+`current-kill' in Outline
+-------------------------
+
+The `current-kill' function looks complex, but as usual, it can be
+understood by taking it apart piece by piece. First look at it in
+skeletal form:
+
+ (defun current-kill (n &optional do-not-move)
+ "Rotate the yanking point by N places, and then return that kill.
+ (let VARLIST
+ BODY...)
+
+This function takes two arguments, one of which is optional. It has a
+documentation string. It is _not_ interactive.
+
+The body of the function definition is a `let' expression, which itself
+has a body as well as a VARLIST.
+
+The `let' expression declares a variable that will be only usable
+within the bounds of this function. This variable is called
+`interprogram-paste' and is for copying to another program. It is not
+for copying within this instance of GNU Emacs. Most window systems
+provide a facility for interprogram pasting. Sadly, that facility
+usually provides only for the lasted element. Most windowing systems
+have not adopted a ring of many possibilities, even though Emacs has
+provided it for decades.
+
+The `if' expression has two parts, one if there exists
+`interprogram-paste' and one if not.
+
+Let us consider the `if not' or else-part of the `current-kill'
+function. (The then-part uses the the `kill-new' function, which we
+have already described. (*Note The `kill-new' function: kill-new
+function.)
+
+ (or kill-ring (error "Kill ring is empty"))
+ (let ((ARGth-kill-element
+ (nthcdr (mod (- n (length kill-ring-yank-pointer))
+ (length kill-ring))
+ kill-ring)))
+ (or do-not-move
+ (setq kill-ring-yank-pointer ARGth-kill-element))
+ (car ARGth-kill-element))
+
+The code first checks whether the kill ring has content; otherwise it
+signals an error.
+
+Note that the `or' expression is very similar to writing
+
+ (if (zerop (length kill-ring)) ; if-part
+ (error "Kill ring is empty")) ; then-part
+ ;; No else-part
+
+If there is not anything in the kill ring, its length must be zero and
+an error message sent to the user: `Kill ring is empty'. The
+`current-kill' function uses an `or' expression which is simpler. But
+an `if' expression reminds us what goes on.
+
+This `if' expression uses the function `zerop' which returns true if
+the value it is testing is zero. When `zerop' tests true, the
+then-part of the `if' is evaluated. The then-part is a list starting
+with the function `error', which is a function that is similar to the
+`message' function (*note The `message' Function: message.), in that it
+prints a one-line message in the echo area. However, in addition to
+printing a message, `error' also stops evaluation of the function
+within which it is embedded. This means that the rest of the function
+will not be evaluated if the length of the kill ring is zero.
+
+Then the `current-kill' function selects the element to return. The
+selection depends on the number of places that `current-kill' rotates
+and on where `kill-ring-yank-pointer' points.
+
+Next, either the optional `do-not-move' argument is true or the current
+value of `kill-ring-yank-pointer' is set to point to the list, the
+first element of which is returned even if the `do-not-move' argument
+is true.
+
+* Menu:
+
+* Digression concerning error::
+* Determining the Element ::
+
+\1f
+File: eintr, Node: Digression concerning error, Next: Determining the Element, Prev: Understanding current-kill, Up: Understanding current-kill
+
+Digression about the word `error'
+.................................
+
+In my opinion, it is slightly misleading, at least to humans, to use
+the term `error' as the name of the `error' function. A better term
+would be `cancel'. Strictly speaking, of course, you cannot point to,
+much less rotate a pointer to a list that has no length, so from the
+point of view of the computer, the word `error' is correct. But a
+human expects to attempt this sort of thing, if only to find out
+whether the kill ring is full or empty. This is an act of exploration.
+
+From the human point of view, the act of exploration and discovery is
+not necessarily an error, and therefore should not be labelled as one,
+even in the bowels of a computer. As it is, the code in Emacs implies
+that a human who is acting virtuously, by exploring his or her
+environment, is making an error. This is bad. Even though the computer
+takes the same steps as it does when there is an `error', a term such as
+`cancel' would have a clearer connotation.
+
+\1f
+File: eintr, Node: Determining the Element, Prev: Digression concerning error, Up: Understanding current-kill
+
+Determining the Element
+.......................
+
+Among other actions, the else-part of the `if' expression sets the
+value of `kill-ring-yank-pointer' to `ARGth-kill-element' when the kill
+ring has something in it and the value of `do-not-move' is `nil'.
+
+The code looks like this:
+
+ (nthcdr (mod (- n (length kill-ring-yank-pointer))
+ (length kill-ring))
+ kill-ring)))
+
+This needs some examination. Unless it is not supposed to move the
+pointer, the `current-kill' function changes where
+`kill-ring-yank-pointer' points. That is what the
+`(setq kill-ring-yank-pointer ARGth-kill-element))' expression does.
+Also, clearly, `ARGth-kill-element' is being set to be equal to some
+CDR of the kill ring, using the `nthcdr' function that is described in
+an earlier section. (*Note copy-region-as-kill::.) How does it do
+this?
+
+As we have seen before (*note nthcdr::), the `nthcdr' function works by
+repeatedly taking the CDR of a list--it takes the CDR of the CDR of the
+CDR ...
+
+The two following expressions produce the same result:
+
+ (setq kill-ring-yank-pointer (cdr kill-ring))
+
+ (setq kill-ring-yank-pointer (nthcdr 1 kill-ring))
+
+However, the `nthcdr' expression is more complicated. It uses the
+`mod' function to determine which CDR to select.
+
+(You will remember to look at inner functions first; indeed, we will
+have to go inside the `mod'.)
+
+The `mod' function returns the value of its first argument modulo the
+second; that is to say, it returns the remainder after dividing the
+first argument by the second. The value returned has the same sign as
+the second argument.
+
+Thus,
+
+ (mod 12 4)
+ => 0 ;; because there is no remainder
+ (mod 13 4)
+ => 1
+
+In this case, the first argument is often smaller than the second.
+That is fine.
+
+ (mod 0 4)
+ => 0
+ (mod 1 4)
+ => 1
+
+We can guess what the `-' function does. It is like `+' but subtracts
+instead of adds; the `-' function subtracts its second argument from
+its first. Also, we already know what the `length' function does
+(*note length::). It returns the length of a list.
+
+And `n' is the name of the required argument to the `current-kill'
+function.
+
+So when the first argument to `nthcdr' is zero, the `nthcdr' expression
+returns the whole list, as you can see by evaluating the following:
+
+ ;; kill-ring-yank-pointer and kill-ring have a length of four
+ (nthcdr (mod (- 0 4) 4) ; (mod -4 4) => 0
+ '("fourth line of text"
+ "third line"
+ "second piece of text"
+ "first some text"))
+
+When the first argument to the `current-kill' function is one, the
+`nthcdr' expression returns the list without its first element.
+
+ (nthcdr (mod (- 1 4) 4)
+ '("fourth line of text"
+ "third line"
+ "second piece of text"
+ "first some text"))
+
+Incidentally, both `kill-ring' and `kill-ring-yank-pointer' are "global
+variables". That means that any expression in Emacs Lisp can access
+them. They are not like the local variables set by `let' or like the
+symbols in an argument list. Local variables can only be accessed
+within the `let' that defines them or the function that specifies them
+in an argument list (and within expressions called by them).
+
+\1f
+File: eintr, Node: yank, Next: yank-pop, Prev: current-kill, Up: Kill Ring
+
+B.2 `yank'
+==========
+
+After learning about `current-kill', the code for the `yank' function
+is almost easy. It has only one tricky part, which is the computation
+of the argument to be passed to `rotate-yank-pointer'.
+
+The code looks like this:
+
+ (defun yank (&optional arg)
+ "Reinsert (\"paste\") the last stretch of killed text.
+ More precisely, reinsert the stretch of killed text most recently
+ killed OR yanked. Put point at end, and set mark at beginning.
+ With just \\[universal-argument] as argument, same but put point at
+ beginning (and mark at end). With argument N, reinsert the Nth most
+ recently killed stretch of killed text.
+
+ When this command inserts killed text into the buffer, it honors
+ `yank-excluded-properties' and `yank-handler' as described in the
+ doc string for `insert-for-yank-1', which see.
+
+ See also the command \\[yank-pop]."
+ (interactive "*P")
+ (setq yank-window-start (window-start))
+ ;; If we don't get all the way thru, make last-command indicate that
+ ;; for the following command.
+ (setq this-command t)
+ (push-mark (point))
+ (insert-for-yank (current-kill (cond
+ ((listp arg) 0)
+ ((eq arg '-) -2)
+ (t (1- arg)))))
+ (if (consp arg)
+ ;; This is like exchange-point-and-mark,
+ ;; but doesn't activate the mark.
+ ;; It is cleaner to avoid activation, even though the command
+ ;; loop would deactivate the mark because we inserted text.
+ (goto-char (prog1 (mark t)
+ (set-marker (mark-marker) (point) (current-buffer)))))
+ ;; If we do get all the way thru, make this-command indicate that.
+ (if (eq this-command t)
+ (setq this-command 'yank))
+ nil)
+
+The key expression is `insert-for-yank', which inserts the string
+returned by `current-kill', but removes some text properties from it.
+
+However, before getting to that expression, the function set the value
+of `yank-window-start' to the position returned by the `(window-start)'
+expression, the position at which the display currently starts. It
+also set `this-command' and pushed the mark.
+
+After it yanks the appropriate element, if the optional argument is a
+CONS rather than a number or nothing, put point at beginning of the
+yanked text and mark at its end. (The `prog1' function is like `progn'
+but returns the value of its first argument rather than the value of
+its last argument. Its first argument is forced to return the buffer's
+mark as an integer. You can see the documentation for these functions
+by placing point over them in this buffer and then typing `C-h f'
+(`describe-function') followed by a `RET'; the default is the function.)
+
+The last part of the function tells what to do when it succeeds.
+
+\1f
+File: eintr, Node: yank-pop, Next: ring file, Prev: yank, Up: Kill Ring
+
+B.3 `yank-pop'
+==============
+
+After understanding `yank' and `current-kill', you know how to approach
+the `yank-pop' function Leaving out the documentation to save space, it
+looks like this:
+
+ (defun yank-pop (&optional arg)
+ "..."
+ (interactive "*p")
+ (if (not (eq last-command 'yank))
+ (error "Previous command was not a yank"))
+ (setq this-command 'yank)
+ (unless arg (setq arg 1))
+ (let ((inhibit-read-only t)
+ (before (< (point) (mark t))))
+ (if before
+ (funcall (or yank-undo-function 'delete-region) (point) (mark t))
+ (funcall (or yank-undo-function 'delete-region) (mark t) (point)))
+ (setq yank-undo-function nil)
+ (set-marker (mark-marker) (point) (current-buffer))
+ (insert-for-yank (current-kill arg))
+ ;; Set the window start back where it was in the yank command,
+ ;; if possible.
+ (set-window-start (selected-window) yank-window-start t)
+ (if before
+ ;; This is like exchange-point-and-mark,
+ ;; but doesn't activate the mark.
+ ;; It is cleaner to avoid activation, even though the command
+ ;; loop would deactivate the mark because we inserted text.
+ (goto-char (prog1 (mark t)
+ (set-marker (mark-marker)
+ (point)
+ (current-buffer))))))
+ nil)
+
+The function is interactive with a small `p' so the prefix argument is
+processed and passed to the function. The command can only be used
+after a previous yank; otherwise an error message is sent. This check
+uses the variable `last-command' which is set by `yank' and is
+discussed elsewhere. (*Note copy-region-as-kill::.)
+
+The `let' clause sets the variable `before' to true or false depending
+whether point is before or after mark and then the region between point
+and mark is deleted. This is the region that was just inserted by the
+previous yank and it is this text that will be replaced.
+
+`funcall' calls its first argument as a function, passing remaining
+arguments to it. The first argument is whatever the `or' expression
+returns. The two remaining arguments are the positions of point and
+mark set by the preceding `yank' command.
+
+There is more, but that is the hardest part.
+
+\1f
+File: eintr, Node: ring file, Prev: yank-pop, Up: Kill Ring
+
+B.4 The `ring.el' File
+======================
+
+Interestingly, GNU Emacs posses a file called `ring.el' that provides
+many of the features we just discussed. But functions such as
+`kill-ring-yank-pointer' do not use this library, possibly because they
+were written earlier.
+
+\1f
+File: eintr, Node: Full Graph, Next: Free Software and Free Manuals, Prev: Kill Ring, Up: Top
+
+Appendix C A Graph with Labelled Axes
+*************************************
+
+Printed axes help you understand a graph. They convey scale. In an
+earlier chapter (*note Readying a Graph: Readying a Graph.), we wrote
+the code to print the body of a graph. Here we write the code for
+printing and labelling vertical and horizontal axes, along with the
+body itself.
+
+* Menu:
+
+* Labelled Example::
+* print-graph Varlist::
+* print-Y-axis::
+* print-X-axis::
+* Print Whole Graph::
+
+\1f
+File: eintr, Node: Labelled Example, Next: print-graph Varlist, Prev: Full Graph, Up: Full Graph
+
+Labelled Example Graph
+======================
+
+Since insertions fill a buffer to the right and below point, the new
+graph printing function should first print the Y or vertical axis, then
+the body of the graph, and finally the X or horizontal axis. This
+sequence lays out for us the contents of the function:
+
+ 1. Set up code.
+
+ 2. Print Y axis.
+
+ 3. Print body of graph.
+
+ 4. Print X axis.
+
+Here is an example of how a finished graph should look:
+
+ 10 -
+ *
+ * *
+ * **
+ * ***
+ 5 - * *******
+ * *** *******
+ *************
+ ***************
+ 1 - ****************
+ | | | |
+ 1 5 10 15
+
+In this graph, both the vertical and the horizontal axes are labelled
+with numbers. However, in some graphs, the horizontal axis is time and
+would be better labelled with months, like this:
+
+ 5 - *
+ * ** *
+ *******
+ ********** **
+ 1 - **************
+ | ^ |
+ Jan June Jan
+
+Indeed, with a little thought, we can easily come up with a variety of
+vertical and horizontal labelling schemes. Our task could become
+complicated. But complications breed confusion. Rather than permit
+this, it is better choose a simple labelling scheme for our first
+effort, and to modify or replace it later.
+
+These considerations suggest the following outline for the
+`print-graph' function:
+
+ (defun print-graph (numbers-list)
+ "DOCUMENTATION..."
+ (let ((height ...
+ ...))
+ (print-Y-axis height ... )
+ (graph-body-print numbers-list)
+ (print-X-axis ... )))
+
+We can work on each part of the `print-graph' function definition in
+turn.
+
+\1f
+File: eintr, Node: print-graph Varlist, Next: print-Y-axis, Prev: Labelled Example, Up: Full Graph
+
+C.1 The `print-graph' Varlist
+=============================
+
+In writing the `print-graph' function, the first task is to write the
+varlist in the `let' expression. (We will leave aside for the moment
+any thoughts about making the function interactive or about the
+contents of its documentation string.)
+
+The varlist should set several values. Clearly, the top of the label
+for the vertical axis must be at least the height of the graph, which
+means that we must obtain this information here. Note that the
+`print-graph-body' function also requires this information. There is
+no reason to calculate the height of the graph in two different places,
+so we should change `print-graph-body' from the way we defined it
+earlier to take advantage of the calculation.
+
+Similarly, both the function for printing the X axis labels and the
+`print-graph-body' function need to learn the value of the width of
+each symbol. We can perform the calculation here and change the
+definition for `print-graph-body' from the way we defined it in the
+previous chapter.
+
+The length of the label for the horizontal axis must be at least as long
+as the graph. However, this information is used only in the function
+that prints the horizontal axis, so it does not need to be calculated
+here.
+
+These thoughts lead us directly to the following form for the varlist
+in the `let' for `print-graph':
+
+ (let ((height (apply 'max numbers-list)) ; First version.
+ (symbol-width (length graph-blank)))
+
+As we shall see, this expression is not quite right.
+
+\1f
+File: eintr, Node: print-Y-axis, Next: print-X-axis, Prev: print-graph Varlist, Up: Full Graph
+
+C.2 The `print-Y-axis' Function
+===============================
+
+The job of the `print-Y-axis' function is to print a label for the
+vertical axis that looks like this:
+
+ 10 -
+
+
+
+
+ 5 -
+
+
+
+ 1 -
+
+The function should be passed the height of the graph, and then should
+construct and insert the appropriate numbers and marks.
+
+It is easy enough to see in the figure what the Y axis label should
+look like; but to say in words, and then to write a function definition
+to do the job is another matter. It is not quite true to say that we
+want a number and a tic every five lines: there are only three lines
+between the `1' and the `5' (lines 2, 3, and 4), but four lines between
+the `5' and the `10' (lines 6, 7, 8, and 9). It is better to say that
+we want a number and a tic mark on the base line (number 1) and then
+that we want a number and a tic on the fifth line from the bottom and
+on every line that is a multiple of five.
+
+* Menu:
+
+* Height of label::
+* Compute a Remainder::
+* Y Axis Element::
+* Y-axis-column::
+* print-Y-axis Penultimate::
+
+\1f
+File: eintr, Node: Height of label, Next: Compute a Remainder, Prev: print-Y-axis, Up: print-Y-axis
+
+What height should the label be?
+--------------------------------
+
+The next issue is what height the label should be? Suppose the maximum
+height of tallest column of the graph is seven. Should the highest
+label on the Y axis be `5 -', and should the graph stick up above the
+label? Or should the highest label be `7 -', and mark the peak of the
+graph? Or should the highest label be `10 -', which is a multiple of
+five, and be higher than the topmost value of the graph?
+
+The latter form is preferred. Most graphs are drawn within rectangles
+whose sides are an integral number of steps long--5, 10, 15, and so on
+for a step distance of five. But as soon as we decide to use a step
+height for the vertical axis, we discover that the simple expression in
+the varlist for computing the height is wrong. The expression is
+`(apply 'max numbers-list)'. This returns the precise height, not the
+maximum height plus whatever is necessary to round up to the nearest
+multiple of five. A more complex expression is required.
+
+As usual in cases like this, a complex problem becomes simpler if it is
+divided into several smaller problems.
+
+First, consider the case when the highest value of the graph is an
+integral multiple of five--when it is 5, 10, 15, or some higher
+multiple of five. We can use this value as the Y axis height.
+
+A fairly simply way to determine whether a number is a multiple of five
+is to divide it by five and see if the division results in a remainder.
+If there is no remainder, the number is a multiple of five. Thus,
+seven divided by five has a remainder of two, and seven is not an
+integral multiple of five. Put in slightly different language, more
+reminiscent of the classroom, five goes into seven once, with a
+remainder of two. However, five goes into ten twice, with no
+remainder: ten is an integral multiple of five.
+
+\1f
+File: eintr, Node: Compute a Remainder, Next: Y Axis Element, Prev: Height of label, Up: print-Y-axis
+
+C.2.1 Side Trip: Compute a Remainder
+------------------------------------
+
+In Lisp, the function for computing a remainder is `%'. The function
+returns the remainder of its first argument divided by its second
+argument. As it happens, `%' is a function in Emacs Lisp that you
+cannot discover using `apropos': you find nothing if you type `M-x
+apropos <RET> remainder <RET>'. The only way to learn of the existence
+of `%' is to read about it in a book such as this or in the Emacs Lisp
+sources.
+
+You can try the `%' function by evaluating the following two
+expressions:
+
+ (% 7 5)
+
+ (% 10 5)
+
+The first expression returns 2 and the second expression returns 0.
+
+To test whether the returned value is zero or some other number, we can
+use the `zerop' function. This function returns `t' if its argument,
+which must be a number, is zero.
+
+ (zerop (% 7 5))
+ => nil
+
+ (zerop (% 10 5))
+ => t
+
+Thus, the following expression will return `t' if the height of the
+graph is evenly divisible by five:
+
+ (zerop (% height 5))
+
+(The value of `height', of course, can be found from `(apply 'max
+numbers-list)'.)
+
+On the other hand, if the value of `height' is not a multiple of five,
+we want to reset the value to the next higher multiple of five. This
+is straightforward arithmetic using functions with which we are already
+familiar. First, we divide the value of `height' by five to determine
+how many times five goes into the number. Thus, five goes into twelve
+twice. If we add one to this quotient and multiply by five, we will
+obtain the value of the next multiple of five that is larger than the
+height. Five goes into twelve twice. Add one to two, and multiply by
+five; the result is fifteen, which is the next multiple of five that is
+higher than twelve. The Lisp expression for this is:
+
+ (* (1+ (/ height 5)) 5)
+
+For example, if you evaluate the following, the result is 15:
+
+ (* (1+ (/ 12 5)) 5)
+
+All through this discussion, we have been using `five' as the value for
+spacing labels on the Y axis; but we may want to use some other value.
+For generality, we should replace `five' with a variable to which we
+can assign a value. The best name I can think of for this variable is
+`Y-axis-label-spacing'.
+
+Using this term, and an `if' expression, we produce the following:
+
+ (if (zerop (% height Y-axis-label-spacing))
+ height
+ ;; else
+ (* (1+ (/ height Y-axis-label-spacing))
+ Y-axis-label-spacing))
+
+This expression returns the value of `height' itself if the height is
+an even multiple of the value of the `Y-axis-label-spacing' or else it
+computes and returns a value of `height' that is equal to the next
+higher multiple of the value of the `Y-axis-label-spacing'.
+
+We can now include this expression in the `let' expression of the
+`print-graph' function (after first setting the value of
+`Y-axis-label-spacing'):
+
+ (defvar Y-axis-label-spacing 5
+ "Number of lines from one Y axis label to next.")
+
+ ...
+ (let* ((height (apply 'max numbers-list))
+ (height-of-top-line
+ (if (zerop (% height Y-axis-label-spacing))
+ height
+ ;; else
+ (* (1+ (/ height Y-axis-label-spacing))
+ Y-axis-label-spacing)))
+ (symbol-width (length graph-blank))))
+ ...
+
+(Note use of the `let*' function: the initial value of height is
+computed once by the `(apply 'max numbers-list)' expression and then
+the resulting value of `height' is used to compute its final value.
+*Note The `let*' expression: fwd-para let, for more about `let*'.)
+
+\1f
+File: eintr, Node: Y Axis Element, Next: Y-axis-column, Prev: Compute a Remainder, Up: print-Y-axis
+
+C.2.2 Construct a Y Axis Element
+--------------------------------
+
+When we print the vertical axis, we want to insert strings such as
+`5 -' and `10 - ' every five lines. Moreover, we want the numbers and
+dashes to line up, so shorter numbers must be padded with leading
+spaces. If some of the strings use two digit numbers, the strings with
+single digit numbers must include a leading blank space before the
+number.
+
+To figure out the length of the number, the `length' function is used.
+But the `length' function works only with a string, not with a number.
+So the number has to be converted from being a number to being a
+string. This is done with the `number-to-string' function. For
+example,
+
+ (length (number-to-string 35))
+ => 2
+
+ (length (number-to-string 100))
+ => 3
+
+(`number-to-string' is also called `int-to-string'; you will see this
+alternative name in various sources.)
+
+In addition, in each label, each number is followed by a string such as
+` - ', which we will call the `Y-axis-tic' marker. This variable is
+defined with `defvar':
+
+ (defvar Y-axis-tic " - "
+ "String that follows number in a Y axis label.")
+
+The length of the Y label is the sum of the length of the Y axis tic
+mark and the length of the number of the top of the graph.
+
+ (length (concat (number-to-string height) Y-axis-tic)))
+
+This value will be calculated by the `print-graph' function in its
+varlist as `full-Y-label-width' and passed on. (Note that we did not
+think to include this in the varlist when we first proposed it.)
+
+To make a complete vertical axis label, a tic mark is concatenated with
+a number; and the two together may be preceded by one or more spaces
+depending on how long the number is. The label consists of three
+parts: the (optional) leading spaces, the number, and the tic mark.
+The function is passed the value of the number for the specific row,
+and the value of the width of the top line, which is calculated (just
+once) by `print-graph'.
+
+ (defun Y-axis-element (number full-Y-label-width)
+ "Construct a NUMBERed label element.
+ A numbered element looks like this ` 5 - ',
+ and is padded as needed so all line up with
+ the element for the largest number."
+ (let* ((leading-spaces
+ (- full-Y-label-width
+ (length
+ (concat (number-to-string number)
+ Y-axis-tic)))))
+ (concat
+ (make-string leading-spaces ? )
+ (number-to-string number)
+ Y-axis-tic)))
+
+The `Y-axis-element' function concatenates together the leading spaces,
+if any; the number, as a string; and the tic mark.
+
+To figure out how many leading spaces the label will need, the function
+subtracts the actual length of the label--the length of the number plus
+the length of the tic mark--from the desired label width.
+
+Blank spaces are inserted using the `make-string' function. This
+function takes two arguments: the first tells it how long the string
+will be and the second is a symbol for the character to insert, in a
+special format. The format is a question mark followed by a blank
+space, like this, `? '. *Note Character Type: (elisp)Character Type,
+for a description of the syntax for characters.
+
+The `number-to-string' function is used in the concatenation
+expression, to convert the number to a string that is concatenated with
+the leading spaces and the tic mark.
+
+\1f
+File: eintr, Node: Y-axis-column, Next: print-Y-axis Penultimate, Prev: Y Axis Element, Up: print-Y-axis
+
+C.2.3 Create a Y Axis Column
+----------------------------
+
+The preceding functions provide all the tools needed to construct a
+function that generates a list of numbered and blank strings to insert
+as the label for the vertical axis:
+
+ (defun Y-axis-column (height width-of-label)
+ "Construct list of Y axis labels and blank strings.
+ For HEIGHT of line above base and WIDTH-OF-LABEL."
+ (let (Y-axis)
+ (while (> height 1)
+ (if (zerop (% height Y-axis-label-spacing))
+ ;; Insert label.
+ (setq Y-axis
+ (cons
+ (Y-axis-element height width-of-label)
+ Y-axis))
+ ;; Else, insert blanks.
+ (setq Y-axis
+ (cons
+ (make-string width-of-label ? )
+ Y-axis)))
+ (setq height (1- height)))
+ ;; Insert base line.
+ (setq Y-axis
+ (cons (Y-axis-element 1 width-of-label) Y-axis))
+ (nreverse Y-axis)))
+
+In this function, we start with the value of `height' and repetitively
+subtract one from its value. After each subtraction, we test to see
+whether the value is an integral multiple of the
+`Y-axis-label-spacing'. If it is, we construct a numbered label using
+the `Y-axis-element' function; if not, we construct a blank label using
+the `make-string' function. The base line consists of the number one
+followed by a tic mark.
+
+\1f
+File: eintr, Node: print-Y-axis Penultimate, Prev: Y-axis-column, Up: print-Y-axis
+
+C.2.4 The Not Quite Final Version of `print-Y-axis'
+---------------------------------------------------
+
+The list constructed by the `Y-axis-column' function is passed to the
+`print-Y-axis' function, which inserts the list as a column.
+
+ (defun print-Y-axis (height full-Y-label-width)
+ "Insert Y axis using HEIGHT and FULL-Y-LABEL-WIDTH.
+ Height must be the maximum height of the graph.
+ Full width is the width of the highest label element."
+ ;; Value of height and full-Y-label-width
+ ;; are passed by `print-graph'.
+ (let ((start (point)))
+ (insert-rectangle
+ (Y-axis-column height full-Y-label-width))
+ ;; Place point ready for inserting graph.
+ (goto-char start)
+ ;; Move point forward by value of full-Y-label-width
+ (forward-char full-Y-label-width)))
+
+The `print-Y-axis' uses the `insert-rectangle' function to insert the Y
+axis labels created by the `Y-axis-column' function. In addition, it
+places point at the correct position for printing the body of the graph.
+
+You can test `print-Y-axis':
+
+ 1. Install
+
+ Y-axis-label-spacing
+ Y-axis-tic
+ Y-axis-element
+ Y-axis-column
+ print-Y-axis
+
+ 2. Copy the following expression:
+
+ (print-Y-axis 12 5)
+
+ 3. Switch to the `*scratch*' buffer and place the cursor where you
+ want the axis labels to start.
+
+ 4. Type `M-:' (`eval-expression').
+
+ 5. Yank the `graph-body-print' expression into the minibuffer with
+ `C-y' (`yank)'.
+
+ 6. Press <RET> to evaluate the expression.
+
+Emacs will print labels vertically, the top one being `10 - '. (The
+`print-graph' function will pass the value of `height-of-top-line',
+which in this case would end up as 15.)
+
+\1f
+File: eintr, Node: print-X-axis, Next: Print Whole Graph, Prev: print-Y-axis, Up: Full Graph
+
+C.3 The `print-X-axis' Function
+===============================
+
+X axis labels are much like Y axis labels, except that the ticks are on
+a line above the numbers. Labels should look like this:
+
+ | | | |
+ 1 5 10 15
+
+The first tic is under the first column of the graph and is preceded by
+several blank spaces. These spaces provide room in rows above for the Y
+axis labels. The second, third, fourth, and subsequent ticks are all
+spaced equally, according to the value of `X-axis-label-spacing'.
+
+The second row of the X axis consists of numbers, preceded by several
+blank spaces and also separated according to the value of the variable
+`X-axis-label-spacing'.
+
+The value of the variable `X-axis-label-spacing' should itself be
+measured in units of `symbol-width', since you may want to change the
+width of the symbols that you are using to print the body of the graph
+without changing the ways the graph is labelled.
+
+* Menu:
+
+* Similarities differences::
+* X Axis Tic Marks::
+
+\1f
+File: eintr, Node: Similarities differences, Next: X Axis Tic Marks, Prev: print-X-axis, Up: print-X-axis
+
+Similarities and differences
+----------------------------
+
+The `print-X-axis' function is constructed in more or less the same
+fashion as the `print-Y-axis' function except that it has two lines:
+the line of tic marks and the numbers. We will write a separate
+function to print each line and then combine them within the
+`print-X-axis' function.
+
+This is a three step process:
+
+ 1. Write a function to print the X axis tic marks,
+ `print-X-axis-tic-line'.
+
+ 2. Write a function to print the X numbers,
+ `print-X-axis-numbered-line'.
+
+ 3. Write a function to print both lines, the `print-X-axis' function,
+ using `print-X-axis-tic-line' and `print-X-axis-numbered-line'.
+
+\1f
+File: eintr, Node: X Axis Tic Marks, Prev: Similarities differences, Up: print-X-axis
+
+C.3.1 X Axis Tic Marks
+----------------------
+
+The first function should print the X axis tic marks. We must specify
+the tic marks themselves and their spacing:
+
+ (defvar X-axis-label-spacing
+ (if (boundp 'graph-blank)
+ (* 5 (length graph-blank)) 5)
+ "Number of units from one X axis label to next.")
+
+(Note that the value of `graph-blank' is set by another `defvar'. The
+`boundp' predicate checks whether it has already been set; `boundp'
+returns `nil' if it has not. If `graph-blank' were unbound and we did
+not use this conditional construction, in GNU Emacs 21, we would enter
+the debugger and see an error message saying
+`Debugger entered--Lisp error: (void-variable graph-blank)'.)
+
+Here is the `defvar' for `X-axis-tic-symbol':
+
+ (defvar X-axis-tic-symbol "|"
+ "String to insert to point to a column in X axis.")
+
+The goal is to make a line that looks like this:
+
+ | | | |
+
+The first tic is indented so that it is under the first column, which is
+indented to provide space for the Y axis labels.
+
+A tic element consists of the blank spaces that stretch from one tic to
+the next plus a tic symbol. The number of blanks is determined by the
+width of the tic symbol and the `X-axis-label-spacing'.
+
+The code looks like this:
+
+ ;;; X-axis-tic-element
+ ...
+ (concat
+ (make-string
+ ;; Make a string of blanks.
+ (- (* symbol-width X-axis-label-spacing)
+ (length X-axis-tic-symbol))
+ ? )
+ ;; Concatenate blanks with tic symbol.
+ X-axis-tic-symbol)
+ ...
+
+Next, we determine how many blanks are needed to indent the first tic
+mark to the first column of the graph. This uses the value of
+`full-Y-label-width' passed it by the `print-graph' function.
+
+The code to make `X-axis-leading-spaces' looks like this:
+
+ ;; X-axis-leading-spaces
+ ...
+ (make-string full-Y-label-width ? )
+ ...
+
+We also need to determine the length of the horizontal axis, which is
+the length of the numbers list, and the number of ticks in the
+horizontal axis:
+
+ ;; X-length
+ ...
+ (length numbers-list)
+
+ ;; tic-width
+ ...
+ (* symbol-width X-axis-label-spacing)
+
+ ;; number-of-X-ticks
+ (if (zerop (% (X-length tic-width)))
+ (/ (X-length tic-width))
+ (1+ (/ (X-length tic-width))))
+
+All this leads us directly to the function for printing the X axis tic
+line:
+
+ (defun print-X-axis-tic-line
+ (number-of-X-tics X-axis-leading-spaces X-axis-tic-element)
+ "Print ticks for X axis."
+ (insert X-axis-leading-spaces)
+ (insert X-axis-tic-symbol) ; Under first column.
+ ;; Insert second tic in the right spot.
+ (insert (concat
+ (make-string
+ (- (* symbol-width X-axis-label-spacing)
+ ;; Insert white space up to second tic symbol.
+ (* 2 (length X-axis-tic-symbol)))
+ ? )
+ X-axis-tic-symbol))
+ ;; Insert remaining ticks.
+ (while (> number-of-X-tics 1)
+ (insert X-axis-tic-element)
+ (setq number-of-X-tics (1- number-of-X-tics))))
+
+The line of numbers is equally straightforward:
+
+First, we create a numbered element with blank spaces before each
+number:
+
+ (defun X-axis-element (number)
+ "Construct a numbered X axis element."
+ (let ((leading-spaces
+ (- (* symbol-width X-axis-label-spacing)
+ (length (number-to-string number)))))
+ (concat (make-string leading-spaces ? )
+ (number-to-string number))))
+
+Next, we create the function to print the numbered line, starting with
+the number "1" under the first column:
+
+ (defun print-X-axis-numbered-line
+ (number-of-X-tics X-axis-leading-spaces)
+ "Print line of X-axis numbers"
+ (let ((number X-axis-label-spacing))
+ (insert X-axis-leading-spaces)
+ (insert "1")
+ (insert (concat
+ (make-string
+ ;; Insert white space up to next number.
+ (- (* symbol-width X-axis-label-spacing) 2)
+ ? )
+ (number-to-string number)))
+ ;; Insert remaining numbers.
+ (setq number (+ number X-axis-label-spacing))
+ (while (> number-of-X-tics 1)
+ (insert (X-axis-element number))
+ (setq number (+ number X-axis-label-spacing))
+ (setq number-of-X-tics (1- number-of-X-tics)))))
+
+Finally, we need to write the `print-X-axis' that uses
+`print-X-axis-tic-line' and `print-X-axis-numbered-line'.
+
+The function must determine the local values of the variables used by
+both `print-X-axis-tic-line' and `print-X-axis-numbered-line', and then
+it must call them. Also, it must print the carriage return that
+separates the two lines.
+
+The function consists of a varlist that specifies five local variables,
+and calls to each of the two line printing functions:
+
+ (defun print-X-axis (numbers-list)
+ "Print X axis labels to length of NUMBERS-LIST."
+ (let* ((leading-spaces
+ (make-string full-Y-label-width ? ))
+ ;; symbol-width is provided by graph-body-print
+ (tic-width (* symbol-width X-axis-label-spacing))
+ (X-length (length numbers-list))
+ (X-tic
+ (concat
+ (make-string
+ ;; Make a string of blanks.
+ (- (* symbol-width X-axis-label-spacing)
+ (length X-axis-tic-symbol))
+ ? )
+ ;; Concatenate blanks with tic symbol.
+ X-axis-tic-symbol))
+ (tic-number
+ (if (zerop (% X-length tic-width))
+ (/ X-length tic-width)
+ (1+ (/ X-length tic-width)))))
+ (print-X-axis-tic-line tic-number leading-spaces X-tic)
+ (insert "\n")
+ (print-X-axis-numbered-line tic-number leading-spaces)))
+
+You can test `print-X-axis':
+
+ 1. Install `X-axis-tic-symbol', `X-axis-label-spacing',
+ `print-X-axis-tic-line', as well as `X-axis-element',
+ `print-X-axis-numbered-line', and `print-X-axis'.
+
+ 2. Copy the following expression:
+
+ (progn
+ (let ((full-Y-label-width 5)
+ (symbol-width 1))
+ (print-X-axis
+ '(1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16))))
+
+ 3. Switch to the `*scratch*' buffer and place the cursor where you
+ want the axis labels to start.
+
+ 4. Type `M-:' (`eval-expression').
+
+ 5. Yank the test expression into the minibuffer with `C-y' (`yank)'.
+
+ 6. Press <RET> to evaluate the expression.
+
+Emacs will print the horizontal axis like this:
+
+ | | | | |
+ 1 5 10 15 20
+
+\1f
+File: eintr, Node: Print Whole Graph, Prev: print-X-axis, Up: Full Graph
+
+C.4 Printing the Whole Graph
+============================
+
+Now we are nearly ready to print the whole graph.
+
+The function to print the graph with the proper labels follows the
+outline we created earlier (*note A Graph with Labelled Axes: Full
+Graph.), but with additions.
+
+Here is the outline:
+
+ (defun print-graph (numbers-list)
+ "DOCUMENTATION..."
+ (let ((height ...
+ ...))
+ (print-Y-axis height ... )
+ (graph-body-print numbers-list)
+ (print-X-axis ... )))
+
+* Menu:
+
+* The final version::
+* Test print-graph::
+* Graphing words in defuns::
+* lambda::
+* mapcar::
+* Another Bug::
+* Final printed graph::
+
+\1f
+File: eintr, Node: The final version, Next: Test print-graph, Prev: Print Whole Graph, Up: Print Whole Graph
+
+Changes for the Final Version
+-----------------------------
+
+The final version is different from what we planned in two ways: first,
+it contains additional values calculated once in the varlist; second,
+it carries an option to specify the labels' increment per row. This
+latter feature turns out to be essential; otherwise, a graph may have
+more rows than fit on a display or on a sheet of paper.
+
+This new feature requires a change to the `Y-axis-column' function, to
+add `vertical-step' to it. The function looks like this:
+
+ ;;; Final version.
+ (defun Y-axis-column
+ (height width-of-label &optional vertical-step)
+ "Construct list of labels for Y axis.
+ HEIGHT is maximum height of graph.
+ WIDTH-OF-LABEL is maximum width of label.
+ VERTICAL-STEP, an option, is a positive integer
+ that specifies how much a Y axis label increments
+ for each line. For example, a step of 5 means
+ that each line is five units of the graph."
+ (let (Y-axis
+ (number-per-line (or vertical-step 1)))
+ (while (> height 1)
+ (if (zerop (% height Y-axis-label-spacing))
+ ;; Insert label.
+ (setq Y-axis
+ (cons
+ (Y-axis-element
+ (* height number-per-line)
+ width-of-label)
+ Y-axis))
+ ;; Else, insert blanks.
+ (setq Y-axis
+ (cons
+ (make-string width-of-label ? )
+ Y-axis)))
+ (setq height (1- height)))
+ ;; Insert base line.
+ (setq Y-axis (cons (Y-axis-element
+ (or vertical-step 1)
+ width-of-label)
+ Y-axis))
+ (nreverse Y-axis)))
+
+The values for the maximum height of graph and the width of a symbol
+are computed by `print-graph' in its `let' expression; so
+`graph-body-print' must be changed to accept them.
+
+ ;;; Final version.
+ (defun graph-body-print (numbers-list height symbol-width)
+ "Print a bar graph of the NUMBERS-LIST.
+ The numbers-list consists of the Y-axis values.
+ HEIGHT is maximum height of graph.
+ SYMBOL-WIDTH is number of each column."
+ (let (from-position)
+ (while numbers-list
+ (setq from-position (point))
+ (insert-rectangle
+ (column-of-graph height (car numbers-list)))
+ (goto-char from-position)
+ (forward-char symbol-width)
+ ;; Draw graph column by column.
+ (sit-for 0)
+ (setq numbers-list (cdr numbers-list)))
+ ;; Place point for X axis labels.
+ (forward-line height)
+ (insert "\n")))
+
+Finally, the code for the `print-graph' function:
+
+ ;;; Final version.
+ (defun print-graph
+ (numbers-list &optional vertical-step)
+ "Print labelled bar graph of the NUMBERS-LIST.
+ The numbers-list consists of the Y-axis values.
+
+ Optionally, VERTICAL-STEP, a positive integer,
+ specifies how much a Y axis label increments for
+ each line. For example, a step of 5 means that
+ each row is five units."
+ (let* ((symbol-width (length graph-blank))
+ ;; `height' is both the largest number
+ ;; and the number with the most digits.
+ (height (apply 'max numbers-list))
+ (height-of-top-line
+ (if (zerop (% height Y-axis-label-spacing))
+ height
+ ;; else
+ (* (1+ (/ height Y-axis-label-spacing))
+ Y-axis-label-spacing)))
+ (vertical-step (or vertical-step 1))
+ (full-Y-label-width
+ (length
+ (concat
+ (number-to-string
+ (* height-of-top-line vertical-step))
+ Y-axis-tic))))
+
+ (print-Y-axis
+ height-of-top-line full-Y-label-width vertical-step)
+ (graph-body-print
+ numbers-list height-of-top-line symbol-width)
+ (print-X-axis numbers-list)))
+
+\1f
+File: eintr, Node: Test print-graph, Next: Graphing words in defuns, Prev: The final version, Up: Print Whole Graph
+
+C.4.1 Testing `print-graph'
+---------------------------
+
+We can test the `print-graph' function with a short list of numbers:
+
+ 1. Install the final versions of `Y-axis-column', `graph-body-print',
+ and `print-graph' (in addition to the rest of the code.)
+
+ 2. Copy the following expression:
+
+ (print-graph '(3 2 5 6 7 5 3 4 6 4 3 2 1))
+
+ 3. Switch to the `*scratch*' buffer and place the cursor where you
+ want the axis labels to start.
+
+ 4. Type `M-:' (`eval-expression').
+
+ 5. Yank the test expression into the minibuffer with `C-y' (`yank)'.
+
+ 6. Press <RET> to evaluate the expression.
+
+Emacs will print a graph that looks like this:
+
+ 10 -
+
+
+ *
+ ** *
+ 5 - **** *
+ **** ***
+ * *********
+ ************
+ 1 - *************
+
+ | | | |
+ 1 5 10 15
+
+On the other hand, if you pass `print-graph' a `vertical-step' value of
+2, by evaluating this expression:
+
+ (print-graph '(3 2 5 6 7 5 3 4 6 4 3 2 1) 2)
+
+The graph looks like this:
+
+ 20 -
+
+
+ *
+ ** *
+ 10 - **** *
+ **** ***
+ * *********
+ ************
+ 2 - *************
+
+ | | | |
+ 1 5 10 15
+
+(A question: is the `2' on the bottom of the vertical axis a bug or a
+feature? If you think it is a bug, and should be a `1' instead, (or
+even a `0'), you can modify the sources.)
+
+\1f
+File: eintr, Node: Graphing words in defuns, Next: lambda, Prev: Test print-graph, Up: Print Whole Graph
+
+C.4.2 Graphing Numbers of Words and Symbols
+-------------------------------------------
+
+Now for the graph for which all this code was written: a graph that
+shows how many function definitions contain fewer than 10 words and
+symbols, how many contain between 10 and 19 words and symbols, how many
+contain between 20 and 29 words and symbols, and so on.
+
+This is a multi-step process. First make sure you have loaded all the
+requisite code.
+
+It is a good idea to reset the value of `top-of-ranges' in case you
+have set it to some different value. You can evaluate the following:
+
+ (setq top-of-ranges
+ '(10 20 30 40 50
+ 60 70 80 90 100
+ 110 120 130 140 150
+ 160 170 180 190 200
+ 210 220 230 240 250
+ 260 270 280 290 300)
+
+Next create a list of the number of words and symbols in each range.
+
+Evaluate the following:
+
+ (setq list-for-graph
+ (defuns-per-range
+ (sort
+ (recursive-lengths-list-many-files
+ (directory-files "/usr/local/emacs/lisp"
+ t ".+el$"))
+ '<)
+ top-of-ranges))
+
+On my old machine, this took about an hour. It looked though 303 Lisp
+files in my copy of Emacs version 19.23. After all that computing, the
+`list-for-graph' had this value:
+
+ (537 1027 955 785 594 483 349 292 224 199 166 120 116 99
+ 90 80 67 48 52 45 41 33 28 26 25 20 12 28 11 13 220)
+
+This means that my copy of Emacs had 537 function definitions with
+fewer than 10 words or symbols in them, 1,027 function definitions with
+10 to 19 words or symbols in them, 955 function definitions with 20 to
+29 words or symbols in them, and so on.
+
+Clearly, just by looking at this list we can see that most function
+definitions contain ten to thirty words and symbols.
+
+Now for printing. We do _not_ want to print a graph that is 1,030
+lines high ... Instead, we should print a graph that is fewer than
+twenty-five lines high. A graph that height can be displayed on almost
+any monitor, and easily printed on a sheet of paper.
+
+This means that each value in `list-for-graph' must be reduced to
+one-fiftieth its present value.
+
+Here is a short function to do just that, using two functions we have
+not yet seen, `mapcar' and `lambda'.
+
+ (defun one-fiftieth (full-range)
+ "Return list, each number one-fiftieth of previous."
+ (mapcar '(lambda (arg) (/ arg 50)) full-range))
+
+\1f
+File: eintr, Node: lambda, Next: mapcar, Prev: Graphing words in defuns, Up: Print Whole Graph
+
+C.4.3 A `lambda' Expression: Useful Anonymity
+---------------------------------------------
+
+`lambda' is the symbol for an anonymous function, a function without a
+name. Every time you use an anonymous function, you need to include
+its whole body.
+
+Thus,
+
+ (lambda (arg) (/ arg 50))
+
+is a function definition that says `return the value resulting from
+dividing whatever is passed to me as `arg' by 50'.
+
+Earlier, for example, we had a function `multiply-by-seven'; it
+multiplied its argument by 7. This function is similar, except it
+divides its argument by 50; and, it has no name. The anonymous
+equivalent of `multiply-by-seven' is:
+
+ (lambda (number) (* 7 number))
+
+(*Note The `defun' Special Form: defun.)
+
+If we want to multiply 3 by 7, we can write:
+
+ (multiply-by-seven 3)
+ \_______________/ ^
+ | |
+ function argument
+
+
+
+This expression returns 21.
+
+Similarly, we can write:
+
+ ((lambda (number) (* 7 number)) 3)
+ \____________________________/ ^
+ | |
+ anonymous function argument
+
+
+
+If we want to divide 100 by 50, we can write:
+
+ ((lambda (arg) (/ arg 50)) 100)
+ \______________________/ \_/
+ | |
+ anonymous function argument
+
+
+
+This expression returns 2. The 100 is passed to the function, which
+divides that number by 50.
+
+*Note Lambda Expressions: (elisp)Lambda Expressions, for more about
+`lambda'. Lisp and lambda expressions derive from the Lambda Calculus.
+
+\1f
+File: eintr, Node: mapcar, Next: Another Bug, Prev: lambda, Up: Print Whole Graph
+
+C.4.4 The `mapcar' Function
+---------------------------
+
+`mapcar' is a function that calls its first argument with each element
+of its second argument, in turn. The second argument must be a
+sequence.
+
+The `map' part of the name comes from the mathematical phrase, `mapping
+over a domain', meaning to apply a function to each of the elements in
+a domain. The mathematical phrase is based on the metaphor of a
+surveyor walking, one step at a time, over an area he is mapping. And
+`car', of course, comes from the Lisp notion of the first of a list.
+
+For example,
+
+ (mapcar '1+ '(2 4 6))
+ => (3 5 7)
+
+The function `1+' which adds one to its argument, is executed on _each_
+element of the list, and a new list is returned.
+
+Contrast this with `apply', which applies its first argument to all the
+remaining. (*Note Readying a Graph: Readying a Graph, for a
+explanation of `apply'.)
+
+In the definition of `one-fiftieth', the first argument is the
+anonymous function:
+
+ (lambda (arg) (/ arg 50))
+
+and the second argument is `full-range', which will be bound to
+`list-for-graph'.
+
+The whole expression looks like this:
+
+ (mapcar '(lambda (arg) (/ arg 50)) full-range))
+
+*Note Mapping Functions: (elisp)Mapping Functions, for more about
+`mapcar'.
+
+Using the `one-fiftieth' function, we can generate a list in which each
+element is one-fiftieth the size of the corresponding element in
+`list-for-graph'.
+
+ (setq fiftieth-list-for-graph
+ (one-fiftieth list-for-graph))
+
+The resulting list looks like this:
+
+ (10 20 19 15 11 9 6 5 4 3 3 2 2
+ 1 1 1 1 0 1 0 0 0 0 0 0 0 0 0 0 0 4)
+
+This, we are almost ready to print! (We also notice the loss of
+information: many of the higher ranges are 0, meaning that fewer than
+50 defuns had that many words or symbols--but not necessarily meaning
+that none had that many words or symbols.)
+
+\1f
+File: eintr, Node: Another Bug, Next: Final printed graph, Prev: mapcar, Up: Print Whole Graph
+
+C.4.5 Another Bug ... Most Insidious
+------------------------------------
+
+I said `almost ready to print'! Of course, there is a bug in the
+`print-graph' function ... It has a `vertical-step' option, but not a
+`horizontal-step' option. The `top-of-range' scale goes from 10 to 300
+by tens. But the `print-graph' function will print only by ones.
+
+This is a classic example of what some consider the most insidious type
+of bug, the bug of omission. This is not the kind of bug you can find
+by studying the code, for it is not in the code; it is an omitted
+feature. Your best actions are to try your program early and often;
+and try to arrange, as much as you can, to write code that is easy to
+understand and easy to change. Try to be aware, whenever you can, that
+whatever you have written, _will_ be rewritten, if not soon,
+eventually. A hard maxim to follow.
+
+It is the `print-X-axis-numbered-line' function that needs the work;
+and then the `print-X-axis' and the `print-graph' functions need to be
+adapted. Not much needs to be done; there is one nicety: the numbers
+ought to line up under the tic marks. This takes a little thought.
+
+Here is the corrected `print-X-axis-numbered-line':
+
+ (defun print-X-axis-numbered-line
+ (number-of-X-tics X-axis-leading-spaces
+ &optional horizontal-step)
+ "Print line of X-axis numbers"
+ (let ((number X-axis-label-spacing)
+ (horizontal-step (or horizontal-step 1)))
+ (insert X-axis-leading-spaces)
+ ;; Delete extra leading spaces.
+ (delete-char
+ (- (1-
+ (length (number-to-string horizontal-step)))))
+ (insert (concat
+ (make-string
+ ;; Insert white space.
+ (- (* symbol-width
+ X-axis-label-spacing)
+ (1-
+ (length
+ (number-to-string horizontal-step)))
+ 2)
+ ? )
+ (number-to-string
+ (* number horizontal-step))))
+ ;; Insert remaining numbers.
+ (setq number (+ number X-axis-label-spacing))
+ (while (> number-of-X-tics 1)
+ (insert (X-axis-element
+ (* number horizontal-step)))
+ (setq number (+ number X-axis-label-spacing))
+ (setq number-of-X-tics (1- number-of-X-tics)))))
+
+If you are reading this in Info, you can see the new versions of
+`print-X-axis' `print-graph' and evaluate them. If you are reading
+this in a printed book, you can see the changed lines here (the full
+text is too much to print).
+
+ (defun print-X-axis (numbers-list horizontal-step)
+ "Print X axis labels to length of NUMBERS-LIST.
+ Optionally, HORIZONTAL-STEP, a positive integer,
+ specifies how much an X axis label increments for
+ each column."
+ ;; Value of symbol-width and full-Y-label-width
+ ;; are passed by `print-graph'.
+ (let* ((leading-spaces
+ (make-string full-Y-label-width ? ))
+ ;; symbol-width is provided by graph-body-print
+ (tic-width (* symbol-width X-axis-label-spacing))
+ (X-length (length numbers-list))
+ (X-tic
+ (concat
+ (make-string
+ ;; Make a string of blanks.
+ (- (* symbol-width X-axis-label-spacing)
+ (length X-axis-tic-symbol))
+ ? )
+ ;; Concatenate blanks with tic symbol.
+ X-axis-tic-symbol))
+ (tic-number
+ (if (zerop (% X-length tic-width))
+ (/ X-length tic-width)
+ (1+ (/ X-length tic-width)))))
+
+ (print-X-axis-tic-line
+ tic-number leading-spaces X-tic)
+ (insert "\n")
+ (print-X-axis-numbered-line
+ tic-number leading-spaces horizontal-step)))
+
+ (defun print-graph
+ (numbers-list &optional vertical-step horizontal-step)
+ "Print labelled bar graph of the NUMBERS-LIST.
+ The numbers-list consists of the Y-axis values.
+
+ Optionally, VERTICAL-STEP, a positive integer,
+ specifies how much a Y axis label increments for
+ each line. For example, a step of 5 means that
+ each row is five units.
+
+ Optionally, HORIZONTAL-STEP, a positive integer,
+ specifies how much an X axis label increments for
+ each column."
+ (let* ((symbol-width (length graph-blank))
+ ;; `height' is both the largest number
+ ;; and the number with the most digits.
+ (height (apply 'max numbers-list))
+ (height-of-top-line
+ (if (zerop (% height Y-axis-label-spacing))
+ height
+ ;; else
+ (* (1+ (/ height Y-axis-label-spacing))
+ Y-axis-label-spacing)))
+ (vertical-step (or vertical-step 1))
+ (full-Y-label-width
+ (length
+ (concat
+ (number-to-string
+ (* height-of-top-line vertical-step))
+ Y-axis-tic))))
+ (print-Y-axis
+ height-of-top-line full-Y-label-width vertical-step)
+ (graph-body-print
+ numbers-list height-of-top-line symbol-width)
+ (print-X-axis numbers-list horizontal-step)))
+
+\1f
+File: eintr, Node: Final printed graph, Prev: Another Bug, Up: Print Whole Graph
+
+C.4.6 The Printed Graph
+-----------------------
+
+When made and installed, you can call the `print-graph' command like
+this:
+
+ (print-graph fiftieth-list-for-graph 50 10)
+
+
+Here is the graph:
+
+
+ 1000 - *
+ **
+ **
+ **
+ **
+ 750 - ***
+ ***
+ ***
+ ***
+ ****
+ 500 - *****
+ ******
+ ******
+ ******
+ *******
+ 250 - ********
+ ********* *
+ *********** *
+ ************* *
+ 50 - ***************** * *
+ | | | | | | | |
+ 10 50 100 150 200 250 300 350
+
+
+
+The largest group of functions contain 10 - 19 words and symbols each.
+
+\1f
+File: eintr, Node: Free Software and Free Manuals, Next: GNU Free Documentation License, Prev: Full Graph, Up: Top
+
+Appendix D Free Software and Free Manuals
+*****************************************
+
+*by Richard M. Stallman*
+
+The biggest deficiency in free operating systems is not in the
+software--it is the lack of good free manuals that we can include in
+these systems. Many of our most important programs do not come with
+full manuals. Documentation is an essential part of any software
+package; when an important free software package does not come with a
+free manual, that is a major gap. We have many such gaps today.
+
+Once upon a time, many years ago, I thought I would learn Perl. I got
+a copy of a free manual, but I found it hard to read. When I asked
+Perl users about alternatives, they told me that there were better
+introductory manuals--but those were not free.
+
+Why was this? The authors of the good manuals had written them for
+O'Reilly Associates, which published them with restrictive terms--no
+copying, no modification, source files not available--which exclude
+them from the free software community.
+
+That wasn't the first time this sort of thing has happened, and (to our
+community's great loss) it was far from the last. Proprietary manual
+publishers have enticed a great many authors to restrict their manuals
+since then. Many times I have heard a GNU user eagerly tell me about a
+manual that he is writing, with which he expects to help the GNU
+project--and then had my hopes dashed, as he proceeded to explain that
+he had signed a contract with a publisher that would restrict it so
+that we cannot use it.
+
+Given that writing good English is a rare skill among programmers, we
+can ill afford to lose manuals this way.
+
+(The Free Software Foundation sells printed copies of free GNU manuals
+(http://www.gnu.org/doc/doc.html), too.)
+
+Free documentation, like free software, is a matter of freedom, not
+price. The problem with these manuals was not that O'Reilly Associates
+charged a price for printed copies--that in itself is fine. (The Free
+Software Foundation sells printed copies of free GNU manuals, too.)
+But GNU manuals are available in source code form, while these manuals
+are available only on paper. GNU manuals come with permission to copy
+and modify; the Perl manuals do not. These restrictions are the
+problems.
+
+The criterion for a free manual is pretty much the same as for free
+software: it is a matter of giving all users certain freedoms.
+Redistribution (including commercial redistribution) must be permitted,
+so that the manual can accompany every copy of the program, on-line or
+on paper. Permission for modification is crucial too.
+
+As a general rule, I don't believe that it is essential for people to
+have permission to modify all sorts of articles and books. The issues
+for writings are not necessarily the same as those for software. For
+example, I don't think you or I are obliged to give permission to
+modify articles like this one, which describe our actions and our views.
+
+But there is a particular reason why the freedom to modify is crucial
+for documentation for free software. When people exercise their right
+to modify the software, and add or change its features, if they are
+conscientious they will change the manual too--so they can provide
+accurate and usable documentation with the modified program. A manual
+which forbids programmers to be conscientious and finish the job, or
+more precisely requires them to write a new manual from scratch if they
+change the program, does not fill our community's needs.
+
+While a blanket prohibition on modification is unacceptable, some kinds
+of limits on the method of modification pose no problem. For example,
+requirements to preserve the original author's copyright notice, the
+distribution terms, or the list of authors, are ok. It is also no
+problem to require modified versions to include notice that they were
+modified, even to have entire sections that may not be deleted or
+changed, as long as these sections deal with nontechnical topics.
+(Some GNU manuals have them.)
+
+These kinds of restrictions are not a problem because, as a practical
+matter, they don't stop the conscientious programmer from adapting the
+manual to fit the modified program. In other words, they don't block
+the free software community from making full use of the manual.
+
+However, it must be possible to modify all the technical content of the
+manual, and then distribute the result in all the usual media, through
+all the usual channels; otherwise, the restrictions do block the
+community, the manual is not free, and so we need another manual.
+
+Unfortunately, it is often hard to find someone to write another manual
+when a proprietary manual exists. The obstacle is that many users
+think that a proprietary manual is good enough--so they don't see the
+need to write a free manual. They do not see that the free operating
+system has a gap that needs filling.
+
+Why do users think that proprietary manuals are good enough? Some have
+not considered the issue. I hope this article will do something to
+change that.
+
+Other users consider proprietary manuals acceptable for the same reason
+so many people consider proprietary software acceptable: they judge in
+purely practical terms, not using freedom as a criterion. These people
+are entitled to their opinions, but since those opinions spring from
+values which do not include freedom, they are no guide for those of us
+who do value freedom.
+
+Please spread the word about this issue. We continue to lose manuals
+to proprietary publishing. If we spread the word that proprietary
+manuals are not sufficient, perhaps the next person who wants to help
+GNU by writing documentation will realize, before it is too late, that
+he must above all make it free.
+
+We can also encourage commercial publishers to sell free, copylefted
+manuals instead of proprietary ones. One way you can help this is to
+check the distribution terms of a manual before you buy it, and prefer
+copylefted manuals to non-copylefted ones.
+
+
+
+Note: The Free Software Foundation maintains a page on its Web site
+that lists free books available from other publishers:
+`http://www.gnu.org/doc/other-free-books.html'
+
+\1f
+File: eintr, Node: GNU Free Documentation License, Next: Index, Prev: Free Software and Free Manuals, Up: Top
+
+Appendix E GNU Free Documentation License
+*****************************************
+
+ Version 1.2, November 2002
+
+ Copyright (C) 2000,2001,2002 Free Software Foundation, Inc.
+ 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA
+
+ Everyone is permitted to copy and distribute verbatim copies
+ of this license document, but changing it is not allowed.
+
+ 0. PREAMBLE
+
+ The purpose of this License is to make a manual, textbook, or other
+ functional and useful document "free" in the sense of freedom: to
+ assure everyone the effective freedom to copy and redistribute it,
+ with or without modifying it, either commercially or
+ noncommercially. Secondarily, this License preserves for the
+ author and publisher a way to get credit for their work, while not
+ being considered responsible for modifications made by others.
+
+ This License is a kind of "copyleft", which means that derivative
+ works of the document must themselves be free in the same sense.
+ It complements the GNU General Public License, which is a copyleft
+ license designed for free software.
+
+ We have designed this License in order to use it for manuals for
+ free software, because free software needs free documentation: a
+ free program should come with manuals providing the same freedoms
+ that the software does. But this License is not limited to
+ software manuals; it can be used for any textual work, regardless
+ of subject matter or whether it is published as a printed book.
+ We recommend this License principally for works whose purpose is
+ instruction or reference.
+
+ 1. APPLICABILITY AND DEFINITIONS
+
+ This License applies to any manual or other work, in any medium,
+ that contains a notice placed by the copyright holder saying it
+ can be distributed under the terms of this License. Such a notice
+ grants a world-wide, royalty-free license, unlimited in duration,
+ to use that work under the conditions stated herein. The
+ "Document", below, refers to any such manual or work. Any member
+ of the public is a licensee, and is addressed as "you". You
+ accept the license if you copy, modify or distribute the work in a
+ way requiring permission under copyright law.
+
+ A "Modified Version" of the Document means any work containing the
+ Document or a portion of it, either copied verbatim, or with
+ modifications and/or translated into another language.
+
+ A "Secondary Section" is a named appendix or a front-matter section
+ of the Document that deals exclusively with the relationship of the
+ publishers or authors of the Document to the Document's overall
+ subject (or to related matters) and contains nothing that could
+ fall directly within that overall subject. (Thus, if the Document
+ is in part a textbook of mathematics, a Secondary Section may not
+ explain any mathematics.) The relationship could be a matter of
+ historical connection with the subject or with related matters, or
+ of legal, commercial, philosophical, ethical or political position
+ regarding them.
+
+ The "Invariant Sections" are certain Secondary Sections whose
+ titles are designated, as being those of Invariant Sections, in
+ the notice that says that the Document is released under this
+ License. If a section does not fit the above definition of
+ Secondary then it is not allowed to be designated as Invariant.
+ The Document may contain zero Invariant Sections. If the Document
+ does not identify any Invariant Sections then there are none.
+
+ The "Cover Texts" are certain short passages of text that are
+ listed, as Front-Cover Texts or Back-Cover Texts, in the notice
+ that says that the Document is released under this License. A
+ Front-Cover Text may be at most 5 words, and a Back-Cover Text may
+ be at most 25 words.
+
+ A "Transparent" copy of the Document means a machine-readable copy,
+ represented in a format whose specification is available to the
+ general public, that is suitable for revising the document
+ straightforwardly with generic text editors or (for images
+ composed of pixels) generic paint programs or (for drawings) some
+ widely available drawing editor, and that is suitable for input to
+ text formatters or for automatic translation to a variety of
+ formats suitable for input to text formatters. A copy made in an
+ otherwise Transparent file format whose markup, or absence of
+ markup, has been arranged to thwart or discourage subsequent
+ modification by readers is not Transparent. An image format is
+ not Transparent if used for any substantial amount of text. A
+ copy that is not "Transparent" is called "Opaque".
+
+ Examples of suitable formats for Transparent copies include plain
+ ASCII without markup, Texinfo input format, LaTeX input format,
+ SGML or XML using a publicly available DTD, and
+ standard-conforming simple HTML, PostScript or PDF designed for
+ human modification. Examples of transparent image formats include
+ PNG, XCF and JPG. Opaque formats include proprietary formats that
+ can be read and edited only by proprietary word processors, SGML or
+ XML for which the DTD and/or processing tools are not generally
+ available, and the machine-generated HTML, PostScript or PDF
+ produced by some word processors for output purposes only.
+
+ The "Title Page" means, for a printed book, the title page itself,
+ plus such following pages as are needed to hold, legibly, the
+ material this License requires to appear in the title page. For
+ works in formats which do not have any title page as such, "Title
+ Page" means the text near the most prominent appearance of the
+ work's title, preceding the beginning of the body of the text.
+
+ A section "Entitled XYZ" means a named subunit of the Document
+ whose title either is precisely XYZ or contains XYZ in parentheses
+ following text that translates XYZ in another language. (Here XYZ
+ stands for a specific section name mentioned below, such as
+ "Acknowledgements", "Dedications", "Endorsements", or "History".)
+ To "Preserve the Title" of such a section when you modify the
+ Document means that it remains a section "Entitled XYZ" according
+ to this definition.
+
+ The Document may include Warranty Disclaimers next to the notice
+ which states that this License applies to the Document. These
+ Warranty Disclaimers are considered to be included by reference in
+ this License, but only as regards disclaiming warranties: any other
+ implication that these Warranty Disclaimers may have is void and
+ has no effect on the meaning of this License.
+
+ 2. VERBATIM COPYING
+
+ You may copy and distribute the Document in any medium, either
+ commercially or noncommercially, provided that this License, the
+ copyright notices, and the license notice saying this License
+ applies to the Document are reproduced in all copies, and that you
+ add no other conditions whatsoever to those of this License. You
+ may not use technical measures to obstruct or control the reading
+ or further copying of the copies you make or distribute. However,
+ you may accept compensation in exchange for copies. If you
+ distribute a large enough number of copies you must also follow
+ the conditions in section 3.
+
+ You may also lend copies, under the same conditions stated above,
+ and you may publicly display copies.
+
+ 3. COPYING IN QUANTITY
+
+ If you publish printed copies (or copies in media that commonly
+ have printed covers) of the Document, numbering more than 100, and
+ the Document's license notice requires Cover Texts, you must
+ enclose the copies in covers that carry, clearly and legibly, all
+ these Cover Texts: Front-Cover Texts on the front cover, and
+ Back-Cover Texts on the back cover. Both covers must also clearly
+ and legibly identify you as the publisher of these copies. The
+ front cover must present the full title with all words of the
+ title equally prominent and visible. You may add other material
+ on the covers in addition. Copying with changes limited to the
+ covers, as long as they preserve the title of the Document and
+ satisfy these conditions, can be treated as verbatim copying in
+ other respects.
+
+ If the required texts for either cover are too voluminous to fit
+ legibly, you should put the first ones listed (as many as fit
+ reasonably) on the actual cover, and continue the rest onto
+ adjacent pages.
+
+ If you publish or distribute Opaque copies of the Document
+ numbering more than 100, you must either include a
+ machine-readable Transparent copy along with each Opaque copy, or
+ state in or with each Opaque copy a computer-network location from
+ which the general network-using public has access to download
+ using public-standard network protocols a complete Transparent
+ copy of the Document, free of added material. If you use the
+ latter option, you must take reasonably prudent steps, when you
+ begin distribution of Opaque copies in quantity, to ensure that
+ this Transparent copy will remain thus accessible at the stated
+ location until at least one year after the last time you
+ distribute an Opaque copy (directly or through your agents or
+ retailers) of that edition to the public.
+
+ It is requested, but not required, that you contact the authors of
+ the Document well before redistributing any large number of
+ copies, to give them a chance to provide you with an updated
+ version of the Document.
+
+ 4. MODIFICATIONS
+
+ You may copy and distribute a Modified Version of the Document
+ under the conditions of sections 2 and 3 above, provided that you
+ release the Modified Version under precisely this License, with
+ the Modified Version filling the role of the Document, thus
+ licensing distribution and modification of the Modified Version to
+ whoever possesses a copy of it. In addition, you must do these
+ things in the Modified Version:
+
+ A. Use in the Title Page (and on the covers, if any) a title
+ distinct from that of the Document, and from those of
+ previous versions (which should, if there were any, be listed
+ in the History section of the Document). You may use the
+ same title as a previous version if the original publisher of
+ that version gives permission.
+
+ B. List on the Title Page, as authors, one or more persons or
+ entities responsible for authorship of the modifications in
+ the Modified Version, together with at least five of the
+ principal authors of the Document (all of its principal
+ authors, if it has fewer than five), unless they release you
+ from this requirement.
+
+ C. State on the Title page the name of the publisher of the
+ Modified Version, as the publisher.
+
+ D. Preserve all the copyright notices of the Document.
+
+ E. Add an appropriate copyright notice for your modifications
+ adjacent to the other copyright notices.
+
+ F. Include, immediately after the copyright notices, a license
+ notice giving the public permission to use the Modified
+ Version under the terms of this License, in the form shown in
+ the Addendum below.
+
+ G. Preserve in that license notice the full lists of Invariant
+ Sections and required Cover Texts given in the Document's
+ license notice.
+
+ H. Include an unaltered copy of this License.
+
+ I. Preserve the section Entitled "History", Preserve its Title,
+ and add to it an item stating at least the title, year, new
+ authors, and publisher of the Modified Version as given on
+ the Title Page. If there is no section Entitled "History" in
+ the Document, create one stating the title, year, authors,
+ and publisher of the Document as given on its Title Page,
+ then add an item describing the Modified Version as stated in
+ the previous sentence.
+
+ J. Preserve the network location, if any, given in the Document
+ for public access to a Transparent copy of the Document, and
+ likewise the network locations given in the Document for
+ previous versions it was based on. These may be placed in
+ the "History" section. You may omit a network location for a
+ work that was published at least four years before the
+ Document itself, or if the original publisher of the version
+ it refers to gives permission.
+
+ K. For any section Entitled "Acknowledgements" or "Dedications",
+ Preserve the Title of the section, and preserve in the
+ section all the substance and tone of each of the contributor
+ acknowledgements and/or dedications given therein.
+
+ L. Preserve all the Invariant Sections of the Document,
+ unaltered in their text and in their titles. Section numbers
+ or the equivalent are not considered part of the section
+ titles.
+
+ M. Delete any section Entitled "Endorsements". Such a section
+ may not be included in the Modified Version.
+
+ N. Do not retitle any existing section to be Entitled
+ "Endorsements" or to conflict in title with any Invariant
+ Section.
+
+ O. Preserve any Warranty Disclaimers.
+
+ If the Modified Version includes new front-matter sections or
+ appendices that qualify as Secondary Sections and contain no
+ material copied from the Document, you may at your option
+ designate some or all of these sections as invariant. To do this,
+ add their titles to the list of Invariant Sections in the Modified
+ Version's license notice. These titles must be distinct from any
+ other section titles.
+
+ You may add a section Entitled "Endorsements", provided it contains
+ nothing but endorsements of your Modified Version by various
+ parties--for example, statements of peer review or that the text
+ has been approved by an organization as the authoritative
+ definition of a standard.
+
+ You may add a passage of up to five words as a Front-Cover Text,
+ and a passage of up to 25 words as a Back-Cover Text, to the end
+ of the list of Cover Texts in the Modified Version. Only one
+ passage of Front-Cover Text and one of Back-Cover Text may be
+ added by (or through arrangements made by) any one entity. If the
+ Document already includes a cover text for the same cover,
+ previously added by you or by arrangement made by the same entity
+ you are acting on behalf of, you may not add another; but you may
+ replace the old one, on explicit permission from the previous
+ publisher that added the old one.
+
+ The author(s) and publisher(s) of the Document do not by this
+ License give permission to use their names for publicity for or to
+ assert or imply endorsement of any Modified Version.
+
+ 5. COMBINING DOCUMENTS
+
+ You may combine the Document with other documents released under
+ this License, under the terms defined in section 4 above for
+ modified versions, provided that you include in the combination
+ all of the Invariant Sections of all of the original documents,
+ unmodified, and list them all as Invariant Sections of your
+ combined work in its license notice, and that you preserve all
+ their Warranty Disclaimers.
+
+ The combined work need only contain one copy of this License, and
+ multiple identical Invariant Sections may be replaced with a single
+ copy. If there are multiple Invariant Sections with the same name
+ but different contents, make the title of each such section unique
+ by adding at the end of it, in parentheses, the name of the
+ original author or publisher of that section if known, or else a
+ unique number. Make the same adjustment to the section titles in
+ the list of Invariant Sections in the license notice of the
+ combined work.
+
+ In the combination, you must combine any sections Entitled
+ "History" in the various original documents, forming one section
+ Entitled "History"; likewise combine any sections Entitled
+ "Acknowledgements", and any sections Entitled "Dedications". You
+ must delete all sections Entitled "Endorsements."
+
+ 6. COLLECTIONS OF DOCUMENTS
+
+ You may make a collection consisting of the Document and other
+ documents released under this License, and replace the individual
+ copies of this License in the various documents with a single copy
+ that is included in the collection, provided that you follow the
+ rules of this License for verbatim copying of each of the
+ documents in all other respects.
+
+ You may extract a single document from such a collection, and
+ distribute it individually under this License, provided you insert
+ a copy of this License into the extracted document, and follow
+ this License in all other respects regarding verbatim copying of
+ that document.
+
+ 7. AGGREGATION WITH INDEPENDENT WORKS
+
+ A compilation of the Document or its derivatives with other
+ separate and independent documents or works, in or on a volume of
+ a storage or distribution medium, is called an "aggregate" if the
+ copyright resulting from the compilation is not used to limit the
+ legal rights of the compilation's users beyond what the individual
+ works permit. When the Document is included in an aggregate, this
+ License does not apply to the other works in the aggregate which
+ are not themselves derivative works of the Document.
+
+ If the Cover Text requirement of section 3 is applicable to these
+ copies of the Document, then if the Document is less than one half
+ of the entire aggregate, the Document's Cover Texts may be placed
+ on covers that bracket the Document within the aggregate, or the
+ electronic equivalent of covers if the Document is in electronic
+ form. Otherwise they must appear on printed covers that bracket
+ the whole aggregate.
+
+ 8. TRANSLATION
+
+ Translation is considered a kind of modification, so you may
+ distribute translations of the Document under the terms of section
+ 4. Replacing Invariant Sections with translations requires special
+ permission from their copyright holders, but you may include
+ translations of some or all Invariant Sections in addition to the
+ original versions of these Invariant Sections. You may include a
+ translation of this License, and all the license notices in the
+ Document, and any Warranty Disclaimers, provided that you also
+ include the original English version of this License and the
+ original versions of those notices and disclaimers. In case of a
+ disagreement between the translation and the original version of
+ this License or a notice or disclaimer, the original version will
+ prevail.
+
+ If a section in the Document is Entitled "Acknowledgements",
+ "Dedications", or "History", the requirement (section 4) to
+ Preserve its Title (section 1) will typically require changing the
+ actual title.
+
+ 9. TERMINATION
+
+ You may not copy, modify, sublicense, or distribute the Document
+ except as expressly provided for under this License. Any other
+ attempt to copy, modify, sublicense or distribute the Document is
+ void, and will automatically terminate your rights under this
+ License. However, parties who have received copies, or rights,
+ from you under this License will not have their licenses
+ terminated so long as such parties remain in full compliance.
+
+ 10. FUTURE REVISIONS OF THIS LICENSE
+
+ The Free Software Foundation may publish new, revised versions of
+ the GNU Free Documentation License from time to time. Such new
+ versions will be similar in spirit to the present version, but may
+ differ in detail to address new problems or concerns. See
+ `http://www.gnu.org/copyleft/'.
+
+ Each version of the License is given a distinguishing version
+ number. If the Document specifies that a particular numbered
+ version of this License "or any later version" applies to it, you
+ have the option of following the terms and conditions either of
+ that specified version or of any later version that has been
+ published (not as a draft) by the Free Software Foundation. If
+ the Document does not specify a version number of this License,
+ you may choose any version ever published (not as a draft) by the
+ Free Software Foundation.
+
+E.0.1 ADDENDUM: How to use this License for your documents
+----------------------------------------------------------
+
+To use this License in a document you have written, include a copy of
+the License in the document and put the following copyright and license
+notices just after the title page:
+
+ Copyright (C) YEAR YOUR NAME.
+ Permission is granted to copy, distribute and/or modify this document
+ under the terms of the GNU Free Documentation License, Version 1.2
+ or any later version published by the Free Software Foundation;
+ with no Invariant Sections, no Front-Cover Texts, and no Back-Cover Texts.
+ A copy of the license is included in the section entitled ``GNU
+ Free Documentation License''.
+
+If you have Invariant Sections, Front-Cover Texts and Back-Cover Texts,
+replace the "with...Texts." line with this:
+
+ with the Invariant Sections being LIST THEIR TITLES, with
+ the Front-Cover Texts being LIST, and with the Back-Cover Texts
+ being LIST.
+
+If you have Invariant Sections without Cover Texts, or some other
+combination of the three, merge those two alternatives to suit the
+situation.
+
+If your document contains nontrivial examples of program code, we
+recommend releasing these examples in parallel under your choice of
+free software license, such as the GNU General Public License, to
+permit their use in free software.
+
+\1f
+File: eintr, Node: Index, Next: About the Author, Prev: GNU Free Documentation License, Up: Top
+
+Index
+*****
+
+\0\b[index\0\b]
+* Menu:
+
+* % (remainder function): Compute a Remainder. (line 6)
+* (debug) in code: debug-on-quit. (line 13)
+* * (multiplication): defun. (line 101)
+* * for read-only buffer: Read-only buffer. (line 6)
+* *scratch* buffer: print-elements-of-list.
+ (line 9)
+* .emacs file: Emacs Initialization.
+ (line 6)
+* .emacs file, beginning of: Beginning a .emacs File.
+ (line 6)
+* / (division): Large buffer case. (line 38)
+* <= (less than or equal): Inc Example parts. (line 47)
+* > (greater than): if in more detail. (line 32)
+* Accumulate, type of recursive pattern: Accumulate. (line 6)
+* add-hook: Text and Auto-fill. (line 55)
+* and <1>: fwd-para let. (line 45)
+* and: kill-new function. (line 213)
+* Anonymous function: lambda. (line 6)
+* append-to-buffer: append-to-buffer. (line 6)
+* apply: Columns of a graph. (line 141)
+* apropos: Columns of a graph. (line 32)
+* Argument as local variable: Dec Example altogether.
+ (line 27)
+* argument defined: Arguments. (line 16)
+* argument list defined: defun. (line 60)
+* Argument, wrong type of: Wrong Type of Argument.
+ (line 6)
+* Arguments: Arguments. (line 6)
+* Arguments' data types: Data types. (line 6)
+* Arguments, variable number of: Variable Number of Arguments.
+ (line 6)
+* Asterisk for read-only buffer: Read-only buffer. (line 6)
+* Auto Fill mode turned on: Text and Auto-fill. (line 55)
+* autoload: Autoload. (line 6)
+* Automatic mode selection: Text and Auto-fill. (line 23)
+* Axis, print horizontal: print-X-axis. (line 6)
+* Axis, print vertical: print-Y-axis. (line 6)
+* beginning-of-buffer: beginning-of-buffer. (line 6)
+* bind defined: set & setq. (line 6)
+* Bindings, key, fixing unpleasant: Miscellaneous. (line 88)
+* body defined: defun. (line 38)
+* Body of graph: Readying a Graph. (line 6)
+* Buffer size: Buffer Size & Locations.
+ (line 6)
+* Buffer, history of word: Buffer Names. (line 66)
+* buffer-file-name: Buffer Names. (line 6)
+* buffer-menu, bound to key: Keybindings. (line 68)
+* buffer-name: Buffer Names. (line 6)
+* Bug, most insidious type: Another Bug. (line 6)
+* Building robots: Building Robots. (line 6)
+* Building Tags in the Emacs sources: etags. (line 87)
+* Byte compiling: Byte Compiling. (line 6)
+* C language primitives: Primitive Functions. (line 6)
+* C, a digression into: Digression into C. (line 6)
+* call defined: Switching Buffers. (line 57)
+* cancel-debug-on-entry: debug-on-entry. (line 83)
+* car, introduced: car cdr & cons. (line 6)
+* cdr, introduced: car cdr & cons. (line 6)
+* Changing a function definition: Change a defun. (line 6)
+* Chest of Drawers, metaphor for a symbol: Symbols as Chest. (line 6)
+* Clipping text: Cutting & Storing Text.
+ (line 6)
+* Code installation: Permanent Installation.
+ (line 6)
+* command defined: How to Evaluate. (line 11)
+* Comments in Lisp code: Change a defun. (line 22)
+* Common Lisp: Lisp History. (line 11)
+* compare-windows: Keybindings. (line 11)
+* concat: Data types. (line 11)
+* cond: Recursion with cond. (line 6)
+* condition-case: condition-case. (line 6)
+* Conditional 'twixt two versions of Emacs: Simple Extension. (line 37)
+* Conditional with if: if. (line 6)
+* cons, introduced: cons. (line 6)
+* copy-region-as-kill: copy-region-as-kill. (line 6)
+* copy-to-buffer: copy-to-buffer. (line 6)
+* Count words recursively: recursive-count-words.
+ (line 6)
+* count-words-in-defun: count-words-in-defun.
+ (line 99)
+* count-words-region: count-words-region. (line 6)
+* Counting: Counting. (line 6)
+* Counting words in a defun <1>: count-words-in-defun.
+ (line 6)
+* Counting words in a defun: Words in a defun. (line 6)
+* current-buffer: Getting Buffers. (line 6)
+* current-kill: current-kill. (line 6)
+* Customizing your .emacs file: Emacs Initialization.
+ (line 6)
+* Cutting and storing text: Cutting & Storing Text.
+ (line 6)
+* Data types: Data types. (line 6)
+* debug: debug. (line 6)
+* debug-on-entry: debug-on-entry. (line 6)
+* debug-on-quit: debug-on-quit. (line 9)
+* debugging: Debugging. (line 6)
+* default-mode-line-format: Mode Line. (line 6)
+* default.el init file: Site-wide Init. (line 6)
+* defconst: defcustom. (line 127)
+* defcustom: defcustom. (line 6)
+* Deferment in recursion: No Deferment. (line 6)
+* Defermentless solution: No deferment solution.
+ (line 6)
+* Definition installation: Install. (line 6)
+* Definition writing: Writing Defuns. (line 6)
+* Definition, how to change: Change a defun. (line 6)
+* defsubst: defcustom. (line 127)
+* defun: defun. (line 6)
+* defvar: defvar. (line 6)
+* defvar for a user customizable variable: defvar and asterisk.
+ (line 6)
+* defvar with an asterisk: defvar and asterisk. (line 6)
+* delete-and-extract-region: Digression into C. (line 6)
+* Deleting text: Cutting & Storing Text.
+ (line 6)
+* describe-function: simplified-beginning-of-buffer.
+ (line 78)
+* describe-function, introduced: Finding More. (line 6)
+* Digression into C: Digression into C. (line 6)
+* directory-files: Files List. (line 13)
+* Division: Large buffer case. (line 38)
+* dolist: dolist. (line 6)
+* dotimes: dotimes. (line 6)
+* Drawers, Chest of, metaphor for a symbol: Symbols as Chest. (line 6)
+* Duplicated words function: the-the. (line 6)
+* edebug: edebug. (line 6)
+* Else: else. (line 6)
+* Emacs version, choosing: Simple Extension. (line 37)
+* empty list defined: Lisp Atoms. (line 18)
+* empty string defined: Review. (line 139)
+* eobp: fwd-para while. (line 59)
+* eq: Review. (line 113)
+* eq (example of use): last-command & this-command.
+ (line 37)
+* equal: Review. (line 113)
+* Erasing text: Cutting & Storing Text.
+ (line 6)
+* error: Understanding current-kill.
+ (line 52)
+* Error for symbol without function: Void Function. (line 6)
+* Error for symbol without value: Void Variable. (line 6)
+* Error message generation: Making Errors. (line 6)
+* etags: etags. (line 6)
+* evaluate defined: Run a Program. (line 6)
+* Evaluating inner lists: Evaluating Inner Lists.
+ (line 6)
+* Evaluation: Evaluation. (line 6)
+* Evaluation practice: Practicing Evaluation.
+ (line 6)
+* Every, type of recursive pattern: Every. (line 6)
+* Example variable, fill-column: fill-column Example. (line 6)
+* expression defined: Lisp Atoms. (line 25)
+* Falsehood and truth in Emacs Lisp: Truth & Falsehood. (line 6)
+* FDL, GNU Free Documentation License: GNU Free Documentation License.
+ (line 6)
+* files-in-below-directory: Files List. (line 26)
+* fill-column, an example variable: fill-column Example. (line 6)
+* filter-buffer-substring: last-command & this-command.
+ (line 30)
+* Find a File: Find a File. (line 6)
+* Find function documentation: Finding More. (line 6)
+* Find source of function: Finding More. (line 13)
+* find-tags: Finding More. (line 40)
+* Flowers in a field: Lisp Lists. (line 18)
+* Focusing attention (narrowing): Narrowing & Widening.
+ (line 6)
+* form defined: Lisp Atoms. (line 25)
+* Formatting convention: append save-excursion.
+ (line 15)
+* Formatting help: Typing Lists. (line 6)
+* forward-paragraph: forward-paragraph. (line 6)
+* forward-sentence: forward-sentence. (line 6)
+* function defined: Making Errors. (line 51)
+* function definition defined: defun. (line 6)
+* Function definition installation: Install. (line 6)
+* Function definition writing: Writing Defuns. (line 6)
+* Function definition, how to change: Change a defun. (line 6)
+* Functions, primitive: Primitive Functions. (line 6)
+* Generate an error message: Making Errors. (line 6)
+* Getting a buffer: Getting Buffers. (line 6)
+* Global set key: Keybindings. (line 18)
+* global variable defined: Determining the Element.
+ (line 88)
+* global-set-key: Keybindings. (line 18)
+* global-unset-key: Keybindings. (line 57)
+* Graph prototype: Readying a Graph. (line 6)
+* Graph, printing all: Print Whole Graph. (line 6)
+* graph-body-print: graph-body-print. (line 6)
+* graph-body-print Final version.: The final version. (line 53)
+* Handling the kill ring: Kill Ring. (line 6)
+* Help typing lists: Typing Lists. (line 6)
+* Horizontal axis printing: print-X-axis. (line 6)
+* if: if. (line 6)
+* if-part defined: if in more detail. (line 6)
+* indent-tabs-mode: Indent Tabs Mode. (line 6)
+* Indentation for formatting: append save-excursion.
+ (line 15)
+* Initialization file: Emacs Initialization.
+ (line 6)
+* Initializing a variable: defvar. (line 6)
+* Inner list evaluation: Evaluating Inner Lists.
+ (line 6)
+* insert-buffer: insert-buffer. (line 6)
+* insert-buffer, new version body: New insert-buffer. (line 6)
+* insert-buffer-substring: append-to-buffer overview.
+ (line 6)
+* Insidious type of bug: Another Bug. (line 6)
+* Install a Function Definition: Install. (line 6)
+* Install code permanently: Permanent Installation.
+ (line 6)
+* interactive: Interactive. (line 6)
+* interactive function defined: How to Evaluate. (line 11)
+* Interactive functions: Interactive. (line 6)
+* Interactive options: Interactive Options. (line 6)
+* interactive, example use of: insert-buffer interactive.
+ (line 6)
+* Interpreter, Lisp, explained: Run a Program. (line 39)
+* Interpreter, what it does: Lisp Interpreter. (line 6)
+* Keep, type of recursive pattern: Keep. (line 6)
+* Key bindings, fixing: Miscellaneous. (line 88)
+* Key setting globally: Keybindings. (line 18)
+* Key unbinding: Keybindings. (line 57)
+* Keymaps: Keymaps. (line 6)
+* Keyword: Optional Arguments. (line 11)
+* Kill ring handling: Kill Ring. (line 6)
+* Kill ring overview: Kill Ring Overview. (line 6)
+* kill-append: kill-append function.
+ (line 6)
+* kill-new: kill-new function. (line 6)
+* kill-region: kill-region. (line 6)
+* Killing text: Cutting & Storing Text.
+ (line 6)
+* lambda: lambda. (line 6)
+* length: length. (line 6)
+* lengths-list-file: lengths-list-file. (line 11)
+* lengths-list-many-files: lengths-list-many-files.
+ (line 33)
+* let: let. (line 6)
+* let expression sample: Sample let Expression.
+ (line 6)
+* let expression, parts of: Parts of let Expression.
+ (line 6)
+* let variables uninitialized: Uninitialized let Variables.
+ (line 6)
+* Library, as term for `file': Finding More. (line 64)
+* line-to-top-of-window: Simple Extension. (line 6)
+* Lisp Atoms: Lisp Atoms. (line 6)
+* Lisp history: Lisp History. (line 6)
+* Lisp interpreter, explained: Run a Program. (line 39)
+* Lisp interpreter, what it does: Lisp Interpreter. (line 6)
+* Lisp Lists: Lisp Lists. (line 6)
+* Lisp macro: Lisp macro. (line 6)
+* list-buffers, rebound: Keybindings. (line 68)
+* Lists in a computer: List Implementation. (line 6)
+* load-library: Loading Files. (line 52)
+* load-path: Loading Files. (line 36)
+* Loading files: Loading Files. (line 6)
+* local variable defined: Prevent confusion. (line 6)
+* Local variables list, per-buffer,: Text and Auto-fill. (line 23)
+* Location of point: Buffer Size & Locations.
+ (line 6)
+* looking-at: fwd-para while. (line 81)
+* Loops: while. (line 6)
+* Loops and recursion: Loops & Recursion. (line 6)
+* Maclisp: Lisp History. (line 11)
+* Macro, lisp: Lisp macro. (line 6)
+* Mail aliases: Mail Aliases. (line 16)
+* make tags: etags. (line 87)
+* make-string: Y Axis Element. (line 74)
+* mapcar: mapcar. (line 6)
+* mark: save-excursion. (line 6)
+* mark-whole-buffer: mark-whole-buffer. (line 6)
+* match-beginning: fwd-para while. (line 158)
+* max: Columns of a graph. (line 129)
+* message: message. (line 6)
+* min: Columns of a graph. (line 129)
+* Mode line format: Mode Line. (line 6)
+* Mode selection, automatic: Text and Auto-fill. (line 23)
+* Motion by sentence and paragraph: Regexp Search. (line 6)
+* Narrowing: Narrowing & Widening.
+ (line 6)
+* narrowing defined: Buffer Size & Locations.
+ (line 40)
+* new version body for insert-buffer: New insert-buffer. (line 6)
+* nil: Truth & Falsehood. (line 6)
+* nil, history of word: Buffer Names. (line 42)
+* No deferment solution: No deferment solution.
+ (line 6)
+* nreverse: Counting function definitions.
+ (line 100)
+* nth: nth. (line 6)
+* nthcdr <1>: copy-region-as-kill. (line 6)
+* nthcdr: nthcdr. (line 6)
+* nthcdr, example: kill-new function. (line 149)
+* number-to-string: Y Axis Element. (line 13)
+* occur: Keybindings. (line 52)
+* optional: Optional Arguments. (line 11)
+* Optional arguments: Optional Arguments. (line 11)
+* Options for interactive: Interactive Options. (line 6)
+* or: Insert or. (line 13)
+* other-buffer: Getting Buffers. (line 6)
+* Paragraphs, movement by: Regexp Search. (line 6)
+* Parts of a Recursive Definition: Recursive Definition Parts.
+ (line 6)
+* Parts of let expression: Parts of let Expression.
+ (line 6)
+* Passing information to functions: Arguments. (line 6)
+* Pasting text: Yanking. (line 6)
+* Patterns, searching for: Regexp Search. (line 6)
+* Per-buffer, local variables list: Text and Auto-fill. (line 23)
+* Permanent code installation: Permanent Installation.
+ (line 6)
+* point: save-excursion. (line 6)
+* point defined: Buffer Size & Locations.
+ (line 19)
+* Point location: Buffer Size & Locations.
+ (line 6)
+* Point, mark, buffer preservation: save-excursion. (line 6)
+* Practicing evaluation: Practicing Evaluation.
+ (line 6)
+* Preserving point, mark, and buffer: save-excursion. (line 6)
+* Primitive functions: Primitive Functions. (line 6)
+* Primitives written in C: Primitive Functions. (line 6)
+* Print horizontal axis: print-X-axis. (line 6)
+* Print vertical axis: print-Y-axis. (line 6)
+* print-elements-of-list: print-elements-of-list.
+ (line 6)
+* print-elements-recursively: Recursion with list. (line 24)
+* print-graph Final version.: The final version. (line 75)
+* print-graph varlist: print-graph Varlist. (line 6)
+* print-X-axis: X Axis Tic Marks. (line 146)
+* print-X-axis-numbered-line: X Axis Tic Marks. (line 116)
+* print-X-axis-tic-line: X Axis Tic Marks. (line 82)
+* print-Y-axis: print-Y-axis Penultimate.
+ (line 9)
+* Printing the whole graph: Print Whole Graph. (line 6)
+* progn: progn. (line 6)
+* Program, running one: Run a Program. (line 6)
+* Properties, in mode line example: Mode Line. (line 64)
+* Properties, mention of buffer-substring-no-properties: narrow Exercise.
+ (line 13)
+* Prototype graph: Readying a Graph. (line 6)
+* push, example: kill-new function. (line 118)
+* re-search-forward: re-search-forward. (line 6)
+* Read-only buffer: Read-only buffer. (line 6)
+* Readying a graph: Readying a Graph. (line 6)
+* Rebinding keys: Keymaps. (line 6)
+* Recursion: Recursion. (line 6)
+* Recursion and loops: Loops & Recursion. (line 6)
+* Recursion without Deferments: No Deferment. (line 6)
+* Recursive Definition Parts: Recursive Definition Parts.
+ (line 6)
+* Recursive pattern: accumulate: Accumulate. (line 6)
+* Recursive pattern: every: Every. (line 6)
+* Recursive pattern: keep: Keep. (line 6)
+* Recursive Patterns: Recursive Patterns. (line 6)
+* recursive-count-words: recursive-count-words.
+ (line 258)
+* recursive-graph-body-print: recursive-graph-body-print.
+ (line 6)
+* recursive-lengths-list-many-files: Several files recursively.
+ (line 17)
+* Recursively counting words: recursive-count-words.
+ (line 6)
+* regexp-quote: fwd-para let. (line 73)
+* Region, what it is: save-excursion. (line 6)
+* Regular expression searches: Regexp Search. (line 6)
+* Regular expressions for word counting: Counting Words. (line 6)
+* Remainder function, %: Compute a Remainder. (line 6)
+* Repetition (loops): Loops & Recursion. (line 6)
+* Repetition for word counting: Counting Words. (line 6)
+* Retrieving text: Yanking. (line 6)
+* reverse: Counting function definitions.
+ (line 115)
+* Ring, making a list like a: Kill Ring. (line 6)
+* ring.el file: ring file. (line 6)
+* Robots, building: Building Robots. (line 6)
+* rotate-yank-pointer: Yanking. (line 6)
+* Run a program: Run a Program. (line 6)
+* Sample let expression: Sample let Expression.
+ (line 6)
+* save-excursion: save-excursion. (line 6)
+* save-restriction: save-restriction. (line 6)
+* search-forward: search-forward. (line 6)
+* Searches, illustrating: Regexp Search. (line 6)
+* sentence-end: sentence-end. (line 6)
+* Sentences, movement by: Regexp Search. (line 6)
+* set: Using set. (line 6)
+* set-buffer: Switching Buffers. (line 6)
+* set-variable: defvar and asterisk. (line 22)
+* setcar: setcar. (line 6)
+* setcdr: setcdr. (line 6)
+* setcdr, example: kill-new function. (line 153)
+* setq: Using setq. (line 6)
+* Setting a key globally: Keybindings. (line 18)
+* Setting value of variable: set & setq. (line 6)
+* side effect defined: Evaluation. (line 22)
+* Simple extension in .emacs file: Simple Extension. (line 6)
+* simplified-beginning-of-buffer: simplified-beginning-of-buffer.
+ (line 6)
+* site-init.el init file: Site-wide Init. (line 6)
+* site-load.el init file: Site-wide Init. (line 6)
+* Size of buffer: Buffer Size & Locations.
+ (line 6)
+* Solution without deferment: No deferment solution.
+ (line 6)
+* sort: Sorting. (line 6)
+* Source level debugger: edebug. (line 6)
+* Special form: Complications. (line 12)
+* Special form of defun: defun. (line 6)
+* Storing and cutting text: Cutting & Storing Text.
+ (line 6)
+* string defined: Lisp Atoms. (line 64)
+* switch-to-buffer: Switching Buffers. (line 6)
+* Switching to a buffer: Switching Buffers. (line 6)
+* Symbol names: Names & Definitions. (line 6)
+* Symbol without function error: Void Function. (line 6)
+* Symbol without value error: Void Variable. (line 6)
+* Symbolic expressions, introduced: Lisp Atoms. (line 25)
+* Symbols as a Chest of Drawers: Symbols as Chest. (line 6)
+* Syntax categories and tables: Syntax. (line 6)
+* Tabs, preventing: Indent Tabs Mode. (line 6)
+* TAGS file, create own: etags. (line 6)
+* Tags in the Emacs sources: etags. (line 87)
+* TAGS table, specifying: Finding More. (line 40)
+* Text between double quotation marks: Lisp Atoms. (line 60)
+* Text Mode turned on: Text and Auto-fill. (line 40)
+* Text retrieval: Yanking. (line 6)
+* the-the: the-the. (line 6)
+* then-part defined: if in more detail. (line 6)
+* top-of-ranges: Counting function definitions.
+ (line 20)
+* triangle-bugged: debug. (line 14)
+* triangle-recursively: Recursive triangle function.
+ (line 6)
+* Truth and falsehood in Emacs Lisp: Truth & Falsehood. (line 6)
+* Types of data: Data types. (line 6)
+* Unbinding key: Keybindings. (line 57)
+* Uninitialized let variables: Uninitialized let Variables.
+ (line 6)
+* Variable initialization: defvar. (line 6)
+* Variable number of arguments: Variable Number of Arguments.
+ (line 6)
+* Variable, example of, fill-column: fill-column Example. (line 6)
+* variable, global, defined: Determining the Element.
+ (line 88)
+* variable, local, defined: Prevent confusion. (line 6)
+* Variable, setting value: set & setq. (line 6)
+* Variables: Variables. (line 6)
+* varlist defined: Parts of let Expression.
+ (line 6)
+* Version of Emacs, choosing: Simple Extension. (line 37)
+* Vertical axis printing: print-Y-axis. (line 6)
+* what-line: what-line. (line 6)
+* while: while. (line 6)
+* Whitespace in lists: Whitespace in Lists. (line 6)
+* Whole graph printing: Print Whole Graph. (line 6)
+* Widening: Narrowing & Widening.
+ (line 6)
+* Widening, example of: what-line. (line 6)
+* Word counting in a defun: Words in a defun. (line 6)
+* Words and symbols in defun: Words and Symbols. (line 6)
+* Words, counted recursively: recursive-count-words.
+ (line 6)
+* Words, duplicated: the-the. (line 6)
+* Writing a function definition: Writing Defuns. (line 6)
+* Wrong type of argument: Wrong Type of Argument.
+ (line 6)
+* X axis printing: print-X-axis. (line 6)
+* X-axis-element: X Axis Tic Marks. (line 105)
+* Y axis printing: print-Y-axis. (line 6)
+* Y-axis-column: Y-axis-column. (line 10)
+* Y-axis-column Final version.: The final version. (line 15)
+* Y-axis-label-spacing: Compute a Remainder. (line 79)
+* Y-axis-tic: Y Axis Element. (line 32)
+* yank <1>: yank. (line 6)
+* yank: Yanking. (line 6)
+* yank-pop: yank-pop. (line 6)
+* zap-to-char: zap-to-char. (line 6)
+* zerop: Understanding current-kill.
+ (line 52)
+
+\1f
+File: eintr, Node: About the Author, Prev: Index, Up: Top
+
+About the Author
+****************
+
+ Robert J. Chassell has worked with GNU Emacs since 1985. He writes
+ and edits, teaches Emacs and Emacs Lisp, and speaks throughout the
+ world on software freedom. Chassell was a founding Director and
+ Treasurer of the Free Software Foundation, Inc. He is co-author of
+ the `Texinfo' manual, and has edited more than a dozen other
+ books. He graduated from Cambridge University, in England. He
+ has an abiding interest in social and economic history and flies
+ his own airplane.
+
+
+
+