xemacs-beta: src/eval.c comparison

comparison src/eval.c @ 20:859a2309aef8 r19-15b93

Import from CVS: tag r19-15b93

author	cvs
date	Mon, 13 Aug 2007 08:50:05 +0200
parents	0293115a14e9
children	8d2a9b52c682

comparison

equal deleted inserted replaced

-:ac1f612d5250
+:859a2309aef8
 static Lisp_Object
 do_debug_on_exit (Lisp_Object val)
 {
 /* This is falsified by call_debugger */
-int old_debug_on_next_call = debug_on_next_call;
 Lisp_Object v = call_debugger (list2 (Qexit, val));
-debug_on_next_call = old_debug_on_next_call;
 return ((!UNBOUNDP (v)) ? v : val);
 }
 /* Called when debug-on-call behavior is called for.  Enter the debugger
 with the appropriate args for this.  VAL is either t for a call
 /* NOTE!!! Every function that can call EVAL must protect its args
 and temporaries from garbage collection while it needs them.
 The definition of `For' shows what you have to do.  */
-DEFUN ("or", For, Sor, 0, UNEVALLED, 0 /*
+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.
 If all args return nil, return nil.
-*/ )
+*/
-(args)
+(args))
-Lisp_Object args;
 {
 /* This function can GC */
 REGISTER Lisp_Object val;
 Lisp_Object args_left;
 struct gcpro gcpro1;
 UNGCPRO;
 return val;
 }
-DEFUN ("and", Fand, Sand, 0, UNEVALLED, 0 /*
+DEFUN ("and", Fand, 0, UNEVALLED, 0, /*
 Eval args until one of them yields nil, then return nil.
 The remaining args are not evalled at all.
 If no arg yields nil, return the last arg's value.
-*/ )
+*/
-(args)
+(args))
-Lisp_Object args;
 {
 /* This function can GC */
 REGISTER Lisp_Object val;
 Lisp_Object args_left;
 struct gcpro gcpro1;
 UNGCPRO;
 return val;
 }
-DEFUN ("if", Fif, Sif, 2, UNEVALLED, 0 /*
+DEFUN ("if", Fif, 2, UNEVALLED, 0, /*
 (if COND THEN 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.
-*/ )
+*/
-(args)
+(args))
-Lisp_Object args;
 {
 /* This function can GC */
 Lisp_Object cond;
 struct gcpro gcpro1;
 if (!NILP (cond))
 return Feval (Fcar (Fcdr (args)));
 return Fprogn (Fcdr (Fcdr (args)));
 }
-DEFUN ("cond", Fcond, Scond, 0, UNEVALLED, 0 /*
+DEFUN ("cond", Fcond, 0, UNEVALLED, 0, /*
 (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.
 If a clause has one element, as in (CONDITION),
 CONDITION's value if non-nil is returned from the cond-form.
-*/ )
+*/
-(args)
+(args))
-Lisp_Object args;
 {
 /* This function can GC */
 REGISTER Lisp_Object clause, val;
 struct gcpro gcpro1;
 UNGCPRO;
 return val;
 }
-DEFUN ("progn", Fprogn, Sprogn, 0, UNEVALLED, 0 /*
+DEFUN ("progn", Fprogn, 0, UNEVALLED, 0, /*
 (progn BODY...): eval BODY forms sequentially and return value of last one.
-*/ )
+*/
-(args)
+(args))
-Lisp_Object args;
 {
 /* This function can GC */
 REGISTER Lisp_Object val;
 Lisp_Object args_left;
 struct gcpro gcpro1;
 UNGCPRO;
 return val;
 }
-DEFUN ("prog1", Fprog1, Sprog1, 1, UNEVALLED, 0 /*
+DEFUN ("prog1", Fprog1, 1, UNEVALLED, 0, /*
 (prog1 FIRST BODY...): eval FIRST and BODY sequentially; value from FIRST.
 The value of FIRST is saved during the evaluation of the remaining args,
 whose values are discarded.
-*/ )
+*/
-(args)
+(args))
-Lisp_Object args;
 {
 /* This function can GC */
 Lisp_Object val;
 REGISTER Lisp_Object args_left;
 struct gcpro gcpro1, gcpro2;
 UNGCPRO;
 return val;
 }
