xemacs-beta: src/eval.c comparison

comparison src/eval.c @ 4962:e813cf16c015

merge

author	Ben Wing <ben@xemacs.org>
date	Mon, 01 Feb 2010 05:29:05 -0600
parents	19a72041c5ed 755ae5b97edb
children	cbe181529c34

comparison

equal deleted inserted replaced

-:b90f8cf474e0
+:e813cf16c015
 static void
 print_subr (Lisp_Object obj, Lisp_Object printcharfun, int UNUSED (escapeflag))
 {
 Lisp_Subr *subr = XSUBR (obj);
 const Ascbyte *header =
-(subr->max_args == UNEVALLED) ? "#<special-form " : "#<subr ";
+(subr->max_args == UNEVALLED) ? "#<special-operator " : "#<subr ";
 const Ascbyte *name = subr_name (subr);
 const Ascbyte *trailer = subr->prompt ? " (interactive)>" : ">";
 if (print_readably)
 printing_unreadable_object ("%s%s%s", header, name, trailer);
 /************************************************************************/
 /*		       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, /*
 Eval ARGS until one of them yields non-nil, then return that value.
 The remaining ARGS are not evalled at all.
 byte-compiled functions, we'll accept it for now.  */
 if (EQ (*btp->function, Qbyte_code))
 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;
 #else
 	{
 	  PROFILE_ENTER_FUNCTION ();
 	  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)))
 {
 args[0] = Qobsolete_throw;
 }
 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'.
 */
 (function))
 }
 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'.
 */
 (function))
 /* Multiple values.
 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.
 Henry Baker, in https://eprints.kfupm.edu.sa/31898/1/31898.pdf ("CONS
 something not true for us. As far as I can tell, it also ignores the
 contexts where multiple-values need to be thrown, or maybe it thinks such
 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
 interested in multiple values, then a maximum of ten multiple values will
 be saved and returned.
 }
 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),
+If that frame has not evaluated the arguments yet (or involves a special
-the value is (nil FUNCTION ARG-FORMS...).
+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.
 FUNCTION is whatever was supplied as car of evaluated list,
 or a lambda expression for macro calls.
 DEFVAR_CONST_INT ("multiple-values-limit", &Vmultiple_values_limit /*
 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;
 staticpro (&Vcatch_everything_tag);
 Vcatch_everything_tag = make_opaque (OPAQUE_CLEAR, 0);

Mercurial > hg > xemacs-beta

comparison src/eval.c @ 4962:e813cf16c015