xemacs-beta: src/eval.c comparison

comparison src/eval.c @ 444:576fb035e263 r21-2-37

Import from CVS: tag r21-2-37

author	cvs
date	Mon, 13 Aug 2007 11:36:19 +0200
parents	abe6d1db359e
children	3d3049ae1304

comparison

equal deleted inserted replaced

-:a8296e22da4e
+:576fb035e263
 #define AV_6(av) AV_5(av), av[5]
 #define AV_7(av) AV_6(av), av[6]
 #define AV_8(av) AV_7(av), av[7]
 #define PRIMITIVE_FUNCALL_1(fn, av, ac) \
 (((Lisp_Object (*)(EXFUN_##ac)) (fn)) (AV_##ac (av)))
 /* If subrs take more than 8 arguments, more cases need to be added
 to this switch.  (But wait - don't do it - if you really need
 a SUBR with more than 8 arguments, use max_args == MANY.
 See the DEFUN macro in lisp.h)  */
 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.
+\(cond CLAUSES...): 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.
 back to the place that established the catch (in this case,
 condition_case_1).  See below for more info.
 */
 DEFUN ("throw", Fthrow, 2, 2, 0, /*
-\(throw TAG VALUE): throw to the catch for TAG and return VALUE from it.
+Throw to the catch for TAG and return VALUE from it.
 Both TAG and VALUE are evalled.
 */
-(tag, val))
+(tag, value))
 {
-throw_or_bomb_out (tag, val, 0, Qnil, Qnil); /* Doesn't return */
+throw_or_bomb_out (tag, value, 0, Qnil, Qnil); /* Doesn't return */
 return Qnil;
 }
 DEFUN ("unwind-protect", Funwind_protect, 1, UNEVALLED, 0, /*
 Do BODYFORM, protecting with UNWINDFORMS.
 CMD must be an object that satisfies the `commandp' predicate.
 Optional second arg RECORD-FLAG is as in `call-interactively'.
 The argument KEYS specifies the value to use instead of (this-command-keys)
 when reading the arguments.
 */
-(cmd, record, keys))
+(cmd, record_flag, keys))
 {
 /* This function can GC */
 Lisp_Object prefixarg;
 Lisp_Object final = cmd;
 struct backtrace backtrace;
 backtrace.evalargs = 0;
 backtrace.pdlcount = specpdl_depth();
 backtrace.debug_on_exit = 0;
 PUSH_BACKTRACE (backtrace);
-final = Fcall_interactively (cmd, record, keys);
+final = Fcall_interactively (cmd, record_flag, keys);
 POP_BACKTRACE (backtrace);
 return final;
 }
 else if (STRINGP (final) || VECTORP (final))
 /************************************************************************/
 /*			      Autoloading				*/
 /************************************************************************/
 DEFUN ("autoload", Fautoload, 2, 5, 0, /*
-Define FUNCTION to autoload from FILE.
+Define FUNCTION to autoload from FILENAME.
-FUNCTION is a symbol; FILE is a file name string to pass to `load'.
+FUNCTION is a symbol; FILENAME is a file name string to pass to `load'.
-Third arg DOCSTRING is documentation for the function.
+The remaining optional arguments provide additional info about the
-Fourth arg INTERACTIVE if non-nil says function can be called interactively.
+real definition.
-Fifth arg TYPE indicates the type of the object:
+DOCSTRING is documentation for FUNCTION.
+INTERACTIVE, if non-nil, says FUNCTION can be called interactively.
+TYPE indicates the type of the object:
 nil or omitted says FUNCTION is a function,
 `keymap' says FUNCTION is really a keymap, and
 `macro' or t says FUNCTION is really a macro.
-Third through fifth args give info about the real definition.
+If FUNCTION already has a non-void function definition that is not an
-They default to nil.
+autoload object, this function does nothing and returns nil.
-If FUNCTION is already defined other than as an autoload,
-this does nothing and returns nil.
 */
-(function, file, docstring, interactive, type))
+(function, filename, docstring, interactive, type))
 {
 /* This function can GC */
 CHECK_SYMBOL (function);
-CHECK_STRING (file);
+CHECK_STRING (filename);
 /* If function is defined and not as an autoload, don't override */
 {
 Lisp_Object f = XSYMBOL (function)->function;
 if (!UNBOUNDP (f) && !(CONSP (f) && EQ (XCAR (f), Qautoload)))
 }
 if (purify_flag)
 {
 /* Attempt to avoid consing identical (string=) pure strings. */
-file = Fsymbol_name (Fintern (file, Qnil));
+filename = Fsymbol_name (Fintern (filename, Qnil));
 }
-return Ffset (function, Fcons (Qautoload, list4 (file,
+return Ffset (function, Fcons (Qautoload, list4 (filename,
 						   docstring,
 						   interactive,
 						   type)));
 }
 value, that value may be a function or a list of functions to be
 called to run the hook.  If the value is a function, it is called with
 the given arguments and its return value is returned.  If it is a list
 of functions, those functions are called, in order,
 with the given arguments ARGS.
-It is best not to depend on the value return by `run-hook-with-args',
+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'.
 */
 }
 DEFUN ("backtrace", Fbacktrace, 0, 2, "", /*
 Print a trace of Lisp function calls currently active.
 Optional arg STREAM specifies the output stream to send the backtrace to,
-and defaults to the value of `standard-output'.  Optional second arg
+and defaults to the value of `standard-output'.
-DETAILED means show places where currently active variable bindings,
+Optional second arg DETAILED non-nil means show places where currently
-catches, condition-cases, and unwind-protects were made as well as
+active variable bindings, catches, condition-cases, and
-function calls.
+unwind-protects, as well as function calls, were made.
 */
 (stream, detailed))
 {
 /* This function can GC */
 struct backtrace *backlist = backtrace_list;
 Vinhibit_quit = oiq;
 return Qnil;
 }
-DEFUN ("backtrace-frame", Fbacktrace_frame, 1, 1, "", /*
+DEFUN ("backtrace-frame", Fbacktrace_frame, 1, 1, 0, /*
-Return the function and arguments N frames up from current execution point.
+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 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.
-If N is more than the number of frames, the value is nil.
+If NFRAMES is more than the number of frames, the value is nil.
 */
 (nframes))
 {
 REGISTER struct backtrace *backlist = backtrace_list;
 REGISTER int i;

Mercurial > hg > xemacs-beta

comparison src/eval.c @ 444:576fb035e263 r21-2-37