-DEFUN ("prog2", Fprog2, Sprog2, 2, UNEVALLED, 0 /*
+DEFUN ("prog2", Fprog2, 2, UNEVALLED, 0, /*
 (prog2 X Y BODY...): eval X, Y and BODY sequentially; value from Y.
 The value of Y is saved during the evaluation of the remaining args,
 whose values are discarded.
-*/ )
+*/
-(args)
+(args))
-Lisp_Object args;
 {
 /* This function can GC */
 Lisp_Object val;
 REGISTER Lisp_Object args_left;
 struct gcpro gcpro1, gcpro2;
 UNGCPRO;
 return val;
 }
-DEFUN ("let*", FletX, SletX, 1, UNEVALLED, 0 /*
+DEFUN ("let*", FletX, 1, UNEVALLED, 0, /*
 (let* VARLIST 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.
-*/ )
+*/
-(args)
+(args))
-Lisp_Object args;
 {
 /* This function can GC */
 Lisp_Object varlist, val, elt;
 int speccount = specpdl_depth_counter;
 struct gcpro gcpro1, gcpro2, gcpro3;
 UNGCPRO;
 val = Fprogn (Fcdr (args));
 return unbind_to (speccount, val);
 }
-DEFUN ("let", Flet, Slet, 1, UNEVALLED, 0 /*
+DEFUN ("let", Flet, 1, UNEVALLED, 0, /*
 (let VARLIST 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.
-*/ )
+*/
-(args)
+(args))
-Lisp_Object args;
 {
 /* This function can GC */
 Lisp_Object *temps, tem;
 REGISTER Lisp_Object elt, varlist;
 int speccount = specpdl_depth_counter;
 elt = Fprogn (Fcdr (args));
 return unbind_to (speccount, elt);
 }
-DEFUN ("while", Fwhile, Swhile, 1, UNEVALLED, 0 /*
+DEFUN ("while", Fwhile, 1, UNEVALLED, 0, /*
 (while TEST BODY...): 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.
-*/ )
+*/
-(args)
+(args))
-Lisp_Object args;
 {
 /* This function can GC */
 Lisp_Object test, body, tem;
 struct gcpro gcpro1, gcpro2;
 return Qnil;
 }
 Lisp_Object Qsetq;
-DEFUN ("setq", Fsetq, Ssetq, 0, UNEVALLED, 0 /*
+DEFUN ("setq", Fsetq, 0, UNEVALLED, 0, /*
 (setq SYM VAL SYM VAL ...): set each SYM to the value of its VAL.
 The symbols SYM are variables; they are literal (not evaluated).
 The values VAL are expressions; they are evaluated.
 Thus, (setq x (1+ y)) sets `x' to the value of `(1+ y)'.
 The second VAL is not computed until after the first SYM is set, and so on;
 each VAL can use the new value of variables set earlier in the `setq'.
 The return value of the `setq' form is the value of the last VAL.
-*/ )
+*/
-(args)
+(args))
-Lisp_Object args;
 {
 /* This function can GC */
 REGISTER Lisp_Object args_left;
 REGISTER Lisp_Object val, sym;
 struct gcpro gcpro1;
 UNGCPRO;
 return val;
 }
-DEFUN ("quote", Fquote, Squote, 1, UNEVALLED, 0 /*
+DEFUN ("quote", Fquote, 1, UNEVALLED, 0, /*
 Return the argument, without evaluating it.  `(quote x)' yields `x'.
-*/ )
+*/
-(args)
+(args))
-Lisp_Object args;
 {
 return Fcar (args);
 }
-DEFUN ("function", Ffunction, Sfunction, 1, UNEVALLED, 0 /*
+DEFUN ("function", Ffunction, 1, UNEVALLED, 0, /*
 Like `quote', but preferred for objects which are functions.
 In byte compilation, `function' causes its argument to be compiled.
 `quote' cannot do that.
-*/ )
+*/
-(args)
+(args))
-Lisp_Object args;
 {
 return Fcar (args);
 }
 /**********************************************************************/
 /*                     Defining functions/variables                   */
 /**********************************************************************/
