Mercurial > hg > xemacs-beta

diff man/lispref/control.texi @ 4905:755ae5b97edb

Find changesets by keywords (author, files, the commit message), revision number or hash, or revset expression.
Change "special form" to "special operator" in our sources. Add a compatible function alias, and the relevant manual index entries. src/ChangeLog addition: 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. man/ChangeLog addition: 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. lisp/ChangeLog addition: 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.
author Aidan Kehoe <kehoea@parhasard.net>
date Sun, 31 Jan 2010 20:28:01 +0000
parents 13a418960a88
children 62b9ef1ed4ac
line wrap: on
line diff
--- 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