xemacs-beta: src/eval.c comparison

comparison src/eval.c @ 173:8eaf7971accc r20-3b13

Import from CVS: tag r20-3b13

author	cvs
date	Mon, 13 Aug 2007 09:49:09 +0200
parents	85ec50267440
children	9ad43877534d

comparison

equal deleted inserted replaced

-:a38aed19690b
+:8eaf7971accc
 ((markobj) (b->doc_and_interactive));
 #ifdef COMPILED_FUNCTION_ANNOTATION_HACK
 ((markobj) (b->annotated));
 #endif
 /* tail-recurse on constants */
-return (b->constants);
+return b->constants;
 }
 static int
 compiled_function_equal (Lisp_Object o1, Lisp_Object o2, int depth)
 {
 do_debug_on_exit (Lisp_Object val)
 {
 /* This is falsified by call_debugger */
 Lisp_Object v = call_debugger (list2 (Qexit, val));
-return ((!UNBOUNDP (v)) ? v : val);
+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
 through `eval' or 'lambda for a call through `funcall'.
 skip_debugger (Lisp_Object conditions, Lisp_Object data)
 {
 /* This function can GC */
 Lisp_Object tail;
 int first_string = 1;
-Lisp_Object error_message;
+Lisp_Object error_message = Qnil;
 for (tail = Vdebug_ignored_errors; CONSP (tail); tail = XCDR (tail))
 {
 if (STRINGP (XCAR (tail)))
 	{
 /* Actually generate a backtrace on STREAM. */
 static Lisp_Object
 backtrace_259 (Lisp_Object stream)
 {
-return (Fbacktrace (stream, Qt));
+return Fbacktrace (stream, Qt);
 }
 /* An error was signalled.  Maybe call the debugger, if the `debug-on-error'
 etc. variables call for this.  CONDITIONS is the list of conditions
 associated with the error being signalled.  SIG is the actual error
 *debugger_entered = 1;
 }
 UNGCPRO;
 Vcondition_handlers = all_handlers;
-return (unbind_to (speccount, val));
+return unbind_to (speccount, val);
 }
 /**********************************************************************/
 /*                     The basic special forms                        */
 /* Call FUNC.  */
 if (SETJMP (c.jmp))
 {
 /* Throw works by a longjmp that comes right here.  */
 if (threw) *threw = 1;
-return (c.val);
+return c.val;
 }
 c.val = (*func) (arg);
 if (threw) *threw = 0;
 catchlist = c.next;
-return (c.val);
+return c.val;
 }
 /* Unwind the specbind, catch, and handler stacks back to CATCH, and
 jump to that CATCH, returning VALUE as the value of that catch.
 if (EQ (loser, Vcondition_handlers)) /* may have been rebound to some tail */
 Vcondition_handlers = victim->cdr;
 free_cons (victim);
-return (Qnil);
+return Qnil;
 }
 static Lisp_Object
 condition_case_unwind (Lisp_Object loser)
 {
 victim = XCONS (loser);
 if (EQ (loser, Vcondition_handlers)) /* may have been rebound to some tail */
 Vcondition_handlers = victim->cdr;
 free_cons (victim);
-return (Qnil);
+return Qnil;
 }
 /* Split out from condition_case_3 so that primitive C callers
 don't have to cons up a lisp handler form to be evaluated. */
 c.next = catchlist;
 if (SETJMP (c.jmp))
 {
 /* throw does ungcpro, etc */
-return ((*hfun) (c.val, harg));
+return (*hfun) (c.val, harg);
 }
 record_unwind_protect (condition_case_unwind, c.tag);
 catchlist = &c;
 have this code here, and it doesn't cost anything, so I'm leaving it.*/
 UNGCPRO;
 catchlist = c.next;
 Vcondition_handlers = XCDR (c.tag);
-return (unbind_to (speccount, c.val));
+return unbind_to (speccount, c.val);
 }
 static Lisp_Object
 run_condition_case_handlers (Lisp_Object val, Lisp_Object var)
 {
 return val;
 #else
 int speccount;
 if (NILP (var))
-return (Fprogn (Fcdr (val))); /* tailcall */
+return Fprogn (Fcdr (val)); /* tailcall */
 speccount = specpdl_depth_counter;
 specbind (var, Fcar (val));
 val = Fprogn (Fcdr (val));
 return unbind_to (speccount, val);
 record_unwind_protect (condition_bind_unwind, tem);
 Vcondition_handlers = tem;
 /* Caller should have GC-protected args */
 tem = Ffuncall (nargs - 1, args + 1);
-return (unbind_to (speccount, tem));
+return unbind_to (speccount, tem);
 }
 static int
 condition_type_p (Lisp_Object type, Lisp_Object conditions)
 {
 if (EQ (type, Qt))
 /* (condition-case c # (t c)) catches -all- signals
 *   Use with caution! */
-return (1);
+return 1;
 else
 {
 if (SYMBOLP (type))
 	{
-	  return (!NILP (Fmemq (type, conditions)));
+	  return !NILP (Fmemq (type, conditions));
 	}
 else if (CONSP (type))
 	{
 	  while (CONSP (type))
 	    {
 #if 1 /* RMS Claims: */
 /* Most callers are not prepared to handle gc if this
 returns.  So, since this feature is not very useful,
 take it out.  */
 /* Have called debugger; return value to signaller  */
-return (value);
+return value;
 #else  /* But the reality is that that stinks, because: */
 /* GACK!!! Really want some way for debug-on-quit errors
 to be continuable!! */
 error ("Returning a value from an error is no longer supported");
 #endif
 NNUNGCPRO;
 }
 NUNGCPRO;
 #if 0
 if (!EQ (tem, Qsignal))
-return (return_from_signal (tem));
+return return_from_signal (tem);
 #endif
 /* If handler didn't throw, try another handler */
 Vcondition_handlers = all_handlers;
 }
 /* t is used by handlers for all conditions, set up by C code.
 *  debugger is not called even if debug_on_error */
 else if (EQ (handler_data, Qt))
 	{
 UNGCPRO;
-return (Fthrow (handlers, Fcons (sig, data)));
+return Fthrow (handlers, Fcons (sig, data));
 	}
 /* `error' is used similarly to the way `t' is used, but in
 addition it invokes the debugger if debug_on_error.
 	 This is normally used for the outer command-loop error
 	 handler. */
 						  &stack_trace_displayed,
 						  &debugger_entered);
 UNGCPRO;
 if (!UNBOUNDP (tem))
-return (return_from_signal (tem));
+return return_from_signal (tem);
 tem = Fcons (sig, data);
-return (Fthrow (handlers, tem));
+return Fthrow (handlers, tem);
 }
 else
 	{
 /* handler established by real (Lisp) condition-case */
 Lisp_Object h;
 outer_handlers, 1,
 					      &stack_trace_displayed,
 					      &debugger_entered);
 UNGCPRO;
 		  if (!UNBOUNDP (tem))
-return (return_from_signal (tem));
+return return_from_signal (tem);
 /* Doesn't return */
 tem = Fcons (Fcons (sig, data), Fcdr (clause));
-return (Fthrow (handlers, tem));
+return Fthrow (handlers, tem);
 }
 	    }
 	}
 }
 static Lisp_Object
 call_with_suspended_errors_1 (Lisp_Object opaque_arg)
 {
 Lisp_Object *kludgy_args = (Lisp_Object *) get_opaque_ptr (opaque_arg);
-return (primitive_funcall ((lisp_fn_t) get_opaque_ptr (kludgy_args[0]),
+return primitive_funcall ((lisp_fn_t) get_opaque_ptr (kludgy_args[0]),
-			     XINT (kludgy_args[1]), kludgy_args + 2));
+			    XINT (kludgy_args[1]), kludgy_args + 2);
 }
 static Lisp_Object
 restore_current_warning_class (Lisp_Object warning_class)
 {
 /* note that this is continuable. */
 Fsignal (Qquit, Qnil);
 }