-DEFUN ("defun", Fdefun, Sdefun, 2, UNEVALLED, 0 /*
+DEFUN ("defun", Fdefun, 2, UNEVALLED, 0, /*
 (defun NAME ARGLIST [DOCSTRING] BODY...): define NAME as a function.
 The definition is (lambda ARGLIST [DOCSTRING] BODY...).
 See also the function `interactive'.
-*/ )
+*/
-(args)
+(args))
-Lisp_Object args;
 {
 /* This function can GC */
 Lisp_Object fn_name;
 Lisp_Object defn;
 Ffset (fn_name, defn);
 LOADHIST_ATTACH (fn_name);
 return fn_name;
 }
-DEFUN ("defmacro", Fdefmacro, Sdefmacro, 2, UNEVALLED, 0 /*
+DEFUN ("defmacro", Fdefmacro, 2, UNEVALLED, 0, /*
 (defmacro NAME ARGLIST [DOCSTRING] BODY...): define NAME as a macro.
 The definition is (macro lambda ARGLIST [DOCSTRING] BODY...).
 When the macro is called, as in (NAME ARGS...),
 the function (lambda ARGLIST BODY...) is applied to
 the list ARGS... as it appears in the expression,
 and the result should be a form to be evaluated instead of the original.
-*/ )
+*/
-(args)
+(args))
-Lisp_Object args;
 {
 /* This function can GC */
 Lisp_Object fn_name;
 Lisp_Object defn;
 Ffset (fn_name, defn);
 LOADHIST_ATTACH (fn_name);
 return fn_name;
 }
-DEFUN ("defvar", Fdefvar, Sdefvar, 1, UNEVALLED, 0 /*
+DEFUN ("defvar", Fdefvar, 1, UNEVALLED, 0, /*
 (defvar SYMBOL INITVALUE DOCSTRING): 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.
 If DOCSTRING starts with *, this variable is identified as a user option.
 This means that M-x set-variable and M-x edit-options recognize it.
 If INITVALUE is missing, SYMBOL's value is not set.
 In lisp-interaction-mode defvar is treated as defconst.
-*/ )
+*/
-(args)
+(args))
-Lisp_Object args;
 {
 /* This function can GC */
 REGISTER Lisp_Object sym, tem, tail;
 sym = Fcar (args);
 LOADHIST_ATTACH (sym);
 return sym;
 }
-DEFUN ("defconst", Fdefconst, Sdefconst, 2, UNEVALLED, 0 /*
+DEFUN ("defconst", Fdefconst, 2, UNEVALLED, 0, /*
 (defconst SYMBOL INITVALUE DOCSTRING): define SYMBOL as a constant
 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;
 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.
-*/ )
+*/
-(args)
+(args))
-Lisp_Object args;
 {
 /* This function can GC */
 REGISTER Lisp_Object sym, tem;
 sym = Fcar (args);
 LOADHIST_ATTACH (sym);
 return sym;
 }
-DEFUN ("user-variable-p", Fuser_variable_p, Suser_variable_p, 1, 1, 0 /*
+DEFUN ("user-variable-p", Fuser_variable_p, 1, 1, 0, /*
 Return t if VARIABLE is intended to be set and modified by users.
 \(The alternative is a variable used internally in a Lisp program.)
 Determined by whether the first character of the documentation
 for the variable is `*'.
-*/ )
+*/
-(variable)
+(variable))
-Lisp_Object variable;
 {
 Lisp_Object documentation;
 documentation = Fget (variable, Qvariable_documentation, Qnil);
 if (INTP (documentation) && XINT (documentation) < 0)
 && XINT (XCDR (documentation)) < 0)
 return Qt;
 return Qnil;
 }
