static void unwind_to_catch (struct catchtag *, Lisp_Object) NO_RETURN;
static int interactive_p (int);
static Lisp_Object apply_lambda (Lisp_Object fun, Lisp_Object args);
+INFUN (Ffetch_bytecode, 1);
\f
void
init_eval_once (void)
return val;
}
-DEFUN ("progn", Fprogn, Sprogn, 0, UNEVALLED, 0,
+DEFUE ("progn", Fprogn, Sprogn, 0, UNEVALLED, 0,
doc: /* Eval BODY forms sequentially and return value of last one.
usage: (progn BODY...) */)
(Lisp_Object args)
}
-DEFUN ("interactive-p", Finteractive_p, Sinteractive_p, 0, 0, 0,
+DEFUE ("interactive-p", Finteractive_p, Sinteractive_p, 0, 0, 0,
doc: /* Return t if the containing function was run directly by user input.
This means that the function was called with `call-interactively'
\(which includes being called as the binding of a key)
_longjmp (catch->jmp, 1);
}
-DEFUN ("throw", Fthrow, Sthrow, 2, 2, 0,
+DEFUE ("throw", Fthrow, Sthrow, 2, 2, 0,
doc: /* Throw to the catch for TAG and return VALUE from it.
Both TAG and VALUE are evalled. */)
(register Lisp_Object tag, Lisp_Object value)
static int maybe_call_debugger (Lisp_Object conditions, Lisp_Object sig,
Lisp_Object data);
-DEFUN ("signal", Fsignal, Ssignal, 2, 2, 0,
+DEFUE ("signal", Fsignal, Ssignal, 2, 2, 0,
doc: /* Signal an error. Args are ERROR-SYMBOL and associated DATA.
This function does not return.
va_end (ap);
}
\f
-DEFUN ("commandp", Fcommandp, Scommandp, 1, 2, 0,
+DEFUE ("commandp", Fcommandp, Scommandp, 1, 2, 0,
doc: /* Non-nil 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
}
\f
-DEFUN ("eval", Feval, Seval, 1, 2, 0,
+DEFUE ("eval", Feval, Seval, 1, 2, 0,
doc: /* Evaluate FORM and return its value.
If LEXICAL is t, evaluate using lexical scoping. */)
(Lisp_Object form, Lisp_Object lexical)
return val;
}
\f
-DEFUN ("apply", Fapply, Sapply, 2, MANY, 0,
+DEFUE ("apply", Fapply, Sapply, 2, MANY, 0,
doc: /* Call FUNCTION with our remaining args, using our last arg as list of args.
Then return the value FUNCTION returns.
Thus, (apply '+ 1 2 '(3 4)) returns 10.
return Qnil;
}
-DEFUN ("run-hooks", Frun_hooks, Srun_hooks, 0, MANY, 0,
+DEFUE ("run-hooks", Frun_hooks, Srun_hooks, 0, MANY, 0,
doc: /* Run each hook in HOOKS.
Each argument should be a symbol, a hook variable.
These symbols are processed in the order specified.
return Qnil;
}
-DEFUN ("run-hook-with-args", Frun_hook_with_args,
+DEFUE ("run-hook-with-args", Frun_hook_with_args,
Srun_hook_with_args, 1, MANY, 0,
doc: /* Run HOOK with the specified arguments ARGS.
HOOK should be a symbol, a hook variable. If HOOK has a non-nil
return NILP (Ffuncall (nargs, args)) ? Qt : Qnil;
}
-DEFUN ("run-hook-with-args-until-failure", Frun_hook_with_args_until_failure,
+DEFUE ("run-hook-with-args-until-failure", Frun_hook_with_args_until_failure,
Srun_hook_with_args_until_failure, 1, MANY, 0,
doc: /* Run HOOK with the specified arguments ARGS.
HOOK should be a symbol, a hook variable. If HOOK has a non-nil
/* The caller should GCPRO all the elements of ARGS. */
-DEFUN ("functionp", Ffunctionp, Sfunctionp, 1, 1, 0,
+DEFUE ("functionp", Ffunctionp, Sfunctionp, 1, 1, 0,
doc: /* Non-nil if OBJECT is a function. */)
(Lisp_Object object)
{
return Qnil;
}
-DEFUN ("funcall", Ffuncall, Sfuncall, 1, MANY, 0,
+DEFUE ("funcall", Ffuncall, Sfuncall, 1, MANY, 0,
doc: /* Call first argument as a function, passing remaining arguments to it.
Return the value that function returns.
Thus, (funcall 'cons 'x 'y) returns (x . y).
}
}
-EXFUN (Funintern, 2);
-
void
syms_of_eval (void)
{