-DEFUN ("strerror", Fstrerror, 1, 1, 0, /*
-Return the error string associated with integer ERRNUM.
-This function is an interface to strerror(3).
-The returned string may or may not be translated.
-*/
-(errnum))
-{
-CHECK_INT (errnum);
-return build_ext_string (strerror (XINT (errnum)), FORMAT_NATIVE);
-}
 /**********************************************************************/
 /*                            User commands                           */
 /**********************************************************************/
 DEFUN ("commandp", Fcommandp, 1, 1, 0, /*
 PUSH_BACKTRACE (backtrace);
 final = Fcall_interactively (cmd, record, keys);
 POP_BACKTRACE (backtrace);
-return (final);
+return final;
 }
 else if (STRINGP (final) || VECTORP (final))
 {
 return Fexecute_kbd_macro (final, prefixarg);
 }
 lisp_eval_depth--;
 if (backtrace.debug_on_exit)
 val = do_debug_on_exit (val);
 	  POP_BACKTRACE (backtrace);
 	  UNGCPRO;
-return (val);
+return val;
 	}
 else
 {
 struct gcpro gcpro1, gcpro2, gcpro3;
 lisp_eval_depth--;
 if (backtrace.debug_on_exit)
 val = do_debug_on_exit (val);
 POP_BACKTRACE (backtrace);
-return (val);
+return val;
 }
 Lisp_Object
 funcall_recording_as (Lisp_Object recorded_as, int nargs,
 /* Do the debug-on-exit now, while arg_vector still exists.  */
 if (backtrace_list->debug_on_exit)
 tem = do_debug_on_exit (tem);
 /* Don't do it again when we return to eval.  */
 backtrace_list->debug_on_exit = 0;
-return (tem);
+return tem;
 }
 /* Apply a Lisp function FUN to the NARGS evaluated arguments in ARG_VECTOR
 and return the result of evaluation.
 FUN must be either a lambda-expression or a compiled-code object.  */
 /* This function can GC */
 struct gcpro gcpro1;
 Lisp_Object args[2];
 if (NILP (arg))