-DEFUN ("macroexpand-internal", Fmacroexpand_internal, Smacroexpand_internal,
+DEFUN ("macroexpand-internal", Fmacroexpand_internal, 1, 2, 0, /*
-1, 2, 0 /*
 Return result of expanding macros at top level of FORM.
 If FORM is not a macro call, it is returned unchanged.
 Otherwise, the macro is expanded and the expansion is considered
 in place of FORM.  When a non-macro-call results, it is returned.
 The second optional arg ENVIRONMENT species an environment of macro
 definitions to shadow the loaded ones for use in file byte-compilation.
-*/ )
+*/
-(form, env)
+(form, env))
-Lisp_Object form;
-Lisp_Object env;
 {
 /* This function can GC */
 /* With cleanups from Hallvard Furuseth.  */
 REGISTER Lisp_Object expander, sym, def, tem;
 /**********************************************************************/
 /*                          Non-local exits                           */
 /**********************************************************************/
-DEFUN ("catch", Fcatch, Scatch, 1, UNEVALLED, 0 /*
+DEFUN ("catch", Fcatch, 1, UNEVALLED, 0, /*
 (catch TAG BODY...): eval BODY allowing nonlocal exits using `throw'.
 TAG is evalled to get the tag to use.  Then the BODY is executed.
 Within BODY, (throw TAG) with same tag exits BODY and exits this `catch'.
 If no throw happens, `catch' returns the value of the last BODY form.
 If a throw happens, it specifies the value to return from `catch'.
-*/ )
+*/
-(args)
+(args))
-Lisp_Object args;
 {
 /* This function can GC */
 Lisp_Object tag;
 struct gcpro gcpro1;
 that is EQ() to TAG.  When it finds it, it will longjmp()
 back to the place that established the catch (in this case,
 condition_case_1).  See below for more info.
 */
-DEFUN ("throw", Fthrow, Sthrow, 2, 2, 0 /*
+DEFUN ("throw", Fthrow, 2, 2, 0, /*
 (throw TAG VALUE): throw to the catch for TAG and return VALUE from it.
 Both TAG and VALUE are evalled.
-*/ )
+*/
-(tag, val)
+(tag, val))
-Lisp_Object tag, val;
 {
 throw_or_bomb_out (tag, val, 0, Qnil, Qnil); /* Doesn't return */
 return Qnil;
 }
-DEFUN ("unwind-protect", Funwind_protect, Sunwind_protect, 1, UNEVALLED, 0 /*
+DEFUN ("unwind-protect", Funwind_protect, 1, UNEVALLED, 0, /*
 Do BODYFORM, protecting with UNWINDFORMS.
 Usage looks like (unwind-protect BODYFORM UNWINDFORMS...).
 If BODYFORM completes normally, its value is returned
 after executing the UNWINDFORMS.
 If BODYFORM exits nonlocally, the UNWINDFORMS are executed anyway.
-*/ )
+*/
-(args)
+(args))
-Lisp_Object args;
 {
 /* This function can GC */
 Lisp_Object val;
 int speccount = specpdl_depth_counter;
 Feval, bodyform,
 run_condition_case_handlers,
 var);
 }
-DEFUN ("condition-case", Fcondition_case, Scondition_case, 2, UNEVALLED, 0 /*
+DEFUN ("condition-case", Fcondition_case, 2, UNEVALLED, 0, /*
 Regain control when an error is signalled.
 Usage looks like (condition-case VAR BODYFORM HANDLERS...).
 executes BODYFORM and returns its value if no error happens.
 Each element of HANDLERS looks like (CONDITION-NAME BODY...)
 where the BODY is made of Lisp expressions.
 within the handler will not result in an infinite loop.
 If you want to establish an error handler that is called with the
 Lisp stack, bindings, etc. as they were when `signal' was called,
 rather than when the handler was set, use `call-with-condition-handler'.
-*/ )
+*/
-(args)
+(args))
-Lisp_Object args;
 {
 /* This function can GC */
 return Fcondition_case_3 (Fcar (Fcdr (args)),
 Fcar (args),
 Fcdr (Fcdr (args)));
 }
