--- a/lisp/ChangeLog	Sun Jan 31 18:09:57 2010 +0000
+++ b/lisp/ChangeLog	Sun Jan 31 20:28:01 2010 +0000
@@ -1,3 +1,17 @@
+2010-01-31  Aidan Kehoe  <kehoea@parhasard.net>
+
+	* obsolete.el:
+	* loadhist.el (symbol-file):
+	* help.el (describe-function-1):
+	* bytecomp.el: (byte-compile-save-current-buffer):
+	* byte-optimize.el (byte-optimize-form-code-walker):
+	* subr.el (subr-arity):
+	Change "special form" to "special operator" in these files, it's
+	the more logical term.
+
+	* subr.el (special-form-p): Provide this alias for
+	#'special-operator-p. 
+
 2010-01-30  Aidan Kehoe  <kehoea@parhasard.net>
 
 	* loadup.el:

--- a/lisp/byte-optimize.el	Sun Jan 31 18:09:57 2010 +0000
+++ b/lisp/byte-optimize.el	Sun Jan 31 20:28:01 2010 +0000
@@ -370,8 +370,8 @@
 (defun byte-optimize-form-code-walker (form for-effect)
   ;;
   ;; For normal function calls, We can just mapcar the optimizer the cdr.  But
-  ;; we need to have special knowledge of the syntax of the special forms
-  ;; like let and defun (that's why they're special forms :-).  (Actually,
+  ;; we need to have special knowledge of the syntax of the special operators
+  ;; like let and defun (that's why they're special operators :-).  (Actually,
   ;; the important aspect is that they are subrs that don't evaluate all of
   ;; their args.)
   ;;

--- a/lisp/bytecomp.el	Sun Jan 31 18:09:57 2010 +0000
+++ b/lisp/bytecomp.el	Sun Jan 31 20:28:01 2010 +0000
@@ -4072,7 +4072,7 @@
 	       (car form)))
 	  (cdr form))))
 
-;;; other tricky macro-like special-forms
+;;; other tricky macro-like special-operators
 
 (byte-defop-compiler-1 catch)
 (byte-defop-compiler-1 unwind-protect)
