xemacs-beta: src/eval.c comparison

comparison src/eval.c @ 4642:48b45a606961

Support #'function-arglist with built-in special forms. Also fix a couple of bugs in lisp/help.el. lisp/ChangeLog addition: 2009-06-14 Aidan Kehoe <kehoea@parhasard.net> * help.el (describe-function-1): Check macro-p, not macrop, when describing whether a symbol has an associated macro or an associated function. Relevant with autoloaded macros. (function-arglist): Accept multi-line arglists in built-in functions, as found in #'write-region-internal. #'dontusethis-set-symbol-value-handler is still broken for other reasons. src/ChangeLog addition: 2009-06-14 Aidan Kehoe <kehoea@parhasard.net> * eval.c (For): * eval.c (Fand): * eval.c (Fif): * eval.c (Fwhen): * eval.c (Fcond): * eval.c (Fprogn): * eval.c (Fprog1): * eval.c (Fprog2): * eval.c (FletX): * eval.c (Flet): * eval.c (Fwhile): * eval.c (Fdefvar): * eval.c (Fdefconst): * eval.c (Frun_hooks): * eval.c (Frun_hooks_with_args): * eval.c (Frun_hooks_with_args_until_success): * eval.c (Frun_hooks_with_args_until_failure): Add arguments information, understood by #'function-arglist, to all these special forms, functions and macros. Remove the argument information that was already there that was not understood by #'function-arglist.

author	Aidan Kehoe <kehoea@parhasard.net>
date	Sun, 14 Jun 2009 15:07:13 +0100
parents	9dd42cb187ed
children	f8d7d8202635

comparison

equal deleted inserted replaced