-DEFUN ("call-with-condition-handler",
+DEFUN ("call-with-condition-handler", Fcall_with_condition_handler, 2, MANY, 0, /*
-Fcall_with_condition_handler,
-Scall_with_condition_handler, 2, MANY, 0 /*
 Regain control when an error is signalled, without popping the stack.
 Usage looks like (call-with-condition-handler HANDLER FUNCTION &rest ARGS).
 This function is similar to `condition-case', but the handler is invoked
 with the same environment (Lisp stack, bindings, catches, condition-cases)
 that was current when `signal' was called, rather than when the handler
 `signal' is called (this differs from `condition-case', which allows
 you to specify which errors are trapped).  If the handler function
 returns, `signal' continues as if the handler were never invoked.
 (It continues to look for handlers established earlier than this one,
 and invokes the standard error-handler if none is found.)
-*/ )
+*/
-(nargs, args)                 /* Note!  Args side-effected! */
+(int nargs, Lisp_Object *args))  /* Note!  Args side-effected! */
-int nargs;
-Lisp_Object *args;
 {
 /* This function can GC */
 int speccount = specpdl_depth_counter;
 Lisp_Object tem;
 /* The simplest external error function: it would be called
 signal_continuable_error() in the terminology below, but it's
 Lisp-callable. */
-DEFUN ("signal", Fsignal, Ssignal, 2, 2, 0 /*
+DEFUN ("signal", Fsignal, 2, 2, 0, /*
 Signal a continuable error.  Args are ERROR-SYMBOL, and associated DATA.
 An error symbol is a symbol defined using `define-error'.
 DATA should be a list.  Its elements are printed as part of the error message.
 If the signal is handled, DATA is made available to the handler.
 See also the function `signal-error', and the functions to handle errors:
 `condition-case' and `call-with-condition-handler'.
 Note that this function can return, if the debugger is invoked and the
 user invokes the "return from signal" option.
-*/ )
+*/
-(error_symbol, data)
+(error_symbol, data))
-Lisp_Object error_symbol, data;
 {
 /* Fsignal() is one of these functions that's called all the time
 with newly-created Lisp objects.  We allow this; but we must GC-
 protect the objects because all sorts of weird stuff could
 happen. */
 /**********************************************************************/
 /*                            User commands                           */
 /**********************************************************************/
-DEFUN ("commandp", Fcommandp, Scommandp, 1, 1, 0 /*
+DEFUN ("commandp", Fcommandp, 1, 1, 0, /*
 T if FUNCTION makes provisions for interactive calling.
 This means it contains a description for how to read arguments to give it.
 The value is nil for an invalid function or a symbol with no function
 definition.
 -- compiled-function objects with a non-nil `compiled-function-interactive'
 value
 -- subrs (built-in functions) that are interactively callable
 Also, a symbol satisfies `commandp' if its function definition does so.
-*/ )
+*/
-(function)
+(function))
-Lisp_Object function;
 {
 REGISTER Lisp_Object fun;
 REGISTER Lisp_Object funcar;
 fun = function;
 return Fcar (Fcdr (Fcdr (Fcdr (fun))));
 else
 return Qnil;
 }
-DEFUN ("command-execute", Fcommand_execute, Scommand_execute, 1, 3, 0 /*
+DEFUN ("command-execute", Fcommand_execute, 1, 3, 0, /*
 Execute CMD as an editor command.
 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, keys))
-Lisp_Object cmd, record, keys;
 {
 /* This function can GC */
 Lisp_Object prefixarg;
 Lisp_Object final = cmd;
 struct backtrace backtrace;
 : list2 (cmd, final))));
 return Qnil;
 }
 }
-DEFUN ("interactive-p", Finteractive_p, Sinteractive_p, 0, 0, 0 /*
+DEFUN ("interactive-p", Finteractive_p, 0, 0, 0, /*
 Return t if function in which this appears was called interactively.
 This means that the function was called with call-interactively (which
 includes being called as the binding of a key)
 and input is currently coming from the keyboard (not in keyboard macro).
-*/ )
+*/
-()
+())
 {
 REGISTER struct backtrace *btp;
 REGISTER Lisp_Object fun;
 if (!INTERACTIVE)
 /**********************************************************************/
 /*                            Autoloading                             */
 /**********************************************************************/
-DEFUN ("autoload", Fautoload, Sautoload, 2, 5, 0 /*
+DEFUN ("autoload", Fautoload, 2, 5, 0, /*
 Define FUNCTION to autoload from FILE.
 FUNCTION is a symbol; FILE is a file name string to pass to `load'.
 Third arg DOCSTRING is documentation for the function.
 Fourth arg INTERACTIVE if non-nil says function can be called interactively.
 Fifth arg TYPE indicates the type of the object:
 `macro' or t says FUNCTION is really a macro.
 Third through fifth args give info about the real definition.
 They default to nil.
 If FUNCTION is already defined other than as an autoload,
 this does nothing and returns nil.
-*/ )
+*/
-(function, file, docstring, interactive, type)
+(function, file, docstring, interactive, type))
-Lisp_Object function, file, docstring, interactive, type;
 {
 /* This function can GC */
 CHECK_SYMBOL (function);
 CHECK_STRING (file);
 in_warnings = 0;
 return Qnil;
 }
