vim: src/ex_eval.c comparison

comparison src/ex_eval.c @ 7819:f86adafb28d4 v7.4.1206

commit https://github.com/vim/vim/commit/78c0b7d43e5048fd71d12816659667834170c76d Author: Bram Moolenaar <Bram@vim.org> Date: Sat Jan 30 15:52:46 2016 +0100 patch 7.4.1206 Problem: Using old style function declarations. Solution: Change to new style function declarations. (script by Hirohito Higashi)

author	Christian Brabandt <cb@256bit.org>
date	Sat, 30 Jan 2016 16:00:06 +0100
parents	a1e71a01dbd6
children	00344cd730f6

comparison

equal deleted inserted replaced

-:19dfb097d82d
+:f86adafb28d4
 * until the throw point for error messages has been reached.  That is, during
 * cancellation of an expression evaluation after an aborting function call or
 * due to a parsing error, aborting() always returns the same value.
 */
 int
-aborting()
+aborting(void)
 {
 return (did_emsg && force_abort) || got_int || did_throw;
 }
 /*
 * during an expression evaluation, and "cause_abort" is used instead.  It might
 * be necessary to restore "force_abort" even before the throw point for the
 * error message has been reached.  update_force_abort() should be called then.
 */
 void
-update_force_abort()
+update_force_abort(void)
 {
 if (cause_abort)
 	force_abort = TRUE;
 }
 * abort the script processing.  Can be used to suppress an autocommand after
 * execution of a failing subcommand as long as the error message has not been
 * displayed and actually caused the abortion.
 */
 int
-should_abort(retcode)
+should_abort(int retcode)
-int		retcode;
 {
 return ((retcode == FAIL && trylevel != 0 && !emsg_silent) || aborting());
 }
 /*
 * ended on an error.  This means that parsing commands is continued in order
 * to find finally clauses to be executed, and that some errors in skipped
 * commands are still reported.
 */
 int
-aborted_in_try()
+aborted_in_try(void)
 {
 /* This function is only called after an error.  In this case, "force_abort"
 * determines whether searching for finally clauses is necessary. */
 return force_abort;
 }
 * When several messages appear in the same command, the first is usually the
 * most specific one and used as the exception value.  The "severe" flag can be
 * set to TRUE, if a later but severer message should be used instead.
 */
 int
