2 files changed, 44 insertions, 30 deletions

diff --git a/doc/lispintro/ChangeLog b/doc/lispintro/ChangeLog
index 93084e76203..be9f9f963c0 100644
--- a/doc/lispintro/ChangeLog
+++ b/doc/lispintro/ChangeLog
@@ -1,3 +1,15 @@
+2013-04-23  Xue Fuqiao  <xfq.free@gmail.com>
+
+        * emacs-lisp-intro.texi (Complications, defvar): Refine the doc
+        about Lisp macros. (http://lists.gnu.org/archive/html/emacs-devel/2013-04/msg00618.html)
+
+2013-04-21  Xue Fuqiao  <xfq.free@gmail.com>
+
+        * emacs-lisp-intro.texi (defcustom, defun)
+        (simplified-beginning-of-buffer, defvar, Building Robots, Review)
+        (save-excursion): `defun' and `defcustom' are now macros rather
+        than special forms. (Bug#13853)
+
 2013-03-16  Glenn Morris  <rgm@gnu.org>
 
         * emacs-lisp-intro.texi: Add some stuff specific to www.gnu.org.
diff --git a/doc/lispintro/emacs-lisp-intro.texi b/doc/lispintro/emacs-lisp-intro.texi
index c42ed210cbc..7831603124e 100644
--- a/doc/lispintro/emacs-lisp-intro.texi
+++ b/doc/lispintro/emacs-lisp-intro.texi
@@ -37,6 +37,7 @@
 
 @set edition-number 3.10
 @set update-date 28 October 2009
+@c FIXME can this be updated?  -- xfq
 
 @ignore
  ## Summary of shell commands to create various output formats:
@@ -456,7 +457,7 @@ Practicing Evaluation
 How To Write Function Definitions
 
 * Primitive Functions::
-* defun::                        The @code{defun} special form.
+* defun::                        The @code{defun} macro.
 * Install::                      Install a function definition.
 * Interactive::                  Making a function interactive.
 * Interactive Options::          Different options for @code{interactive}.
@@ -1617,11 +1618,16 @@ the symbol's value as a @dfn{variable}.  This situation is described
 in the section on variables.  (@xref{Variables}.)
 
 @cindex Special form
-The second complication occurs because some functions are unusual and do
-not work in the usual manner.  Those that don't are called @dfn{special
-forms}.  They are used for special jobs, like defining a function, and
-there are not many of them.  In the next few chapters, you will be
-introduced to several of the more important special forms.
+The second complication occurs because some functions are unusual and
+do not work in the usual manner.  Those that don't are called
+@dfn{special forms}.  They are used for special jobs, like defining a
+function, and there are not many of them.  In the next few chapters,
+you will be introduced to several of the more important special forms.
+And there are also @dfn{macros}.  Macro is a construct defined in
+Lisp, which differs from a function in that it translates a Lisp
+expression into another expression which is to be evaluated instead of
+the original expression.  (@xref{Lisp macro}.)
+
 
 The third and final complication is this: if the function that the
 Lisp interpreter is looking at is not a special form, and if it is part
@@ -3094,18 +3100,15 @@ unless you investigate, you won't know whether an already-written
 function is written in Emacs Lisp or C.
 
 @node defun
-@section The @code{defun} Special Form
+@section The @code{defun} Macro
 @findex defun
-@cindex Special form of @code{defun}
 
 @cindex @samp{function definition} defined
 In Lisp, a symbol such as @code{mark-whole-buffer} has code attached to
 it that tells the computer what to do when the function is called.
 This code is called the @dfn{function definition} and is created by
 evaluating a Lisp expression that starts with the symbol @code{defun}
-(which is an abbreviation for @emph{define function}).  Because
-@code{defun} does not evaluate its arguments in the usual way, it is
-called a @dfn{special form}.
+(which is an abbreviation for @emph{define function}).
 
 In subsequent sections, we will look at function definitions from the
 Emacs source code, such as @code{mark-whole-buffer}.  In this section,
@@ -4254,7 +4257,7 @@ On the other hand, this function returns @code{nil} if the test is false.
 @findex point
 @findex mark
 
-The @code{save-excursion} function is the fourth and final special form
+The @code{save-excursion} function is the third and final special form
 that we will discuss in this chapter.
 
 In Emacs Lisp programs used for editing, the @code{save-excursion}
@@ -4381,9 +4384,9 @@ within the body of a @code{let} expression.  It looks like this:
 @node Review
 @section Review
 
-In the last few chapters we have introduced a fair number of functions
-and special forms.  Here they are described in brief, along with a few
-similar functions that have not been mentioned yet.
+In the last few chapters we have introduced a macro and a fair number
+of functions and special forms.  Here they are described in brief,
+along with a few similar functions that have not been mentioned yet.
 
 @table @code
 @item eval-last-sexp
@@ -4393,10 +4396,10 @@ invoked with an argument; in that case, the output is printed in the
 current buffer.  This command is normally bound to @kbd{C-x C-e}.
 
 @item defun
-Define function.  This special form has up to five parts: the name,
-a template for the arguments that will be passed to the function,
-documentation, an optional interactive declaration, and the body of the
-definition.
+Define function.  This macro has up to five parts: the name, a
+template for the arguments that will be passed to the function,
+documentation, an optional interactive declaration, and the body of
+the definition.
 
 @need 1250
 For example, in an early version of Emacs, the function definition was
@@ -4803,7 +4806,7 @@ leave mark at previous position."
 @end smallexample
 
 Like all function definitions, this definition has five parts following
-the special form @code{defun}:
+the macro @code{defun}:
 
 @enumerate
 @item
@@ -9293,7 +9296,7 @@ have a value.  If the variable already has a value, @code{defvar} does
 not override the existing value.  Second, @code{defvar} has a
 documentation string.
 
-(Another special form, @code{defcustom}, is designed for variables
+(There is a related macro, @code{defcustom}, designed for variables
 that people customize.  It has more features than @code{defvar}.
 (@xref{defcustom, , Setting Variables with @code{defcustom}}.)
 
@@ -11300,11 +11303,11 @@ Let's expand on the metaphor in which a computer program is a robot.
 
 A function definition provides the blueprints for a robot.  When you
 install a function definition, that is, when you evaluate a
-@code{defun} special form, you install the necessary equipment to
-build robots.  It is as if you were in a factory, setting up an
-assembly line.  Robots with the same name are built according to the
-same blueprints.  So they have, as it were, the same `model number',
-but a different `serial number'.
+@code{defun} macro, you install the necessary equipment to build
+robots.  It is as if you were in a factory, setting up an assembly
+line.  Robots with the same name are built according to the same
+blueprints.  So they have, as it were, the same `model number', but a
+different `serial number'.
 
 We often say that a recursive function `calls itself'.  What we mean
 is that the instructions in a recursive function cause the Lisp
@@ -16971,10 +16974,9 @@ definitions; but you can write @code{defuns} in your @file{.emacs}
 file.  Indeed, you can write any Lisp expression in your @file{.emacs}
 file.)
 
-The @code{customize} feature depends on the @code{defcustom} special
-form.  Although you can use @code{defvar} or @code{setq} for variables
-that users set, the @code{defcustom} special form is designed for the
-job.
+The @code{customize} feature depends on the @code{defcustom} macro.
+Although you can use @code{defvar} or @code{setq} for variables that
+users set, the @code{defcustom} macro is designed for the job.
 
 You can use your knowledge of @code{defvar} for writing the
 first three arguments for @code{defcustom}.  The first argument to