-DEFUN ("eval", Feval, Seval, 1, 1, 0 /*
+DEFUN ("eval", Feval, 1, 1, 0, /*
 Evaluate FORM and return its value.
-*/ )
+*/
-(form)
+(form))
-Lisp_Object form;
 {
 /* This function can GC */
 Lisp_Object fun, val, original_fun, original_args;
 int nargs;
 struct backtrace backtrace;
 val = do_debug_on_exit (val);
 backtrace_list = backtrace.next;
 return val;
 }
-DEFUN ("funcall", Ffuncall, Sfuncall, 1, MANY, 0 /*
+DEFUN ("funcall", Ffuncall, 1, MANY, 0, /*
 Call first argument as a function, passing remaining arguments to it.
 Thus, (funcall 'cons 'x 'y) returns (x . y).
-*/ )
+*/
-(nargs, args)
+(int nargs, Lisp_Object *args))
-int nargs;
-Lisp_Object *args;
 {
 return funcall_recording_as (args[0], nargs, args);
 }
-DEFUN ("function-min-args", Ffunction_min_args, Sfunction_min_args,
+DEFUN ("function-min-args", Ffunction_min_args, 1, 1, 0, /*
-1, 1, 0 /*
 Return the 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.
-*/ )
+*/
-(function)
+(function))
-Lisp_Object function;
 {
 Lisp_Object orig_function = function;
 Lisp_Object arglist;
 int argcount;
 }
 return make_int (argcount);
 }
-DEFUN ("function-max-args", Ffunction_max_args, Sfunction_max_args,
+DEFUN ("function-max-args", Ffunction_max_args, 1, 1, 0, /*
-1, 1, 0 /*
 Return the number of arguments a function may be called with.  If the
 function takes an arbitrary number of arguments or is a built-in
 special form, nil is returned.  The function may be any form that can
 be passed to `funcall', any special form, or any macro.
-*/ )
+*/
-(function)
+(function))
-Lisp_Object function;
 {
 Lisp_Object orig_function = function;
 Lisp_Object arglist;
 int argcount;
 return make_int (argcount);
 }
-DEFUN ("apply", Fapply, Sapply, 2, MANY, 0 /*
+DEFUN ("apply", Fapply, 2, MANY, 0, /*
 Call FUNCTION with our remaining args, using our last arg as list of args.
 Thus, (apply '+ 1 2 '(3 4)) returns 10.
-*/ )
+*/
-(nargs, args)
+(int nargs, Lisp_Object *args))
-int nargs;
-Lisp_Object *args;
 {
 /* This function can GC */
 Lisp_Object fun = args[0];
 Lisp_Object spread_arg = args [nargs - 1];
 int numargs;
 make_int (b->maxdepth));
 }
 return unbind_to (speccount, val);
 }
-DEFUN ("fetch-bytecode", Ffetch_bytecode, Sfetch_bytecode,
+DEFUN ("fetch-bytecode", Ffetch_bytecode, 1, 1, 0, /*
-1, 1, 0 /*
 If byte-compiled OBJECT is lazy-loaded, fetch it now.
-*/ )
+*/
-(object)
+(object))
-Lisp_Object object;
 {
 Lisp_Object tem;
 if (COMPILED_FUNCTIONP (object)
 && CONSP (XCOMPILED_FUNCTION (object)->bytecodes))
 /**********************************************************************/
 /*                   Run hook variables in various ways.              */
 /**********************************************************************/
-DEFUN ("run-hooks", Frun_hooks, Srun_hooks, 1, MANY, 0 /*
+DEFUN ("run-hooks", Frun_hooks, 1, MANY, 0, /*
 Run each hook in HOOKS.  Major mode functions use this.
 Each argument should be a symbol, a hook variable.
 These symbols are processed in the order specified.
 If a hook symbol has a non-nil 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 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'.
-*/ )
+*/
-(nargs, args)
+(int nargs, Lisp_Object *args))
-int nargs;
-Lisp_Object *args;
 {
 Lisp_Object hook[1];
 REGISTER int i;
 for (i = 0; i < nargs; i++)
 }
 return Qnil;
 }