-cause_errthrow(mesg, severe, ignore)
+cause_errthrow(
-char_u	*mesg;
+char_u	*mesg,
-int		severe;
+int		severe,
-int		*ignore;
+int		*ignore)
 {
 struct msglist *elem;
 struct msglist **plist;
 /*
 /*
 * Free a "msg_list" and the messages it contains.
 */
 static void
-free_msglist(l)
+free_msglist(struct msglist *l)
-struct msglist  *l;
 {
 struct msglist  *messages, *next;
 messages = l;
 while (messages != NULL)
 /*
 * Free global "*msg_list" and the messages it contains, then set "*msg_list"
 * to NULL.
 */
 void
-free_global_msglist()
+free_global_msglist(void)
 {
 free_msglist(*msg_list);
 *msg_list = NULL;
 }
 * Throw the message specified in the call to cause_errthrow() above as an
 * error exception.  If cstack is NULL, postpone the throw until do_cmdline()
 * has returned (see do_one_cmd()).
 */
 void
-do_errthrow(cstack, cmdname)
+do_errthrow(struct condstack *cstack, char_u *cmdname)
-struct condstack	*cstack;
-char_u		*cmdname;
 {
 /*
 * Ensure that all commands in nested function calls and sourced files
 * are aborted immediately.
 */
 * do_intthrow(): Replace the current exception by an interrupt or interrupt
 * exception if appropriate.  Return TRUE if the current exception is discarded,
 * FALSE otherwise.
 */
 int
-do_intthrow(cstack)
+do_intthrow(struct condstack *cstack)
-struct condstack	*cstack;
 {
 /*
 * If no interrupt occurred or no try conditional is active and no exception
 * is being thrown, do nothing (for compatibility of non-EH scripts).
 */
 /*
 * Get an exception message that is to be stored in current_exception->value.
 */
 char_u *
-get_exception_string(value, type, cmdname, should_free)
+get_exception_string(
-void	*value;
+void	*value,
-int		type;
+int		type,
-char_u	*cmdname;
+char_u	*cmdname,
-int		*should_free;
+int		*should_free)
 {
 char_u	*ret, *mesg;
 int		cmdlen;
 char_u	*p, *val;
 * throw an illegal user exception.  "value" is the exception string for a
 * user or interrupt exception, or points to a message list in case of an
 * error exception.
 */
 static int
-throw_exception(value, type, cmdname)
+throw_exception(void *value, int type, char_u *cmdname)
-void	*value;
-int		type;
-char_u	*cmdname;
 {
 except_T	*excp;
 int		should_free;
 /*
 /*
 * Discard an exception.  "was_finished" is set when the exception has been
 * caught and the catch clause has been ended normally.
 */
 static void
-discard_exception(excp, was_finished)
+discard_exception(except_T *excp, int was_finished)
-except_T		*excp;
-int			was_finished;
 {
 char_u		*saved_IObuff;
 if (excp == NULL)
 {
 /*
 * Discard the exception currently being thrown.
 */
 void
-discard_current_exception()
+discard_current_exception(void)
 {
 discard_exception(current_exception, FALSE);
 current_exception = NULL;
 did_throw = FALSE;
 need_rethrow = FALSE;
 /*
 * Put an exception on the caught stack.
 */
 static void
-catch_exception(excp)
+catch_exception(except_T *excp)
-except_T	*excp;
 {
 excp->caught = caught_stack;
 caught_stack = excp;
 set_vim_var_string(VV_EXCEPTION, excp->value, -1);
 if (*excp->throw_name != NUL)
 /*
 * Remove an exception from the caught stack.
 */
 static void
-finish_exception(excp)
+finish_exception(except_T *excp)
-except_T	*excp;
 {
 if (excp != caught_stack)
 	EMSG(_(e_internal));
 caught_stack = caught_stack->caught;
 if (caught_stack != NULL)
 * made pending or something pending is resumed or discarded.  "pending" tells
 * what is pending.  "value" specifies the return value for a pending ":return"
 * or the exception value for a pending exception.
 */
 static void
-report_pending(action, pending, value)
+report_pending(int action, int pending, void *value)
-int		action;
-int		pending;
-void	*value;
 {
 char_u	*mesg;
 char	*s;
 int		save_msg_silent;
 /*
 * If something is made pending in a finally clause, report it if required by
 * the 'verbose' option or when debugging.
 */
 void
-report_make_pending(pending, value)
+report_make_pending(int pending, void *value)
-int		pending;
-void	*value;
 {
 if (p_verbose >= 14 || debug_break_level > 0)
 {
 	if (debug_break_level <= 0)
 	    verbose_enter();
 /*
 * If something pending in a finally clause is resumed at the ":endtry", report
 * it if required by the 'verbose' option or when debugging.
 */
 void
-report_resume_pending(pending, value)
+report_resume_pending(int pending, void *value)
-int		pending;
-void	*value;
 {
 if (p_verbose >= 14 || debug_break_level > 0)
 {
 	if (debug_break_level <= 0)
 	    verbose_enter();
 /*
 * If something pending in a finally clause is discarded, report it if required
 * by the 'verbose' option or when debugging.
 */
 void
-report_discard_pending(pending, value)
+report_discard_pending(int pending, void *value)
-int		pending;
-void	*value;
 {
 if (p_verbose >= 14 || debug_break_level > 0)
 {
 	if (debug_break_level <= 0)
 	    verbose_enter();
 /*
 * ":if".
 */
 void
-ex_if(eap)
+ex_if(exarg_T *eap)
-exarg_T	*eap;
 {
 int		error;
 int		skip;
 int		result;
 struct condstack	*cstack = eap->cstack;
 /*
 * ":endif".
 */
 void
-ex_endif(eap)
+ex_endif(exarg_T *eap)
-exarg_T	*eap;
 {
 did_endif = TRUE;
 if (eap->cstack->cs_idx < 0
 	    || (eap->cstack->cs_flags[eap->cstack->cs_idx]
 					   & (CSF_WHILE | CSF_FOR | CSF_TRY)))
 /*
 * ":else" and ":elseif".
 */
 void
-ex_else(eap)
+ex_else(exarg_T *eap)
-exarg_T	*eap;
 {
 int		error;
 int		skip;
 int		result;
 struct condstack	*cstack = eap->cstack;
 /*
 * Handle ":while" and ":for".
 */
 void
-ex_while(eap)
+ex_while(exarg_T *eap)
-exarg_T	*eap;
 {
 int		error;
 int		skip;
 int		result;
 struct condstack	*cstack = eap->cstack;
 /*
 * ":continue"
 */
 void
-ex_continue(eap)
+ex_continue(exarg_T *eap)
-exarg_T	*eap;
 {
 int		idx;
 struct condstack	*cstack = eap->cstack;
 if (cstack->cs_looplevel <= 0 || cstack->cs_idx < 0)
 /*
 * ":break"
 */
 void
-ex_break(eap)
+ex_break(exarg_T *eap)
-exarg_T	*eap;
 {
 int		idx;
 struct condstack	*cstack = eap->cstack;
 if (cstack->cs_looplevel <= 0 || cstack->cs_idx < 0)
 /*
 * ":endwhile" and ":endfor"
 */
 void
-ex_endwhile(eap)
+ex_endwhile(exarg_T *eap)
-exarg_T	*eap;
 {
 struct condstack	*cstack = eap->cstack;
 int			idx;
 char_u		*err;
 int			csf;
 /*
 * ":throw expr"
 */
 void
-ex_throw(eap)
+ex_throw(exarg_T *eap)
-exarg_T	*eap;
 {
 char_u	*arg = eap->arg;
 char_u	*value;
 if (*arg != NUL && *arg != '|' && *arg != '\n')
 * Throw the current exception through the specified cstack.  Common routine
 * for ":throw" (user exception) and error and interrupt exceptions.  Also
 * used for rethrowing an uncaught exception.
 */
 void
-do_throw(cstack)
+do_throw(struct condstack *cstack)
-struct condstack	*cstack;
 {
 int		idx;
 int		inactivate_try = FALSE;
 /*
 /*
 * ":try"
 */
 void
-ex_try(eap)
+ex_try(exarg_T *eap)
-exarg_T	*eap;
 {
 int		skip;
 struct condstack	*cstack = eap->cstack;
 if (cstack->cs_idx == CSTACK_LEN - 1)
 /*
 * ":catch /{pattern}/" and ":catch"
 */
 void
-ex_catch(eap)
+ex_catch(exarg_T *eap)
-exarg_T	*eap;
 {
 int		idx = 0;
 int		give_up = FALSE;
 int		skip = FALSE;
 int		caught = FALSE;
 /*
 * ":finally"
 */
 void
-ex_finally(eap)
+ex_finally(exarg_T *eap)
-exarg_T	*eap;
 {
 int		idx;
 int		skip = FALSE;
 int		pending = CSTP_NONE;
 struct condstack	*cstack = eap->cstack;
 /*
 * ":endtry"
 */
 void
-ex_endtry(eap)
+ex_endtry(exarg_T *eap)
-exarg_T	*eap;
 {
 int		idx;
 int		skip;
 int		rethrow = FALSE;
 int		pending = CSTP_NONE;
 * saves the error/interrupt/ exception state and prepares for the call to
 * do_cmdline() that is going to be made for the cleanup autocommand
 * execution.
 */
 void
-enter_cleanup(csp)
+enter_cleanup(cleanup_T *csp)
-cleanup_T	*csp;
 {
 int		pending = CSTP_NONE;
 /*
 * Postpone did_emsg, got_int, did_throw.  The pending values will be
 * error, an interrupt or an uncaught exception during execution of the
 * cleanup autocommands.  In the latter case, the saved error/interrupt/
 * exception state is discarded.
 */
 void
-leave_cleanup(csp)
+leave_cleanup(cleanup_T *csp)
-cleanup_T	*csp;
 {
 int		pending = csp->pending;
 if (pending == CSTP_NONE)	/* nothing to do */
 	return;
 * "emsg_silent", if reset when the try conditional finally reached was
 * entered, is restored (used by ex_endtry()).  This is normally done only
 * when such a try conditional is left.
 */
 int
-cleanup_conditionals(cstack, searched_cond, inclusive)
+cleanup_conditionals(
-struct condstack   *cstack;
+struct condstack   *cstack,
-int		searched_cond;
+int		searched_cond,
-int		inclusive;
+int		inclusive)
 {
 int		idx;
 int		stop = FALSE;
 for (idx = cstack->cs_idx; idx >= 0; --idx)
 /*
 * Return an appropriate error message for a missing endwhile/endfor/endif.
 */
 static char_u *
-get_end_emsg(cstack)
+get_end_emsg(struct condstack *cstack)
-struct condstack	*cstack;
 {
 if (cstack->cs_flags[cstack->cs_idx] & CSF_WHILE)
 	return e_endwhile;
 if (cstack->cs_flags[cstack->cs_idx] & CSF_FOR)
 	return e_endfor;
 * which is to be decremented with each skipped conditional of the specified
 * type.
 * Also free "for info" structures where needed.
 */
 void
-rewind_conditionals(cstack, idx, cond_type, cond_level)
+rewind_conditionals(
-struct condstack   *cstack;
+struct condstack   *cstack,
-int		idx;
+int		idx,
-int		cond_type;
+int		cond_type,
-int		*cond_level;
+int		*cond_level)
 {
 while (cstack->cs_idx > idx)
 {
 	if (cstack->cs_flags[cstack->cs_idx] & cond_type)
 	    --*cond_level;
 /*
 * ":endfunction" when not after a ":function"
 */
 void
-ex_endfunction(eap)
+ex_endfunction(exarg_T *eap UNUSED)
-exarg_T	*eap UNUSED;
 {
 EMSG(_("E193: :endfunction not inside a function"));
 }
 /*
 * Return TRUE if the string "p" looks like a ":while" or ":for" command.
 */
 int
-has_loop_cmd(p)
+has_loop_cmd(char_u *p)
-char_u	*p;
 {
 int		len;
 /* skip modifiers, white space and ':' */
 for (;;)

Mercurial > vim

comparison src/ex_eval.c @ 7819:f86adafb28d4 v7.4.1206