@@ -4167,7 +4167,7 @@
 
 (defun byte-compile-save-current-buffer (form)
   (if (byte-compile-version-cond byte-compile-emacs19-compatibility)
-      ;; `save-current-buffer' special form is not available in XEmacs 19.
+      ;; `save-current-buffer' special operator is not available in XEmacs 19.
       (byte-compile-form
        `(let ((_byte_compiler_save_buffer_emulation_closure_ (current-buffer)))
 	  (unwind-protect

--- a/lisp/help.el	Sun Jan 31 18:09:57 2010 +0000
+++ b/lisp/help.el	Sun Jan 31 20:28:01 2010 +0000
@@ -1414,8 +1414,8 @@
       (cond ((or (stringp def) (vectorp def))
              (princ "a keyboard macro.")
 	     (setq kbd-macro-p t))
-            ((special-form-p fndef)
-             (funcall int "built-in special form" nil 'neither))
+            ((special-operator-p fndef)
+             (funcall int "built-in special operator" nil 'neither))
             ((subrp fndef)
              (funcall int "built-in" nil macrop))
             ((compiled-function-p fndef)

--- a/lisp/loadhist.el	Sun Jan 31 18:09:57 2010 +0000
+++ b/lisp/loadhist.el	Sun Jan 31 20:28:01 2010 +0000
@@ -46,7 +46,7 @@
 This is a file name, or nil if the source was a buffer with no associated file.
 
 If TYPE is nil or omitted, any kind of definition is acceptable.
-If TYPE is `defun', then function, subr, special form or macro definitions
+If TYPE is `defun', then function, subr, special operator or macro definitions
 are acceptable.
 If TYPE is `defvar', then variable definitions are acceptable.
 

--- a/lisp/obsolete.el	Sun Jan 31 18:09:57 2010 +0000
+++ b/lisp/obsolete.el	Sun Jan 31 20:28:01 2010 +0000
@@ -398,7 +398,7 @@
 
 (make-obsolete 'function-called-at-point 'function-at-point)
 
-;; As of 21.5, #'throw is a special form. This makes bytecode using it
+;; As of 21.5, #'throw is a special operator. This makes bytecode using it
 ;; compiled for 21.4 fail; making this function available works around that.
 (defun obsolete-throw (tag value)
   "Ugly compatibility hack.

--- a/lisp/subr.el	Sun Jan 31 18:09:57 2010 +0000
+++ b/lisp/subr.el	Sun Jan 31 20:28:01 2010 +0000
@@ -218,6 +218,7 @@
 (define-function 'remove-directory 'delete-directory)
 (define-function 'set-match-data 'store-match-data)
 (define-function 'send-string-to-terminal 'external-debugging-output)
+(define-function 'special-form-p 'special-operator-p)
 
 ;; XEmacs:
 (defun local-variable-if-set-p (sym buffer)
@@ -1763,14 +1764,14 @@
 SUBR must be a built-in function (not just a symbol that refers to one).
 The returned value is a pair (MIN . MAX).  MIN is the minimum number
 of args.  MAX is the maximum number or the symbol `many', for a
-function with `&rest' args, or `unevalled' for a special form.
+function with `&rest' args, or `unevalled' for a special operator.
 
-See also `special-form-p', `subr-min-args', `subr-max-args',
+See also `special-operator-p', `subr-min-args', `subr-max-args',
 `function-allows-args'. "
   (check-argument-type #'subrp subr)
   (cons (subr-min-args subr)
         (cond
-         ((special-form-p subr)
+         ((special-operator-p subr)
           'unevalled)
          ((null (subr-max-args subr))
           'many)

--- a/man/ChangeLog	Sun Jan 31 18:09:57 2010 +0000
+++ b/man/ChangeLog	Sun Jan 31 20:28:01 2010 +0000
@@ -1,3 +1,48 @@
+2010-01-31  Aidan Kehoe  <kehoea@parhasard.net>
+
+	* xemacs/programs.texi (Defuns): 
+	* lispref/variables.texi (Local Variables, Defining Variables)
+	(Setting Variables, Default Value):
+	* lispref/symbols.texi (Definitions): 
+	* lispref/searching.texi (Saving Match Data): 
+	* lispref/positions.texi (Excursions, Narrowing):
+	* lispref/objects.texi (Primitive Function Type): 
+	* lispref/macros.texi (Defining Macros, Backquote): 
+	* lispref/lispref.texi (Top): 
+	* lispref/intro.texi (A Sample Function Description):
+	* lispref/help.texi (Help Functions):
+	* lispref/functions.texi (What Is a Function, Simple Lambda)
+	(Defining Functions, Calling Functions, Anonymous Functions):
+	* lispref/frames.texi (Input Focus):
+	* lispref/eval.texi (Forms, Function Indirection)
+	(Special Operators, Quoting):
+	* lispref/edebug-inc.texi (Instrumenting)
+	(Specification Examples):
+	* lispref/debugging.texi (Internals of Debugger):
+	* lispref/control.texi (Control Structures, Sequencing):
+	(Conditionals, Combining Conditions, Iteration):
+	(Catch and Throw, Handling Errors):
+	* lispref/commands.texi (Defining Commands, Using Interactive):
+	Terminology change; special operator -> special form. 
+
+	Don't attempt to change this in texinfo.texi or cl.texi, which use
+	macros I don't understand.
+
+	* lispref/macros.texi (Defining Macros): Give an anonymous macro
+	example here. 
+	* lispref/positions.texi (Excursions):
+	Correct some documentation that called a couple of macros special
+	forms.
+	* lispref/searching.texi (Saving Match Data):
+	Drop some documentation of how to write code that works with Emacs
+	18.
+	* lispref/specifiers.texi (Adding Specifications):
+	Correct this; #'let-specifier is a macro, not a special operator.
+	* lispref/windows.texi (Window Configurations)
+	(Selecting Windows): 
+	Correct this, #'save-selected-window and #'save-window-excursion
+	are macros, not special operators.
+
 2010-01-28  Jerry James  <loganjerry@gmail.com>
 
 	* external-widget.texi: Add copyright and license boilerplate text

--- a/man/cl.texi	Sun Jan 31 18:09:57 2010 +0000
+++ b/man/cl.texi	Sun Jan 31 20:28:01 2010 +0000
@@ -680,7 +680,7 @@
 (compile load eval) @dots{})}.
 @end defspec
 
-Emacs 19 includes two special forms related to @code{eval-when}.
+Emacs 19 includes two special operators related to @code{eval-when}.
 One of these, @code{eval-when-compile}, is not quite equivalent to
 any @code{eval-when} construct and is described below.  This package
 defines a version of @code{eval-when-compile} for the benefit of
@@ -990,7 +990,7 @@
 assignments are done in parallel rather than sequentially.
 
 @defspec psetq [symbol form]@dots{}
-This special form (actually a macro) is used to assign to several
+This macro is used to assign to several
 variables simultaneously.  Given only one @var{symbol} and @var{form},
 it has the same effect as @code{setq}.  Given several @var{symbol}
 and @var{form} pairs, it evaluates all the @var{form}s in advance

--- a/man/internals/internals.texi	Sun Jan 31 18:09:57 2010 +0000
+++ b/man/internals/internals.texi	Sun Jan 31 20:28:01 2010 +0000
@@ -451,7 +451,7 @@
 
 * Evaluation::                  
 * Dynamic Binding; The specbinding Stack; Unwind-Protects::  
-* Simple Special Forms::        
+* Simple Special Operators::        
 * Catch and Throw::             
 * Error Trapping::              
 
@@ -3518,7 +3518,7 @@
 This module contains all of the functions to handle the flow of control.
 This includes the mechanisms of defining functions, calling functions,
 traversing stack frames, and binding variables; the control primitives
-and other special forms such as @code{while}, @code{if}, @code{eval},
+and other special operators such as @code{while}, @code{if}, @code{eval},
 @code{let}, @code{and}, @code{or}, @code{progn}, etc.; handling of
 non-local exits, unwind-protects, and exception handlers; entering the
 debugger; methods for the subr Lisp object type; etc.  It does
@@ -5323,7 +5323,7 @@
 C macros.  The only way to really understand how to write new C code is
 to read the source, but we can explain some things here.
 
-An example of a special form is the definition of @code{prog1}, from
+An example of a special operator is the definition of @code{prog1}, from
 @file{eval.c}.  (An ordinary function would have the same general
 appearance.)
 
@@ -5404,7 +5404,7 @@
 @item max_args
 This is the maximum number of arguments that the function accepts, if
 there is a fixed maximum.  Alternatively, it can be @code{UNEVALLED},
-indicating a special form that receives unevaluated arguments, or
+indicating a special operator that receives unevaluated arguments, or
 @code{MANY}, indicating an unlimited number of evaluated arguments (the
 C equivalent of @code{&rest}).  Both @code{UNEVALLED} and @code{MANY}
 are macros.  If @var{max_args} is a number, it may not be less than
@@ -5457,7 +5457,7 @@
 or errors.
 
 A Lisp function with @w{@var{max_args} = @code{UNEVALLED}} is a
-@w{@dfn{special form}}; its arguments are not evaluated.  Instead it
+@w{@dfn{special operator}}; its arguments are not evaluated.  Instead it
 receives one argument of type @code{Lisp_Object}, a (Lisp) list of the
 unevaluated arguments, conventionally named @code{(args)}.
 
@@ -8954,7 +8954,7 @@
 @menu
 * Evaluation::                  
 * Dynamic Binding; The specbinding Stack; Unwind-Protects::  
-* Simple Special Forms::        
+* Simple Special Operators::        
 * Catch and Throw::             
 * Error Trapping::              
 @end menu
@@ -9090,7 +9090,7 @@
 an array).  @code{apply1()} uses @code{Fapply()} while the others use
 @code{Ffuncall()} to do the real work.
 
-@node Dynamic Binding; The specbinding Stack; Unwind-Protects, Simple Special Forms, Evaluation, Evaluation; Stack Frames; Bindings
+@node Dynamic Binding; The specbinding Stack; Unwind-Protects, Simple Special Operators, Evaluation, Evaluation; Stack Frames; Bindings
 @section Dynamic Binding; The specbinding Stack; Unwind-Protects
 @cindex dynamic binding; the specbinding stack; unwind-protects
 @cindex binding; the specbinding stack; unwind-protects, dynamic
@@ -9148,9 +9148,10 @@
 the symbol's value).
 @end enumerate
 
-@node Simple Special Forms, Catch and Throw, Dynamic Binding; The specbinding Stack; Unwind-Protects, Evaluation; Stack Frames; Bindings
-@section Simple Special Forms
-@cindex special forms, simple
+@node Simple Special Operators, Catch and Throw, Dynamic Binding; The specbinding Stack; Unwind-Protects, Evaluation; Stack Frames; Bindings
+@section Simple Special Operators
+@cindex special operators, simple
+@cindex special forms
 
 @code{or}, @code{and}, @code{if}, @code{cond}, @code{progn},
 @code{prog1}, @code{prog2}, @code{setq}, @code{quote}, @code{function},
@@ -9166,7 +9167,7 @@
 compiler knows how to convert calls to these functions directly into
 byte code.
 
-@node Catch and Throw, Error Trapping, Simple Special Forms, Evaluation; Stack Frames; Bindings
+@node Catch and Throw, Error Trapping, Simple Special Operators, Evaluation; Stack Frames; Bindings
 @section Catch and Throw
 @cindex catch and throw
 @cindex throw, catch and

--- a/man/lispref/commands.texi	Sun Jan 31 18:09:57 2010 +0000
+++ b/man/lispref/commands.texi	Sun Jan 31 20:28:01 2010 +0000
@@ -102,8 +102,8 @@
 @cindex interactive function
 
   A Lisp function becomes a command when its body contains, at top
-level, a form that calls the special form @code{interactive}.  This
-form does nothing when actually executed, but its presence serves as a
+level, a form that calls the special operator @code{interactive}.  This
+operator does nothing when actually executed, but its presence serves as a
 flag to indicate that interactive calling is permitted.  Its argument
 controls the reading of arguments for an interactive call.
 
@@ -122,7 +122,7 @@
 
 @defspec interactive arg-descriptor
 @cindex argument descriptors
-This special form declares that the function in which it appears is a
+This special operator declares that the function in which it appears is a
 command, and that it may therefore be called interactively (via
 @kbd{M-x} or by entering a key sequence bound to it).  The argument
 @var{arg-descriptor} declares how to compute the arguments to the

--- a/man/lispref/control.texi	Sun Jan 31 18:09:57 2010 +0000
+++ b/man/lispref/control.texi	Sun Jan 31 20:28:01 2010 +0000
@@ -5,14 +5,14 @@
 @setfilename ../../info/control.info
 @node Control Structures, Variables, Evaluation, Top
 @chapter Control Structures
-@cindex special forms for control structures
+@cindex special operators for control structures
 @cindex control structures
 
   A Lisp program consists of expressions or @dfn{forms} (@pxref{Forms}).
 We control the order of execution of the forms by enclosing them in
-@dfn{control structures}.  Control structures are special forms which
-control when, whether, or how many times to execute the forms they
-contain.
+@dfn{control structures}.  Control structures are special operators which
+control when, whether, or how many times to execute the subforms of
+their containing forms.
 
   The simplest order of execution is sequential execution: first form
 @var{a}, then form @var{b}, and so on.  This is what happens when you
@@ -29,9 +29,9 @@
   XEmacs Lisp provides several kinds of control structure, including
 other varieties of sequencing, conditionals, iteration, and (controlled)
 jumps---all discussed below.  The built-in control structures are
-special forms since their subforms are not necessarily evaluated or not
-evaluated sequentially.  You can use macros to define your own control
-structure constructs (@pxref{Macros}).
+special operators since their enclosing forms' subforms are not
+necessarily evaluated or not evaluated sequentially.  You can use macros
+to define your own control structure constructs (@pxref{Macros}).
 
 @menu
 * Sequencing::             Evaluation in textual order.
@@ -77,7 +77,7 @@
 @code{or}, or in the @var{then}-part of an @code{if}.
 
 @defspec progn forms@dots{}
-This special form evaluates all of the @var{forms}, in textual
+This special operator evaluates all of the @var{forms}, in textual
 order, returning the result of the final form.
 
 @example
@@ -97,7 +97,7 @@
 a different value:
 
 @defspec prog1 form1 forms@dots{}
-This special form evaluates @var{form1} and all of the @var{forms}, in
+This special operator evaluates @var{form1} and all of the @var{forms}, in
 textual order, returning the result of @var{form1}.
 
 @example
@@ -121,7 +121,7 @@
 @end defspec
 
 @defspec prog2 form1 form2 forms@dots{}
-This special form evaluates @var{form1}, @var{form2}, and all of the
+This special operator evaluates @var{form1}, @var{form2}, and all of the
 following @var{forms}, in textual order, returning the result of
 @var{form2}.
 
@@ -157,7 +157,7 @@
 If @var{condition} has the value @code{nil}, and no @var{else-forms} are
 given, @code{if} returns @code{nil}.
 
-@code{if} is a special form because the branch that is not selected is
+@code{if} is a special operator because the branch that is not selected is
 never evaluated---it is ignored.  Thus, in the example below,
 @code{true} is not printed because @code{print} is never called.
 
@@ -269,7 +269,7 @@
 @end defun
 
 @defspec and conditions@dots{}
-The @code{and} special form tests whether all the @var{conditions} are
+The @code{and} special operator tests whether all the @var{conditions} are
 true.  It works by evaluating the @var{conditions} one by one in the
 order written.
 
@@ -323,7 +323,7 @@
 @end defspec
 
 @defspec or conditions@dots{}
-The @code{or} special form tests whether at least one of the
+The @code{or} special operator tests whether at least one of the
 @var{conditions} is true.  It works by evaluating all the
 @var{conditions} one by one in the order written.
 
@@ -379,7 +379,7 @@
   Iteration means executing part of a program repetitively.  For
 example, you might want to repeat some computation once for each element
 of a list, or once for each integer from 0 to @var{n}.  You can do this
-in XEmacs Lisp with the special form @code{while}:
+in XEmacs Lisp with the special operator @code{while}:
 
 @defspec while condition forms@dots{}
 @code{while} first evaluates @var{condition}.  If the result is
@@ -488,7 +488,7 @@
 the narrowing status saved by @code{save-restriction} and the window
 selection saved by @code{save-window-excursion} (@pxref{Window
 Configurations}).  It also runs any cleanups established with the
-@code{unwind-protect} special form when it exits that form
+@code{unwind-protect} special operator when it exits that form
 (@pxref{Cleanups}).
 
   The @code{throw} need not appear lexically within the @code{catch}
@@ -957,7 +957,7 @@
   The usual effect of signaling an error is to terminate the command
 that is running and return immediately to the XEmacs editor command loop.
 You can arrange to trap errors occurring in a part of your program by
-establishing an error handler, with the special form
+establishing an error handler, with the special operator
 @code{condition-case}.  A simple example looks like this:
 
 @example
@@ -1029,7 +1029,7 @@
 @code{catch} signals an error that can be handled).
 
 @defspec condition-case var protected-form handlers@dots{}
-This special form establishes the error handlers @var{handlers} around
+This special operator establishes the error handlers @var{handlers} around
 the execution of @var{protected-form}.  If @var{protected-form} executes
 without error, the value it returns becomes the value of the
 @code{condition-case} form; in this case, the @code{condition-case} has

--- a/man/lispref/debugging.texi	Sun Jan 31 18:09:57 2010 +0000
+++ b/man/lispref/debugging.texi	Sun Jan 31 20:28:01 2010 +0000
@@ -529,7 +529,7 @@
 @samp{backtrace-output}.  Each line of the backtrace represents one
 function call.  The line shows the values of the function's arguments if
 they are all known.  If they are still being computed, the line says so.
-The arguments of special forms are elided.
+The arguments of special operators are elided.
 
 @smallexample
 @group

--- a/man/lispref/edebug-inc.texi	Sun Jan 31 18:09:57 2010 +0000
+++ b/man/lispref/edebug-inc.texi	Sun Jan 31 20:28:01 2010 +0000
@@ -203,13 +203,13 @@
 instrumenting it.  Also see the command @kbd{i} (@ref{Jumping}) which
 steps into the callee.
 
-@cindex special forms (Edebug)
+@cindex special operators (Edebug)
 @cindex interactive commands (Edebug)
 @cindex anonymous lambda expressions (Edebug)
 @cindex Common Lisp (Edebug)
 @pindex cl.el (Edebug)
 @pindex cl-specs.el
-  Edebug knows how to instrument all the standard special forms, an
+  Edebug knows how to instrument all the standard special operators, an
 interactive form with an expression argument, anonymous lambda
 expressions, and other defining forms.  (Specifications for macros
 defined by @file{cl.el} (version 2.03) are provided in
@@ -1497,7 +1497,7 @@
 Here we provide several examples of Edebug specifications to show
 many of its capabilities.
 
-A @code{let} special form has a sequence of bindings and a body.  Each
+A @code{let} special operator has a sequence of bindings and a body.  Each
 of the bindings is either a symbol or a sublist with a symbol and
 optional value.  In the specification below, notice the @code{gate}
 inside of the sublist to prevent backtracking.

--- a/man/lispref/eval.texi	Sun Jan 31 18:09:57 2010 +0000
+++ b/man/lispref/eval.texi	Sun Jan 31 20:28:01 2010 +0000
@@ -252,8 +252,9 @@
 			      we find the real function via the symbol.
 * Function Forms::          Forms that call functions.
 * Macro Forms::             Forms that call macros.
-* Special Forms::           ``Special forms'' are idiosyncratic primitives,
+* Special Operators::       ``Special operators'' are idiosyncratic primitives,
                               most of them extremely important.
+                              Also known as special forms.
 * Autoloading::             Functions set up to load files
                               containing their real definitions.
 @end menu
@@ -354,7 +355,7 @@
 call, or a special form, according to its first element.  These three
 kinds of forms are evaluated in different ways, described below.  The
 remaining list elements constitute the @dfn{arguments} for the function,
-macro, or special form.
+macro, or special operator.
 
   The first step in evaluating a nonempty list is to examine its first
 element.  This element alone determines what kind of form the list is
@@ -387,7 +388,7 @@
 @cindex invalid function
   More precisely, we should now have a Lisp function (a lambda
 expression), a byte-code function, a primitive function, a Lisp macro, a
-special form, or an autoload object.  Each of these types is a case
+special operator, or an autoload object.  Each of these types is a case
 described in one of the following sections.  If the object is not one of
 these types, the error @code{invalid-function} is signaled.
 
@@ -531,20 +532,22 @@
 
 @xref{Macros}, for a complete description of XEmacs Lisp macros.
 
-@node Special Forms
-@subsection Special Forms
-@cindex special form evaluation
+@node Special Operators
+@subsection Special Operators
+@cindex special operator evaluation
+@cindex special form
 
-  A @dfn{special form} is a primitive function specially marked so that
-its arguments are not all evaluated.  Most special forms define control
+  A @dfn{special operator} (historically, and less logically, a
+@dfn{special form}) is a primitive function specially marked so that
+its arguments are not all evaluated.  Most special operators define control
 structures or perform variable bindings---things which functions cannot
 do.
 
-  Each special form has its own rules for which arguments are evaluated
+  Each special operator has its own rules for which arguments are evaluated
 and which are used without evaluation.  Whether a particular argument is
 evaluated may depend on the results of evaluating other arguments.
 
-  Here is a list, in alphabetical order, of all of the special forms in
+  Here is a list, in alphabetical order, of all of the special operators in
 XEmacs Lisp with a reference to where each is described.
 
 @table @code
@@ -627,17 +630,16 @@
 @pxref{Temporary Displays}
 @end table
 
-@cindex CL note---special forms compared
+@cindex CL note---special operators compared
 @quotation
-@b{Common Lisp note:} here are some comparisons of special forms in
+@b{Common Lisp note:} here are some comparisons of special operators in
 XEmacs Lisp and Common Lisp.  @code{setq}, @code{if}, and
-@code{catch} are special forms in both XEmacs Lisp and Common Lisp.
-@code{defun} is a special form in XEmacs Lisp, but a macro in Common
-Lisp.  @code{save-excursion} is a special form in XEmacs Lisp, but
-doesn't exist in Common Lisp.  @code{throw} is a special form in
-Common Lisp (because it must be able to throw multiple values), but it
-is a function in XEmacs Lisp (which doesn't have multiple
-values).@refill
+@code{catch} are special operators in both XEmacs Lisp and Common Lisp.
+@code{defun} is a special operator in XEmacs Lisp, but a macro in Common
+Lisp.  @code{save-excursion} is a special operator in XEmacs Lisp, but
+doesn't exist in Common Lisp.  @code{throw} is a special operator in
+both Common Lisp and XEmacs Lisp (because it must be able to throw
+multiple values).@refill
 @end quotation
 
 @node Autoloading
@@ -654,14 +656,14 @@
 @section Quoting
 @cindex quoting
 
-  The special form @code{quote} returns its single argument, as written,
+  The special operator @code{quote} returns its single argument, as written,
 without evaluating it.  This provides a way to include constant symbols
 and lists, which are not self-evaluating objects, in a program.  (It is
 not necessary to quote self-evaluating objects such as numbers, strings,
 and vectors.)
 
 @defspec quote object
-This special form returns @var{object}, without evaluating it.
+This special operator returns @var{object}, without evaluating it.
 @end defspec
 
 @cindex @samp{'} for quoting

--- a/man/lispref/frames.texi	Sun Jan 31 18:09:57 2010 +0000
+++ b/man/lispref/frames.texi	Sun Jan 31 20:28:01 2010 +0000
@@ -786,13 +786,13 @@
 @end defun
 
 @defspec save-selected-frame forms@dots{}
-This special form records the selected frame, executes @var{forms} in
+This special operator records the selected frame, executes @var{forms} in
 sequence, then restores the earlier selected frame.  The value returned
 is the value of the last form.
 @end defspec
 
 @defspec with-selected-frame frame forms@dots{}
-This special form records the selected frame, then selects @var{frame}
+This special operator records the selected frame, then selects @var{frame}
 and executes @var{forms} in sequence.  After the last form is finished,
 the earlier selected frame is restored.  The value returned is the value
 of the last form.

--- a/man/lispref/functions.texi	Sun Jan 31 18:09:57 2010 +0000
+++ b/man/lispref/functions.texi	Sun Jan 31 20:28:01 2010 +0000
@@ -42,7 +42,7 @@
 @cindex function
 In XEmacs Lisp, a @dfn{function} is anything that can be applied to
 arguments in a Lisp program.  In some cases, we use it more
-specifically to mean a function written in Lisp.  Special forms and
+specifically to mean a function written in Lisp.  Special operators and
 macros are not functions.
 
 @item command
@@ -84,7 +84,7 @@
 @cindex built-in function
 A @dfn{primitive} is a function callable from Lisp that is written in C,
 such as @code{car} or @code{append}.  These functions are also called
-@dfn{built-in} functions or @dfn{subrs}.  (Special forms are also
+@dfn{built-in} functions or @dfn{subrs}.  (Special operators are also
 considered primitives.)
 
 Usually the reason that a function is a primitives is because it is
@@ -101,11 +101,11 @@
 @xref{Lambda Expressions}.
 @end ifinfo
 
-@item special form
-A @dfn{special form} is a primitive that is like a function but does not
+@item special operator
+A @dfn{special operator} is a primitive that is like a function but does not
 evaluate all of its arguments in the usual way.  It may evaluate only
 some of the arguments, or may evaluate them in an unusual order, or
-several times.  Many special forms are described in @ref{Control
+several times.  Many special operators are described in @ref{Control
 Structures}.
 
 @item macro
@@ -114,7 +114,7 @@
 differs from a function in that it translates a Lisp expression that you
 write into an equivalent expression to be evaluated instead of the
 original expression.  Macros enable Lisp programmers to do the sorts of
-things that special forms can do.  @xref{Macros}, for how to define and
+things that special operators can do.  @xref{Macros}, for how to define and
 use macros.
 
 @item compiled function
@@ -267,14 +267,14 @@
 
   It is not often useful to write a lambda expression as the @sc{car} of
 a form in this way.  You can get the same result, of making local
-variables and giving them values, using the special form @code{let}
+variables and giving them values, using the special operator @code{let}
 (@pxref{Local Variables}).  And @code{let} is clearer and easier to use.
 In practice, lambda expressions are either stored as the function
 definitions of symbols, to produce named functions, or passed as
 arguments to other functions (@pxref{Anonymous Functions}).
 
   However, calls to explicit lambda expressions were very useful in the
-old days of Lisp, before the special form @code{let} was invented.  At
+old days of Lisp, before the special operator @code{let} was invented.  At
 that time, they were the only way to bind and initialize local
 variables.
 
@@ -472,7 +472,7 @@
 
   We usually give a name to a function when it is first created.  This
 is called @dfn{defining a function}, and it is done with the
-@code{defun} special form.
+@code{defun} special operator.
 
 @defspec defun name argument-list body-forms
 @code{defun} is the usual way to define new Lisp functions.  It
@@ -547,7 +547,7 @@
 
 @defun define-function name definition
 @defunx defalias name definition
-These equivalent special forms define the symbol @var{name} as a
+These equivalent primitives define the symbol @var{name} as a
 function, with definition @var{definition} (which can be any valid Lisp
 function).
 
@@ -601,7 +601,7 @@
 place where the arguments have already been evaluated.
 
 The argument @var{function} must be either a Lisp function or a
-primitive function.  Special forms and macros are not allowed, because
+primitive function.  Special operators and macros are not allowed, because
 they make sense only when given the ``unevaluated'' argument
 expressions.  @code{funcall} cannot provide these because, as we saw
 above, it never knows them in the first place.
@@ -637,7 +637,7 @@
 
 @code{apply} returns the result of calling @var{function}.  As with
 @code{funcall}, @var{function} must either be a Lisp function or a
-primitive function; special forms and macros do not make sense in
+primitive function; special operators and macros do not make sense in
 @code{apply}.
 
 @example
@@ -830,12 +830,12 @@
 @end example
 
 @noindent
-In such cases, we usually use the special form @code{function} instead
+In such cases, we usually use the special operator @code{function} instead
 of simple quotation to quote the anonymous function.
 
 @defspec function function-object
 @cindex function quoting
-This special form returns @var{function-object} without evaluating it.
+This special operator returns @var{function-object} without evaluating it.
 In this, it is equivalent to @code{quote}.  However, it serves as a
 note to the XEmacs Lisp compiler that @var{function-object} is intended
 to be used only as a function, and therefore can safely be compiled.

--- a/man/lispref/help.texi	Sun Jan 31 18:09:57 2010 +0000
+++ b/man/lispref/help.texi	Sun Jan 31 20:28:01 2010 +0000
@@ -555,8 +555,8 @@
 Otherwise it calls @code{message} to display it in the echo area.
 
 This function expects to be called inside a
-@code{with-output-to-temp-buffer} special form, and expects
-@code{standard-output} to have the value bound by that special form.
+@code{with-output-to-temp-buffer} form, and expects
+@code{standard-output} to have the value bound by that special operator.
 For an example of its use, see the long example in @ref{Accessing
 Documentation}.
 @end defun

--- a/man/lispref/intro.texi	Sun Jan 31 18:09:57 2010 +0000
+++ b/man/lispref/intro.texi	Sun Jan 31 20:28:01 2010 +0000
@@ -720,7 +720,7 @@
 @cindex function descriptions
 @cindex command descriptions
 @cindex macro descriptions
-@cindex special form descriptions
+@cindex special operator descriptions
 
   In a function description, the name of the function being described
 appears first.  It is followed on the same line by a list of parameters.
@@ -773,13 +773,13 @@
   @xref{Lambda Expressions}, for a more complete description of optional
 and rest arguments.
 
-  Command, macro, and special form descriptions have the same format,
+  Command, macro, and special operator descriptions have the same format,
 but the word `Function' is replaced by `Command', `Macro', or `Special
 Form', respectively.  Commands are simply functions that may be called
 interactively; macros process their arguments differently from functions
 (the arguments are not evaluated), but are presented the same way.
 
-  Special form descriptions use a more complex notation to specify
+  Special operator descriptions use a more complex notation to specify
 optional and repeated parameters because they can break the argument
 list down into separate arguments in more complicated ways.
 @samp{@code{@r{[}@var{optional-arg}@r{]}}} means that @var{optional-arg} is
@@ -788,7 +788,7 @@
 additional levels of list structure.  Here is an example:
 
 @defspec count-loop (@var{var} [@var{from} @var{to} [@var{inc}]]) @var{body}@dots{}
-This imaginary special form implements a loop that executes the
+This imaginary special operator implements a loop that executes the
 @var{body} forms and then increments the variable @var{var} on each
 iteration.  On the first iteration, the variable has the value
 @var{from}; on subsequent iterations, it is incremented by 1 (or by
@@ -812,7 +812,7 @@
     (setq done t)))
 @end example
 
-In this special form, the arguments @var{from} and @var{to} are
+With this special operator, the arguments @var{from} and @var{to} are
 optional, but must both be present or both absent.  If they are present,
 @var{inc} may optionally be specified as well.  These arguments are
 grouped with the argument @var{var} into a list, to distinguish them

--- a/man/lispref/lispref.texi	Sun Jan 31 18:09:57 2010 +0000
+++ b/man/lispref/lispref.texi	Sun Jan 31 20:28:01 2010 +0000
@@ -408,7 +408,7 @@
 * Classifying Lists::       How to distinguish various sorts of list forms.
 * Function Forms::          Forms that call functions.
 * Macro Forms::             Forms that call macros.
-* Special Forms::           ``Special forms'' are idiosyncratic primitives,
+* Special Operators::       ``Special operators'' are idiosyncratic primitives,
                               most of them extremely important.
 * Autoloading::             Functions set up to load files
                               containing their real definitions.

--- a/man/lispref/macros.texi	Sun Jan 31 18:09:57 2010 +0000
+++ b/man/lispref/macros.texi	Sun Jan 31 20:28:01 2010 +0000
@@ -178,10 +178,39 @@
 from the macro call.
 
   It is possible to use an anonymous Lisp macro just like an anonymous
-function, but this is never done, because it does not make sense to pass
-an anonymous macro to functionals such as @code{mapcar}.  In practice,
-all Lisp macros have names, and they are usually defined with the
-special form @code{defmacro}.
+function.  It doesn't make sense to pass an anonymous macro to
+functionals such as @code{mapcar}, and it is usually more readable to
+use @code{macrolet} to make a local macro definition, and call that.
+But if, for whatever reason, @code{macrolet} is not available, code
+like the following may be useful:
+
+@example
+((macro . (lambda (&rest arguments)
+	    (let (res)
+	      (while (consp arguments)
+		(setq res (cons (cons 'put
+				      (cons (list 'quote (car arguments))
+					    '((quote my-property) t)))
+				res)
+		      arguments (cdr arguments)))
+	      (cons 'progn res))))
+ + - = floor ceiling round)
+@end example
+
+This expands to: 
+
+@example
+(progn
+  (put 'round 'my-property t)
+  (put 'ceiling 'my-property t)
+  (put 'floor 'my-property t)
+  (put '= 'my-property t)
+  (put '- 'my-property t)
+  (put '+ 'my-property t))
+@end example
+
+In practice, almost all Lisp macros have names, and they are usually
+defined with the special operator @code{defmacro}.
 
 @defspec defmacro name argument-list body-forms@dots{}
 @code{defmacro} defines the symbol @var{name} as a macro that looks
@@ -214,7 +243,7 @@
 
   Backquote allows you to quote a list, but selectively evaluate
 elements of that list.  In the simplest case, it is identical to the
-special form @code{quote} (@pxref{Quoting}).  For example, these
+special operator @code{quote} (@pxref{Quoting}).  For example, these
 two forms yield identical results:
 
 @example

--- a/man/lispref/objects.texi	Sun Jan 31 18:09:57 2010 +0000
+++ b/man/lispref/objects.texi	Sun Jan 31 20:28:01 2010 +0000
@@ -1217,15 +1217,15 @@
 
 @node Primitive Function Type
 @subsection Primitive Function Type
-@cindex special forms
+@cindex special operators
 
   A @dfn{primitive function} is a function callable from Lisp but
 written in the C programming language.  Primitive functions are also
 called @dfn{subrs} or @dfn{built-in functions}.  (The word ``subr'' is
 derived from ``subroutine''.)  Most primitive functions evaluate all
 their arguments when they are called.  A primitive function that does
-not evaluate all its arguments is called a @dfn{special form}
-(@pxref{Special Forms}).@refill
+not evaluate all its arguments is called a @dfn{special operator}
+(@pxref{Special Operators}).@refill
 
   It does not matter to the caller of a function whether the function is
 primitive.  However, this does matter if you try to substitute a

--- a/man/lispref/positions.texi	Sun Jan 31 18:09:57 2010 +0000
+++ b/man/lispref/positions.texi	Sun Jan 31 20:28:01 2010 +0000
@@ -758,7 +758,7 @@
   It is often useful to move point ``temporarily'' within a localized
 portion of the program, or to switch buffers temporarily.  This is
 called an @dfn{excursion}, and it is done with the @code{save-excursion}
-special form.  This construct saves the current buffer and its values of
+special operator.  This construct saves the current buffer and its values of
 point and the mark so they can be restored after the completion of the
 excursion.
 
@@ -770,13 +770,13 @@
 @cindex mark excursion
 @cindex point excursion
 @cindex current buffer excursion
-The @code{save-excursion} special form saves the identity of the current
+The @code{save-excursion} special operator saves the identity of the current
 buffer and the values of point and the mark in it, evaluates
 @var{forms}, and finally restores the buffer and its saved values of
 point and the mark.  All three saved values are restored even in case of
 an abnormal exit via @code{throw} or error (@pxref{Nonlocal Exits}).
 
-The @code{save-excursion} special form is the standard way to switch
+The @code{save-excursion} special operator is the standard way to switch
 buffers or move point within one part of a program and avoid affecting
 the rest of the program.  It is used more than 500 times in the Lisp
 sources of XEmacs.
@@ -813,24 +813,24 @@
 @end defspec
 
 @defspec save-current-buffer forms@dots{}
-This special form is similar to @code{save-excursion} but it only
+This special operator is similar to @code{save-excursion} but it only
 saves and restores the current buffer.  Beginning with XEmacs 20.3,
 @code{save-current-buffer} is a primitive.
 @end defspec
 
 @defspec with-current-buffer buffer forms@dots{}
-This special form evaluates @var{forms} with @var{buffer} as the current
+This macro evaluates @var{forms} with @var{buffer} as the current
 buffer.  It returns the value of the last form.
 @end defspec
 
 @defspec with-temp-file filename forms@dots{}
-This special form creates a new buffer, evaluates @var{forms} there, and
+This macro creates a new buffer, evaluates @var{forms} there, and
 writes the buffer to @var{filename}.  It returns the value of the last form
 evaluated.
 @end defspec
 
 @defspec save-selected-window forms@dots{}
-This special form is similar to @code{save-excursion} but it saves and
+This macro is similar to @code{save-excursion} but it saves and
 restores the selected window and nothing else.
 @end defspec
 
@@ -894,7 +894,7 @@
 @end deffn
 
 @defspec save-restriction body@dots{}
-This special form saves the current bounds of the accessible portion,
+This special operator saves the current bounds of the accessible portion,
 evaluates the @var{body} forms, and finally restores the saved bounds,
 thus restoring the same state of narrowing (or absence thereof) formerly
 in effect.  The state of narrowing is restored even in the event of an
@@ -922,7 +922,7 @@
 value were outside the limits of the temporary narrowing, this would
 fail to restore it accurately.
 
-The @code{save-restriction} special form records the values of the
+The @code{save-restriction} special operator records the values of the
 beginning and end of the accessible portion as distances from the
 beginning and end of the buffer.  In other words, it records the amount
 of inaccessible text before and after the accessible portion.

--- a/man/lispref/searching.texi	Sun Jan 31 18:09:57 2010 +0000
+++ b/man/lispref/searching.texi	Sun Jan 31 20:28:01 2010 +0000
@@ -1459,23 +1459,10 @@
   You can save and restore the match data with @code{save-match-data}:
 
 @defspec save-match-data body@dots{}
-This special form executes @var{body}, saving and restoring the match
+This special operator executes @var{body}, saving and restoring the match
 data around it.
 @end defspec
 
-  You can use @code{set-match-data} together with @code{match-data} to
-imitate the effect of the special form @code{save-match-data}.  This is
-useful for writing code that can run in Emacs 18.  Here is how:
-
-@example
-@group
-(let ((data (match-data)))
-  (unwind-protect
-      @dots{}   ; @r{May change the original match data.}
-    (set-match-data data)))
-@end group
-@end example
-
   Emacs automatically saves and restores the match data when it runs
 process filter functions (@pxref{Filter Functions}) and process
 sentinels (@pxref{Sentinels}).

--- a/man/lispref/specifiers.texi	Sun Jan 31 18:09:57 2010 +0000
+++ b/man/lispref/specifiers.texi	Sun Jan 31 20:28:01 2010 +0000
@@ -876,7 +876,7 @@
 @end defun
 
 @defspec let-specifier specifier-list &rest body
-This special form temporarily adds specifications to specifiers,
+This macro temporarily adds specifications to specifiers,
 evaluates forms in @var{body} and restores the specifiers to their
 previous states.  The specifiers and their temporary specifications are
 listed in @var{specifier-list}.
@@ -892,11 +892,10 @@
 @var{locale}.  @var{locale}, @var{tag-set} and @var{how-to-add} have the
 same meaning as in @code{add-spec-to-specifier}.
 
-This special form is implemented as a macro; the code resulting from
-macro expansion will add specifications to specifiers using
-@code{add-spec-to-specifier}.  After forms in @var{body} are evaluated,
-the temporary specifications are removed and old specifier spec-lists
-are restored.
+The code resulting from macro expansion will add specifications to
+specifiers using @code{add-spec-to-specifier}.  After forms in
+@var{body} are evaluated, the temporary specifications are removed and
+old specifier spec-lists are restored.
 
 @var{locale}, @var{tag-set} and @var{how-to-add} may be omitted, and
 default to @code{nil}.  The value of the last form in @var{body} is

--- a/man/lispref/symbols.texi	Sun Jan 31 18:09:57 2010 +0000
+++ b/man/lispref/symbols.texi	Sun Jan 31 20:28:01 2010 +0000
@@ -132,7 +132,7 @@
 @section Defining Symbols
 @cindex definition of a symbol
 
-  A @dfn{definition} in Lisp is a special form that announces your
+  A @dfn{definition} in Lisp is a special operator that announces your
 intention to use a certain symbol in a particular way.  In XEmacs Lisp,
 you can define a symbol as a variable, or define it as a function (or
 macro), or both independently.
@@ -143,7 +143,7 @@
 supply an initial value for the variable, plus documentation for the
 variable.
 
-  @code{defvar} and @code{defconst} are special forms that define a
+  @code{defvar} and @code{defconst} are special operators that define a
 symbol as a global variable.  They are documented in detail in
 @ref{Defining Variables}.
 

--- a/man/lispref/variables.texi	Sun Jan 31 18:09:57 2010 +0000
+++ b/man/lispref/variables.texi	Sun Jan 31 20:28:01 2010 +0000
@@ -128,7 +128,7 @@
 
   For example, when a function is called, its argument variables receive
 new local values that last until the function exits.  The @code{let}
-special form explicitly establishes new local values for specified
+special operator explicitly establishes new local values for specified
 variables; these last until exit from the @code{let} form.
 
 @cindex shadowing of variables
@@ -144,7 +144,7 @@
 speak of a @dfn{local binding} of the variable as well as a local value.
 
   The local binding is a conceptual place that holds a local value.
-Entry to a function, or a special form such as @code{let}, creates the
+Entry to a function, or a special operator such as @code{let}, creates the
 local binding; exit from the function or from the @code{let} removes the
 local binding.  As long as the local binding lasts, the variable's value
 is stored within it.  Use of @code{setq} or @code{set} while there is a
@@ -165,11 +165,11 @@
 Ordinary evaluation of a symbol always returns the value of its current
 binding.
 
-  The special forms @code{let} and @code{let*} exist to create
+  The special operators @code{let} and @code{let*} exist to create
 local bindings.
 
 @defspec let (bindings@dots{}) forms@dots{}
-This special form binds variables according to @var{bindings} and then
+This special operator binds variables according to @var{bindings} and then
 evaluates all of the @var{forms} in textual order.  The @code{let}-form
 returns the value of the last form in @var{forms}.
 
@@ -199,7 +199,7 @@
 @end defspec
 
 @defspec let* (bindings@dots{}) forms@dots{}
-This special form is like @code{let}, but it binds each variable right
+This special operator is like @code{let}, but it binds each variable right
 after computing its local value, before computing the local value for
 the next variable.  Therefore, an expression in @var{bindings} can
 reasonably refer to the preceding symbols bound in this @code{let*}
@@ -376,7 +376,7 @@
 @cindex variable definition
 
   You may announce your intention to use a symbol as a global variable
-with a @dfn{variable definition}: a special form, either @code{defconst}
+with a @dfn{variable definition}: a special operator, either @code{defconst}
 or @code{defvar}.
 
   In XEmacs Lisp, definitions serve three purposes.  First, they inform
@@ -404,7 +404,7 @@
 this reason, user options must be defined with @code{defvar}.
 
 @defspec defvar symbol [value [doc-string]]
-This special form defines @var{symbol} as a value and initializes it.
+This special operator defines @var{symbol} as a value and initializes it.
 The definition informs a person reading your code that @var{symbol} is
 used as a variable that programs are likely to set or change.  It is
 also used for all user option variables except in the preloaded parts of
@@ -475,7 +475,7 @@
 @end group
 @end example
 
-Here is an equivalent expression for the @code{defvar} special form:
+Here is an equivalent expression for the @code{defvar} special operator:
 
 @example
 @group
@@ -494,7 +494,7 @@
 @end defspec
 
 @defspec defconst symbol [value [doc-string]]
-This special form defines @var{symbol} as a value and initializes it.
+This special operator defines @var{symbol} as a value and initializes it.
 It informs a person reading your code that @var{symbol} has a global
 value, established here, that will not normally be changed or locally
 bound by the execution of the program.  The user, however, may be
@@ -553,7 +553,7 @@
   @strong{Warning:} If the @code{defconst} and @code{defvar} special
 forms are used while the variable has a local binding, they set the
 local binding's value; the global binding is not changed.  This is not
-what we really want.  To prevent it, use these special forms at top
+what we really want.  To prevent it, use these special operators at top
 level in a file, where normally no local binding is in effect, and make
 sure to load the file before making a local binding for the variable.
 
@@ -616,7 +616,7 @@
 run time, use the function @code{set}.
 
 @defspec setq [symbol form]@dots{}
-This special form is the most common method of changing a variable's
+This special operator is the most common method of changing a variable's
 value.  Each @var{symbol} is given a new value, which is the result of
 evaluating the corresponding @var{form}.  The most-local existing
 binding of the symbol is changed.
@@ -1232,7 +1232,7 @@
 this variable.
 
 @c Emacs 19 feature
-  The special forms @code{defvar} and @code{defconst} also set the
+  The special operators @code{defvar} and @code{defconst} also set the
 default value (if they set the variable at all), rather than any local
 value.
 

--- a/man/lispref/windows.texi	Sun Jan 31 18:09:57 2010 +0000
+++ b/man/lispref/windows.texi	Sun Jan 31 20:28:01 2010 +0000
@@ -443,7 +443,7 @@
 @end defun
 
 @defspec save-selected-window forms@dots{}
-This special form records the selected window, executes @var{forms} in
+This macro records the selected window, executes @var{forms} in
 sequence, then restores the earlier selected window.  It does not save
 or restore anything about the sizes, arrangement or contents of windows;
 therefore, if the @var{forms} change them, the changes are permanent.
@@ -1955,7 +1955,7 @@
 @end defun
 
 @defspec save-window-excursion forms@dots{}
-This special form records the window configuration, executes @var{forms}
+This macro records the window configuration, executes @var{forms}
 in sequence, then restores the earlier window configuration.  The window
 configuration includes the value of point and the portion of the buffer
 that is visible.  It also includes the choice of selected window.

--- a/man/xemacs-faq.texi	Sun Jan 31 18:09:57 2010 +0000
+++ b/man/xemacs-faq.texi	Sun Jan 31 20:28:01 2010 +0000
@@ -7781,12 +7781,10 @@
 
 @emph{Interpreted} code, on the other hand, must expand these macros
 every time they are executed.  For this reason it is strongly
-recommended that code making heavy use of macros be compiled.  (The
-features labelled @dfn{Special Form} instead of @dfn{Function} in this
-manual are macros.)  A loop using @code{incf} a hundred times will
-execute considerably faster if compiled, and will also garbage-collect
-less because the macro expansion will not have to be generated, used,
-and thrown away a hundred times.
+recommended that code making heavy use of macros be compiled. A loop
+using @code{incf} a hundred times will execute considerably faster if
+compiled, and will also garbage-collect less because the macro expansion
+will not have to be generated, used, and thrown away a hundred times.
 
 You can find out how a macro expands by using the @code{cl-prettyexpand}
 function.
@@ -8585,7 +8583,7 @@
 @strong{Frame focus changes}: @code{focus-follows-mouse} works like FSF,
 prevents any attempt to permanently change the selected frame; new
 function @code{focus-frame} sets the window system focus a frame; new
-special forms @code{save-selected-frame} and @code{with-selected-frame}.
+macros @code{save-selected-frame} and @code{with-selected-frame}.
 
 @item
 @strong{Window function changes}: @code{select-window} now has optional

--- a/man/xemacs/programs.texi	Sun Jan 31 18:09:57 2010 +0000
+++ b/man/xemacs/programs.texi	Sun Jan 31 20:28:01 2010 +0000
@@ -271,7 +271,7 @@
 
   In Emacs, a parenthetical grouping at the top level in the buffer is
 called a @dfn{defun}.  The name derives from the fact that most
-top-level lists in Lisp are instances of the special form
+top-level lists in Lisp are instances of the special operator
 @code{defun}, but Emacs calls any top-level parenthetical
 grouping counts a defun regardless of its contents or
 the programming language.  For example, in C, the body of a

--- a/src/ChangeLog	Sun Jan 31 18:09:57 2010 +0000
+++ b/src/ChangeLog	Sun Jan 31 20:28:01 2010 +0000
@@ -1,3 +1,13 @@
+2010-01-31  Aidan Kehoe  <kehoea@parhasard.net>
+
+	* symbols.c (Fspecial_operator_p, syms_of_symbols):
+	* eval.c (print_subr, Finteractive_p, Ffuncall)
+	(Ffunction_min_args, Ffunction_max_args, vars_of_eval):
+	* editfns.c:
+	* data.c (Fsubr_max_args):
+	* doc.c (Fbuilt_in_symbol_file):
+	Change "special form" to "special operator" in our sources.
+
 2010-01-31  Aidan Kehoe  <kehoea@parhasard.net>
 
 	* search.c (search_buffer): 

--- a/src/data.c	Sun Jan 31 18:09:57 2010 +0000
+++ b/src/data.c	Sun Jan 31 20:28:01 2010 +0000
@@ -342,7 +342,7 @@
 
 DEFUN ("subr-max-args", Fsubr_max_args, 1, 1, 0, /*
 Return maximum number of args built-in function SUBR may be called with,
-or nil if it takes an arbitrary number of arguments or is a special form.
+or nil if it takes an arbitrary number of arguments or is a special operator.
 */
        (subr))
 {

--- a/src/doc.c	Sun Jan 31 18:09:57 2010 +0000
+++ b/src/doc.c	Sun Jan 31 20:28:01 2010 +0000
@@ -504,7 +504,7 @@
 Don't use this.  Use the more general `symbol-file' (q.v.) instead. 
 
 If TYPE is nil or omitted, any kind of definition is acceptable. 
-If TYPE is `defun', then function, subr, special form or macro definitions
+If TYPE is `defun', then function, subr, special operator or macro definitions
 are acceptable.
 If TYPE is `defvar', then variable definitions are acceptable.
 */

--- a/src/editfns.c	Sun Jan 31 18:09:57 2010 +0000
+++ b/src/editfns.c	Sun Jan 31 20:28:01 2010 +0000
@@ -2131,8 +2131,8 @@
 Execute BODY, saving and restoring current buffer's restrictions.
 The buffer's restrictions make parts of the beginning and end invisible.
 \(They are set up with `narrow-to-region' and eliminated with `widen'.)
-This special form, `save-restriction', saves the current buffer's restrictions
-when it is entered, and restores them when it is exited.
+This special operator, `save-restriction', saves the current buffer's
+restrictions when it is entered, and restores them when it is exited.
 So any `narrow-to-region' within BODY lasts only until the end of the form.
 The old restrictions settings are restored
 even in case of abnormal exit (throw or error).

--- a/src/eval.c	Sun Jan 31 18:09:57 2010 +0000
+++ b/src/eval.c	Sun Jan 31 20:28:01 2010 +0000
@@ -427,7 +427,7 @@
 {
   Lisp_Subr *subr = XSUBR (obj);
   const CIbyte *header =
-    (subr->max_args == UNEVALLED) ? "#<special-form " : "#<subr ";
+    (subr->max_args == UNEVALLED) ? "#<special-operator " : "#<subr ";
   const CIbyte *name = subr_name (subr);
   const CIbyte *trailer = subr->prompt ? " (interactive)>" : ">";
 
@@ -823,7 +823,7 @@
 /*		       The basic special forms				*/
 /************************************************************************/
 
-/* Except for Fprogn(), the basic special forms below are only called
+/* Except for Fprogn(), the basic special operators below are only called
    from interpreted code.  The byte compiler turns them into bytecodes. */
 
 DEFUN ("or", For, 0, UNEVALLED, 0, /*
@@ -3302,7 +3302,7 @@
     btp = btp->next;
 
   /* If this isn't a byte-compiled function, then we may now be
-     looking at several frames for special forms.  Skip past them.  */
+     looking at several frames for special operators.  Skip past them.  */
   while (btp &&
 	 btp->nargs == UNEVALLED)
     btp = btp->next;
@@ -4060,7 +4060,7 @@
 	  val = SUBR_FUNCTION (subr, MANY) (fun_nargs, fun_args);
 	  PROFILE_EXIT_FUNCTION ();
 	}
-      else if (max_args == UNEVALLED) /* Can't funcall a special form */
+      else if (max_args == UNEVALLED) /* Can't funcall a special operator */
 	{
           /* Ugh, ugh, ugh. */
           if (EQ (fun, XSYMBOL_FUNCTION (Qthrow)))
@@ -4243,7 +4243,7 @@
 DEFUN ("function-min-args", Ffunction_min_args, 1, 1, 0, /*
 Return the minimum number of arguments a function may be called with.
 The function may be any form that can be passed to `funcall',
-any special form, or any macro.
+any special operator, or any macro.
 
 To check if a function can be called with a specified number of
 arguments, use `function-allows-args'.
@@ -4256,9 +4256,9 @@
 DEFUN ("function-max-args", Ffunction_max_args, 1, 1, 0, /*
 Return the maximum number of arguments a function may be called with.
 The function may be any form that can be passed to `funcall',
-any special form, or any macro.
+any special operator, or any macro.
 If the function takes an arbitrary number of arguments or is
-a built-in special form, nil is returned.
+a built-in special operator, nil is returned.
 
 To check if a function can be called with a specified number of
 arguments, use `function-allows-args'.
@@ -4415,7 +4415,7 @@
    A multiple value object is returned by #'values if:
 
    -- The number of arguments to #'values is not one, and: 
-   -- Some special form in the call stack is prepared to handle more than
+   -- Some special operator in the call stack is prepared to handle more than
    one multiple value.
    
    The return value of #'values-list is analogous to that of #'values.
@@ -4430,7 +4430,7 @@
    objects should be converted to heap allocation at that point.
 
    The specific multiple values saved and returned depend on how many
-   multiple-values special forms in the stack are interested in; for
+   multiple-values special operators in the stack are interested in; for
    example, if #'multiple-value-call is somewhere in the call stack, all
    values passed to #'values will be saved and returned.  If an expansion of
    #'multiple-value-setq with 10 SYMS is the only part of the call stack
@@ -7158,8 +7158,8 @@
 
 DEFUN ("backtrace-frame", Fbacktrace_frame, 1, 1, 0, /*
 Return the function and arguments NFRAMES up from current execution point.
-If that frame has not evaluated the arguments yet (or is a special form),
-the value is (nil FUNCTION ARG-FORMS...).
+If that frame has not evaluated the arguments yet (or involves a special
+operator), the value is (nil FUNCTION ARG-FORMS...).
 If that frame has evaluated its arguments and called its function already,
 the value is (t FUNCTION ARG-VALUES...).
 A &rest arg is represented as the tail of the list ARG-VALUES.
@@ -7527,7 +7527,7 @@
 The exclusive upper bound on the number of multiple values. 
 
 This applies to `values', `values-list', `multiple-value-bind' and related
-macros and special forms.
+macros and special operators.
 */);
   Vmultiple_values_limit = EMACS_INT_MAX > INT_MAX ? INT_MAX : EMACS_INT_MAX;
 

--- a/src/symbols.c	Sun Jan 31 18:09:57 2010 +0000
+++ b/src/symbols.c	Sun Jan 31 20:28:01 2010 +0000
@@ -738,13 +738,13 @@
   return make_string ((const Ibyte *)name, strlen (name));
 }
 
-DEFUN ("special-form-p", Fspecial_form_p, 1, 1, 0, /*
-Return whether SUBR is a special form.
-
-A special form is a built-in function (a subr, that is a function
+DEFUN ("special-operator-p", Fspecial_operator_p, 1, 1, 0, /*
+Return whether SUBR is a special operator.
+
+A special operator is a built-in function (a subr, that is a function
 implemented in C, not Lisp) which does not necessarily evaluate all its
 arguments.  Much of the basic XEmacs Lisp syntax is implemented by means of
-special forms; examples are `let', `condition-case', `defun', `setq' and so
+special operators; examples are `let', `condition-case', `setq', and so
 on.
 
 If you intend to write a Lisp function that does not necessarily evaluate
@@ -3899,7 +3899,7 @@
   DEFSUBR (Fdefine_function);
   Ffset (intern ("defalias"), intern ("define-function"));
   DEFSUBR (Fsubr_name);
-  DEFSUBR (Fspecial_form_p);
+  DEFSUBR (Fspecial_operator_p);
   DEFSUBR (Fsetplist);
   DEFSUBR (Fsymbol_value_in_buffer);
   DEFSUBR (Fsymbol_value_in_console);