-DEFUN ("run-hook-with-args",
+DEFUN ("run-hook-with-args", Frun_hook_with_args, 1, MANY, 0, /*
-Frun_hook_with_args, Srun_hook_with_args, 1, MANY, 0 /*
 Run HOOK with the specified arguments ARGS.
 HOOK should be a symbol, a hook variable.  If HOOK has a non-nil
 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
 It is best not to depend on the value return by `run-hook-with-args',
 as that may change.
 To make a hook variable buffer-local, use `make-local-hook',
 not `make-local-variable'.
-*/ )
+*/
-(nargs, args)
+(int nargs, Lisp_Object *args))
-int nargs;
-Lisp_Object *args;
 {
 return run_hook_with_args (nargs, args, RUN_HOOKS_TO_COMPLETION);
 }
-DEFUN ("run-hook-with-args-until-success",
+DEFUN ("run-hook-with-args-until-success", Frun_hook_with_args_until_success, 1, MANY, 0, /*
-Frun_hook_with_args_until_success, Srun_hook_with_args_until_success,
-1, MANY, 0 /*
 Run HOOK with the specified arguments ARGS.
 HOOK should be a symbol, a hook variable.  Its value should
 be a list of functions.  We call those functions, one by one,
 passing arguments ARGS to each of them, until one of them
 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'.
-*/ )
+*/
-(nargs, args)
+(int nargs, Lisp_Object *args))
-int nargs;
-Lisp_Object *args;
 {
 return run_hook_with_args (nargs, args, RUN_HOOKS_UNTIL_SUCCESS);
 }
-DEFUN ("run-hook-with-args-until-failure",
+DEFUN ("run-hook-with-args-until-failure", Frun_hook_with_args_until_failure, 1, MANY, 0, /*
-Frun_hook_with_args_until_failure, Srun_hook_with_args_until_failure,
-1, MANY, 0 /*
 Run HOOK with the specified arguments ARGS.
 HOOK should be a symbol, a hook variable.  Its value should
 be a list of functions.  We call those functions, one by one,
 passing arguments ARGS to each of them, until one of them
 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'.
-*/ )
+*/
-(nargs, args)
+(int nargs, Lisp_Object *args))
-int nargs;
-Lisp_Object *args;
 {
 return run_hook_with_args (nargs, args, RUN_HOOKS_UNTIL_FAILURE);
 }
 /* ARGS[0] should be a hook symbol.
 /**********************************************************************/
 /*                            Backtraces                              */
 /**********************************************************************/
-DEFUN ("backtrace-debug", Fbacktrace_debug, Sbacktrace_debug, 2, 2, 0 /*
+DEFUN ("backtrace-debug", Fbacktrace_debug, 2, 2, 0, /*
 Set the debug-on-exit flag of eval frame LEVEL levels down to FLAG.
 The debugger is entered when that frame exits, if the flag is non-nil.
-*/ )
+*/
-(level, flag)
+(level, flag))
-Lisp_Object level, flag;
 {
 REGISTER struct backtrace *backlist = backtrace_list;
 REGISTER int i;
 CHECK_INT (level);
 	}
 }
 if (printing_bindings) write_c_string (")\n", stream);
 }
-DEFUN ("backtrace", Fbacktrace, Sbacktrace, 0, 2, "" /*
+DEFUN ("backtrace", Fbacktrace, 0, 2, "", /*
 Print a trace of Lisp function calls currently active.
 Option arg STREAM specifies the output stream to send the backtrace to,
 and defaults to the value of `standard-output'.  Optional second arg
 DETAILED means show places where currently active variable bindings,
 catches, condition-cases, and unwind-protects were made as well as
 function calls.
-*/ )
+*/
-(stream, detailed)
+(stream, detailed))
-Lisp_Object stream, detailed;
 {
 struct backtrace *backlist = backtrace_list;
 struct catchtag *catches = catchlist;
 int speccount = specpdl_depth_counter;
 Vinhibit_quit = oiq;
 return Qnil;
 }