-:a90b63846dc4
+:48b45a606961
 /* Except for Fprogn(), the basic special forms 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.
+Eval ARGS until one of them yields non-nil, then return that value.
-The remaining args are not evalled at all.
+The remaining ARGS are not evalled at all.
 If all args return nil, return nil.
+arguments: (&rest ARGS)
 */
 (args))
 {
 /* This function can GC */
 REGISTER Lisp_Object val;
 return Qnil;
 }
 DEFUN ("and", Fand, 0, UNEVALLED, 0, /*
-Eval args until one of them yields nil, then return nil.
+Eval ARGS until one of them yields nil, then return nil.
-The remaining args are not evalled at all.
+The remaining ARGS are not evalled at all.
 If no arg yields nil, return the last arg's value.
+arguments: (&rest ARGS)
 */
 (args))
 {
 /* This function can GC */
 REGISTER Lisp_Object val = Qt;
 return val;
 }
 DEFUN ("if", Fif, 2, UNEVALLED, 0, /*
-\(if COND THEN ELSE...): if COND yields non-nil, do THEN, else do ELSE...
+If COND yields non-nil, do THEN, else do ELSE.
 Returns the value of THEN or the value of the last of the ELSE's.
 THEN must be one expression, but ELSE... can be zero or more expressions.
 If COND yields nil, and there are no ELSE's, the value is nil.
+arguments: (COND THEN &rest ELSE)
 */
 (args))
 {
 /* This function can GC */
 Lisp_Object condition  = XCAR (args);
 /* Macros `when' and `unless' are trivially defined in Lisp,
 but it helps for bootstrapping to have them ALWAYS defined. */
 DEFUN ("when", Fwhen, 1, MANY, 0, /*
-\(when COND BODY...): if COND yields non-nil, do BODY, else return nil.
+If COND yields non-nil, do BODY, else return nil.
 BODY can be zero or more expressions.  If BODY is nil, return nil.
+arguments: (COND &rest BODY)
 */
 (int nargs, Lisp_Object *args))
 {
 Lisp_Object cond = args[0];
 Lisp_Object body;
 return list3 (Qif, cond, body);
 }
 DEFUN ("unless", Funless, 1, MANY, 0, /*
-\(unless COND BODY...): if COND yields nil, do BODY, else return nil.
+If COND yields nil, do BODY, else return nil.
 BODY can be zero or more expressions.  If BODY is nil, return nil.
+arguments: (COND &rest BODY)
 */
 (int nargs, Lisp_Object *args))
 {
 Lisp_Object cond = args[0];
 Lisp_Object body = Flist (nargs-1, args+1);
 return Fcons (Qif, Fcons (cond, Fcons (Qnil, body)));
 }
 DEFUN ("cond", Fcond, 0, UNEVALLED, 0, /*
-\(cond CLAUSES...): try each clause until one succeeds.
+Try each clause until one succeeds.
 Each clause looks like (CONDITION BODY...).  CONDITION is evaluated
 and, if the value is non-nil, this clause succeeds:
 then the expressions in BODY are evaluated and the last one's
 value is the value of the cond-form.
 If no clause succeeds, cond returns nil.
 If a clause has one element, as in (CONDITION),
 CONDITION's value if non-nil is returned from the cond-form.
+arguments: (&rest CLAUSES)
 */
 (args))
 {
 /* This function can GC */
 REGISTER Lisp_Object val;
 return Qnil;
 }
 DEFUN ("progn", Fprogn, 0, UNEVALLED, 0, /*
-\(progn BODY...): eval BODY forms sequentially and return value of last one.
+Eval BODY forms sequentially and return value of last one.
+arguments: (&rest BODY)
 */
 (args))
 {
 /* This function can GC */
 /* Caller must provide a true list in ARGS */
 /* Fprog1() is the canonical example of a function that must GCPRO a
 Lisp_Object across calls to Feval(). */
 DEFUN ("prog1", Fprog1, 1, UNEVALLED, 0, /*
 Similar to `progn', but the value of the first form is returned.
-\(prog1 FIRST BODY...): All the arguments are evaluated sequentially.
-The value of FIRST is saved during evaluation of the remaining args,
+All the arguments are evaluated sequentially.  The value of FIRST is saved
-whose values are discarded.
+during evaluation of the remaining args, whose values are discarded.
+arguments: (FIRST &rest BODY)
 */
 (args))
 {
-/* This function can GC */
 Lisp_Object val;
 struct gcpro gcpro1;
 val = Feval (XCAR (args));
 return val;
 }
 DEFUN ("prog2", Fprog2, 2, UNEVALLED, 0, /*
 Similar to `progn', but the value of the second form is returned.
-\(prog2 FIRST SECOND BODY...): All the arguments are evaluated sequentially.
-The value of SECOND is saved during evaluation of the remaining args,
+All the arguments are evaluated sequentially.  The value of SECOND is saved
-whose values are discarded.
+during evaluation of the remaining args, whose values are discarded.
+arguments: (FIRST SECOND &rest BODY)
 */
 (args))
 {
 /* This function can GC */
 Lisp_Object val;
 UNGCPRO;
 return val;
 }
 DEFUN ("let*", FletX, 1, UNEVALLED, 0, /*
-\(let* VARLIST BODY...): bind variables according to VARLIST then eval BODY.
+Bind variables according to VARLIST then eval BODY.
 The value of the last form in BODY is returned.
 Each element of VARLIST is a symbol (which is bound to nil)
 or a list (SYMBOL VALUEFORM) (which binds SYMBOL to the value of VALUEFORM).
 Each VALUEFORM can refer to the symbols already bound by this VARLIST.
+arguments: (VARLIST &rest BODY)
 */
 (args))
 {
 /* This function can GC */
 Lisp_Object varlist = XCAR (args);
 }
 return unbind_to_1 (speccount, Fprogn (body));
 }
 DEFUN ("let", Flet, 1, UNEVALLED, 0, /*
-\(let VARLIST BODY...): bind variables according to VARLIST then eval BODY.
+Bind variables according to VARLIST then eval BODY.
 The value of the last form in BODY is returned.
 Each element of VARLIST is a symbol (which is bound to nil)
 or a list (SYMBOL VALUEFORM) (which binds SYMBOL to the value of VALUEFORM).
 All the VALUEFORMs are evalled before any symbols are bound.
+arguments: (VARLIST &rest BODY)
 */
 (args))
 {
 /* This function can GC */
 Lisp_Object varlist = XCAR (args);
 return unbind_to_1 (speccount, Fprogn (body));
 }
 DEFUN ("while", Fwhile, 1, UNEVALLED, 0, /*
-\(while TEST BODY...): if TEST yields non-nil, eval BODY... and repeat.
+If TEST yields non-nil, eval BODY... and repeat.
 The order of execution is thus TEST, BODY, TEST, BODY and so on
 until TEST returns nil.
+arguments: (TEST &rest BODY)
 */
 (args))
 {
 /* This function can GC */
 Lisp_Object test = XCAR (args);
 return define_function (XCAR (args),
 			  Fcons (Qmacro, Fcons (Qlambda, XCDR (args))));
 }
 DEFUN ("defvar", Fdefvar, 1, UNEVALLED, 0, /*
-\(defvar SYMBOL INITVALUE DOCSTRING): define SYMBOL as a variable.
+Define SYMBOL as a variable.
 You are not required to define a variable in order to use it,
 but the definition can supply documentation and an initial value
 in a way that tags can recognize.
 INITVALUE is evaluated, and used to set SYMBOL, only if SYMBOL's value is
 If DOCSTRING starts with *, this variable is identified as a user option.
 This means that M-x set-variable recognizes it.
 If INITVALUE is missing, SYMBOL's value is not set.
 In lisp-interaction-mode defvar is treated as defconst.
+arguments: (SYMBOL &optional INITVALUE DOCSTRING)
 */
 (args))
 {
 /* This function can GC */
 Lisp_Object sym = XCAR (args);
 LOADHIST_ATTACH (sym);
 return sym;
 }
 DEFUN ("defconst", Fdefconst, 2, UNEVALLED, 0, /*
-\(defconst SYMBOL INITVALUE DOCSTRING): define SYMBOL as a constant
+Define SYMBOL as a constant variable.
-variable.
 The intent is that programs do not change this value, but users may.
 Always sets the value of SYMBOL to the result of evalling INITVALUE.
 If SYMBOL is buffer-local, its default value is what is set;
 buffer-local values are not affected.
 DOCSTRING is optional.
 Note: do not use `defconst' for user options in libraries that are not
 normally loaded, since it is useful for users to be able to specify
 their own values for such variables before loading the library.
 Since `defconst' unconditionally assigns the variable,
 it would override the user's choice.
+arguments: (SYMBOL &optional INITVALUE DOCSTRING)
 */
 (args))
 {
 /* This function can GC */
 Lisp_Object sym = XCAR (args);
 If the value is a function, it is called with no arguments.
 If it is a list, the elements are called, in order, with no arguments.
 To make a hook variable buffer-local, use `make-local-hook',
 not `make-local-variable'.
+arguments: (&rest HOOKS)
 */
 (int nargs, Lisp_Object *args))
 {
 REGISTER int i;
 It is best not to depend on the value returned by `run-hook-with-args',
 as that may change.
 To make a hook variable buffer-local, use `make-local-hook',
 not `make-local-variable'.
+arguments: (HOOK &rest ARGS)
 */
 (int nargs, Lisp_Object *args))
 {
 return run_hook_with_args (nargs, args, RUN_HOOKS_TO_COMPLETION);
 }
 returns a non-nil value.  Then we return that value.
 If all the functions return nil, we return nil.
 To make a hook variable buffer-local, use `make-local-hook',
 not `make-local-variable'.
+arguments: (HOOK &rest ARGS)
 */
 (int nargs, Lisp_Object *args))
 {
 return run_hook_with_args (nargs, args, RUN_HOOKS_UNTIL_SUCCESS);
 }
 returns nil.  Then we return nil.
 If all the functions return non-nil, we return non-nil.
 To make a hook variable buffer-local, use `make-local-hook',
 not `make-local-variable'.
+arguments: (HOOK &rest ARGS)
 */
 (int nargs, Lisp_Object *args))
 {
 return run_hook_with_args (nargs, args, RUN_HOOKS_UNTIL_FAILURE);
 }

Mercurial > hg > xemacs-beta

comparison src/eval.c @ 4642:48b45a606961