-return (Ffuncall (1, &fn));
+return Ffuncall (1, &fn);
 GCPRO1 (args[0]);
 gcpro1.nvars = 2;
 args[0] = fn;
 args[1] = arg;
 RETURN_UNGCPRO (Fapply (2, args));
 if (SYMBOLP (function))
 {
 tem = XSYMBOL (function)->function;
 if (NILP (tem) || UNBOUNDP (tem))
-	return (Qnil);
+	return Qnil;
 }
 GCPRO2 (opaque, function);
 specbind (Qinhibit_quit, Qt);
 /* gc_currently_forbidden = 1; Currently no reason to do this; */
 if (SYMBOLP (function))
 {
 tem = XSYMBOL (function)->function;
 if (NILP (tem) || UNBOUNDP (tem))
-	return (Qnil);
+	return Qnil;
 }
 GCPRO4 (cons, opaque, function, object);
 specbind (Qinhibit_quit, Qt);
 if (SYMBOLP (function))
 {
 tem = XSYMBOL (function)->function;
 if (NILP (tem) || UNBOUNDP (tem))
-	return (Qnil);
+	return Qnil;
 }
 GCPRO5 (cons, opaque, function, object1, object2);
 specbind (Qinhibit_quit, Qt);
 /* gc_currently_forbidden = 1; Currently no reason to do this; */
 Fset_buffer (buf);
 Fset (symbol, ovalue);
 Fset_buffer (current);
 UNGCPRO;
 }
-return (symbol);
+return symbol;
 }
 static Lisp_Object
 specbind_unwind_wasnt_local (Lisp_Object buffer)
 {
 Fset_buffer (buffer);
 Fkill_local_variable (symbol);
 Fset_buffer (current);
 UNGCPRO;
 }
-return (symbol);
+return symbol;
 }
 /* Don't want to include buffer.h just for this */
 extern struct buffer *current_buffer;
 if (quitf)
 Vquit_flag = Qt;
 UNGCPRO;
-return (value);
+return value;
 }
 int
 specpdl_depth (void)
 {
-return (specpdl_depth_counter);
+return specpdl_depth_counter;
 }
 /* Get the value of symbol's global binding, even if that binding is
 not now dynamically visible.  May return Qunbound or magic values. */
 DEFSUBR (Funwind_protect);
 DEFSUBR (Fcondition_case);
 DEFSUBR (Fcall_with_condition_handler);
 DEFSUBR (Fsignal);
 DEFSUBR (Finteractive_p);
-DEFSUBR (Fstrerror);
 DEFSUBR (Fcommandp);
 DEFSUBR (Fcommand_execute);
 DEFSUBR (Fautoload);
 DEFSUBR (Feval);
 DEFSUBR (Fapply);

Mercurial > hg > xemacs-beta

comparison src/eval.c @ 173:8eaf7971accc r20-3b13