-DEFUN ("backtrace-frame", Fbacktrace_frame, Sbacktrace_frame, 1, 1, "" /*
+DEFUN ("backtrace-frame", Fbacktrace_frame, 1, 1, "", /*
 Return the function and arguments N frames 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.
-*/ )
+*/
-(nframes)
+(nframes))
-Lisp_Object nframes;
 {
 REGISTER struct backtrace *backlist = backtrace_list;
 REGISTER int i;
 Lisp_Object tem;
 defsymbol (&Qprogn, "progn");
 defsymbol (&Qvalues, "values");
 defsymbol (&Qdisplay_warning, "display-warning");
 defsymbol (&Qrun_hooks, "run-hooks");
-defsubr (&Sor);
+DEFSUBR (For);
-defsubr (&Sand);
+DEFSUBR (Fand);
-defsubr (&Sif);
+DEFSUBR (Fif);
-defsubr (&Scond);
+DEFSUBR (Fcond);
-defsubr (&Sprogn);
+DEFSUBR (Fprogn);
-defsubr (&Sprog1);
+DEFSUBR (Fprog1);
-defsubr (&Sprog2);
+DEFSUBR (Fprog2);
-defsubr (&Ssetq);
+DEFSUBR (Fsetq);
-defsubr (&Squote);
+DEFSUBR (Fquote);
-defsubr (&Sfunction);
+DEFSUBR (Ffunction);
-defsubr (&Sdefun);
+DEFSUBR (Fdefun);
-defsubr (&Sdefmacro);
+DEFSUBR (Fdefmacro);
-defsubr (&Sdefvar);
+DEFSUBR (Fdefvar);
-defsubr (&Sdefconst);
+DEFSUBR (Fdefconst);
-defsubr (&Suser_variable_p);
+DEFSUBR (Fuser_variable_p);
-defsubr (&Slet);
+DEFSUBR (Flet);
-defsubr (&SletX);
+DEFSUBR (FletX);
-defsubr (&Swhile);
+DEFSUBR (Fwhile);
-defsubr (&Smacroexpand_internal);
+DEFSUBR (Fmacroexpand_internal);
-defsubr (&Scatch);
+DEFSUBR (Fcatch);
-defsubr (&Sthrow);
+DEFSUBR (Fthrow);
-defsubr (&Sunwind_protect);
+DEFSUBR (Funwind_protect);
-defsubr (&Scondition_case);
+DEFSUBR (Fcondition_case);
-defsubr (&Scall_with_condition_handler);
+DEFSUBR (Fcall_with_condition_handler);
-defsubr (&Ssignal);
+DEFSUBR (Fsignal);
-defsubr (&Sinteractive_p);
+DEFSUBR (Finteractive_p);
-defsubr (&Scommandp);
+DEFSUBR (Fcommandp);
-defsubr (&Scommand_execute);
+DEFSUBR (Fcommand_execute);
-defsubr (&Sautoload);
+DEFSUBR (Fautoload);
-defsubr (&Seval);
+DEFSUBR (Feval);
-defsubr (&Sapply);
+DEFSUBR (Fapply);
-defsubr (&Sfuncall);
+DEFSUBR (Ffuncall);
-defsubr (&Sfunction_min_args);
+DEFSUBR (Ffunction_min_args);
-defsubr (&Sfunction_max_args);
+DEFSUBR (Ffunction_max_args);
-defsubr (&Srun_hooks);
+DEFSUBR (Frun_hooks);
-defsubr (&Srun_hook_with_args);
+DEFSUBR (Frun_hook_with_args);
-defsubr (&Srun_hook_with_args_until_success);
+DEFSUBR (Frun_hook_with_args_until_success);
-defsubr (&Srun_hook_with_args_until_failure);
+DEFSUBR (Frun_hook_with_args_until_failure);
-defsubr (&Sfetch_bytecode);
+DEFSUBR (Ffetch_bytecode);
-defsubr (&Sbacktrace_debug);
+DEFSUBR (Fbacktrace_debug);
-defsubr (&Sbacktrace);
+DEFSUBR (Fbacktrace);
-defsubr (&Sbacktrace_frame);
+DEFSUBR (Fbacktrace_frame);
 }
 void
 reinit_eval (void)
 {

Mercurial > hg > xemacs-beta

comparison src/eval.c @ 20:859a2309aef8 r19-15b93