vim: src/message.c comparison

comparison src/message.c @ 7827:41789f16d6b2 v7.4.1210

commit https://github.com/vim/vim/commit/52ea13da0fe86df1abf34de52841e367035170c0 Author: Bram Moolenaar <Bram@vim.org> Date: Sat Jan 30 18:51:09 2016 +0100 patch 7.4.1210 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 19:00:05 +0100
parents	37c929c4a073
children	58505cbea7e5

comparison

equal deleted inserted replaced

-:df34d45f38d4
+:41789f16d6b2
 * msg(s) - displays the string 's' on the status line
 * When terminal not initialized (yet) mch_errmsg(..) is used.
 * return TRUE if wait_return not called
 */
 int
-msg(s)
+msg(char_u *s)
-char_u	*s;
 {
 return msg_attr_keep(s, 0, FALSE);
 }
 #if defined(FEAT_EVAL) || defined(FEAT_X11) || defined(USE_XSMP) \
 || defined(FEAT_GUI_GTK) || defined(PROTO)
 /*
 * Like msg() but keep it silent when 'verbosefile' is set.
 */
 int
-verb_msg(s)
+verb_msg(char_u *s)
-char_u	*s;
 {
 int		n;
 verbose_enter();
 n = msg_attr_keep(s, 0, FALSE);
 return n;
 }
 #endif
 int
-msg_attr(s, attr)
+msg_attr(char_u *s, int attr)
-char_u	*s;
-int		attr;
 {
 return msg_attr_keep(s, attr, FALSE);
 }
 int
-msg_attr_keep(s, attr, keep)
+msg_attr_keep(
-char_u	*s;
+char_u	*s,
-int		attr;
+int		attr,
-int		keep;	    /* TRUE: set keep_msg if it doesn't scroll */
+int		keep)	    /* TRUE: set keep_msg if it doesn't scroll */
 {
 static int	entered = 0;
 int		retval;
 char_u	*buf = NULL;
 /*
 * Truncate a string such that it can be printed without causing a scroll.
 * Returns an allocated string or NULL when no truncating is done.
 */
 char_u *
-msg_strtrunc(s, force)
+msg_strtrunc(
-char_u	*s;
+char_u	*s,
-int		force;	    /* always truncate */
+int		force)	    /* always truncate */
 {
 char_u	*buf = NULL;
 int		len;
 int		room;
 /*
 * Truncate a string "s" to "buf" with cell width "room".
 * "s" and "buf" may be equal.
 */
 void
-trunc_string(s, buf, room, buflen)
+trunc_string(
-char_u	*s;
+char_u	*s,
-char_u	*buf;
+char_u	*buf,
-int		room;
+int		room,
-int		buflen;
+int		buflen)
 {
 int		half;
 int		len;
 int		e;
 int		i;
 /*
 * Reset the last used sourcing name/lnum.  Makes sure it is displayed again
 * for the next error message;
 */
 void
-reset_last_sourcing()
+reset_last_sourcing(void)
 {
 vim_free(last_sourcing_name);
 last_sourcing_name = NULL;
 last_sourcing_lnum = 0;
 }
 /*
 * Return TRUE if "sourcing_name" differs from "last_sourcing_name".
 */
 static int
-other_sourcing_name()
+other_sourcing_name(void)
 {
 if (sourcing_name != NULL)
 {
 	if (last_sourcing_name != NULL)
 	    return STRCMP(sourcing_name, last_sourcing_name) != 0;
 * Get the message about the source, as used for an error message.
 * Returns an allocated string with room for one more character.
 * Returns NULL when no message is to be given.
 */
 static char_u *
-get_emsg_source()
+get_emsg_source(void)
 {
 char_u	*Buf, *p;
 if (sourcing_name != NULL && other_sourcing_name())
 {
 * Get the message about the source lnum, as used for an error message.
 * Returns an allocated string with room for one more character.
 * Returns NULL when no message is to be given.
 */
 static char_u *
-get_emsg_lnum()
+get_emsg_lnum(void)
 {
 char_u	*Buf, *p;
 /* lnum is 0 when executing a command from the command line
 * argument, we don't want a line number then */
 * Display name and line number for the source of an error.
 * Remember the file name and line number, so that for the next error the info
 * is only displayed if it changed.
 */
 void
-msg_source(attr)
+msg_source(int attr)
-int		attr;
 {
 char_u	*p;
 ++no_wait_return;
 p = get_emsg_source();
 * If "emsg_off" is set: no error messages at the moment.
 * If "msg" is in 'debug': do error message but without side effects.
 * If "emsg_skip" is set: never do error messages.
 */
 int
-emsg_not_now()
+emsg_not_now(void)
 {
 if ((emsg_off > 0 && vim_strchr(p_debug, 'm') == NULL
 					  && vim_strchr(p_debug, 't') == NULL)
 #ifdef FEAT_EVAL
 	    || emsg_skip > 0
 * When terminal not initialized (yet) mch_errmsg(..) is used.
 *
 * return TRUE if wait_return not called
 */
 int
-emsg(s)
+emsg(char_u *s)
-char_u	*s;
 {
 int		attr;
 char_u	*p;
 #ifdef FEAT_EVAL
 int		ignore = FALSE;
 /*
 * Print an error message with one "%s" and one string argument.
 */
 int
-emsg2(s, a1)
+emsg2(char_u *s, char_u *a1)
-char_u *s, *a1;
 {
 return emsg3(s, a1, NULL);
 }
 /* emsg3() and emsgn() are in misc2.c to avoid warnings for the prototypes. */
 void
-emsg_invreg(name)
+emsg_invreg(int name)
-int	    name;
 {
 EMSG2(_("E354: Invalid register name: '%s'"), transchar(name));
 }
 /*
 * "force" is TRUE.  This truncates in another way as for normal messages.
 * Careful: The string may be changed by msg_may_trunc()!
 * Returns a pointer to the printed message, if wait_return() not called.
 */
 char_u *
-msg_trunc_attr(s, force, attr)
+msg_trunc_attr(char_u *s, int force, int attr)
-char_u	*s;
-int		force;
-int		attr;
 {
 int		n;
 /* Add message to history before truncating */
 add_msg_hist(s, -1, attr);
 * Check if message "s" should be truncated at the start (for filenames).
 * Return a pointer to where the truncated message starts.
 * Note: May change the message by replacing a character with '<'.
 */
 char_u *
-msg_may_trunc(force, s)
+msg_may_trunc(int force, char_u *s)
-int		force;
-char_u	*s;
 {
 int		n;
 int		room;
 room = (int)(Rows - cmdline_row - 1) * Columns + sc_col - 1;
 }
 return s;
 }
 static void
-add_msg_hist(s, len, attr)
+add_msg_hist(
-char_u	*s;
+char_u	*s,
-int		len;		/* -1 for undetermined length */
+int		len,		/* -1 for undetermined length */
-int		attr;
+int		attr)
 {
 struct msg_hist *p;
 if (msg_hist_off || msg_silent != 0)
 	return;
 /*
 * Delete the first (oldest) message from the history.
 * Returns FAIL if there are no messages.
 */
 int
-delete_first_msg()
+delete_first_msg(void)
 {
 struct msg_hist *p;
 if (msg_hist_len <= 0)
 	return FAIL;
 /*
 * ":messages" command.
 */
 void
-ex_messages(eap)
+ex_messages(exarg_T *eap UNUSED)
-exarg_T	*eap UNUSED;
 {
 struct msg_hist *p;
 char_u	    *s;
 msg_hist_off = TRUE;
 /*
 * Call this after prompting the user.  This will avoid a hit-return message
 * and a delay.
 */
 void
-msg_end_prompt()
+msg_end_prompt(void)
 {
 need_wait_return = FALSE;
 emsg_on_display = FALSE;
 cmdline_row = msg_row;
 msg_col = 0;
 * if 'redraw' is TRUE, clear and redraw the screen
 * if 'redraw' is FALSE, just redraw the screen
 * if 'redraw' is -1, don't redraw at all
 */
 void
-wait_return(redraw)
+wait_return(int redraw)
-int		redraw;
 {
 int		c;
 int		oldState;
 int		tmpState;
 int		had_got_int;
 /*
 * Write the hit-return prompt.
 */
 static void
-hit_return_msg()
+hit_return_msg(void)
 {
 int		save_p_more = p_more;
 p_more = FALSE;	/* don't want see this message when scrolling back */
 if (msg_didout)	/* start on a new line */
 /*
 * Set "keep_msg" to "s".  Free the old value and check for NULL pointer.
 */
 void
-set_keep_msg(s, attr)
+set_keep_msg(char_u *s, int attr)
-char_u	*s;
-int		attr;
 {
 vim_free(keep_msg);
 if (s != NULL && msg_silent == 0)
 	keep_msg = vim_strsave(s);
 else
 /*
 * If there currently is a message being displayed, set "keep_msg" to it, so
 * that it will be displayed again after redraw.
 */
 void
-set_keep_msg_from_hist()
+set_keep_msg_from_hist(void)
 {
 if (keep_msg == NULL && last_msg_hist != NULL && msg_scrolled == 0
 							  && (State & NORMAL))
 	set_keep_msg(last_msg_hist->msg, last_msg_hist->attr);
 }
 /*
 * Prepare for outputting characters in the command line.
 */
 void
-msg_start()
+msg_start(void)
 {
 int		did_return = FALSE;
 if (!msg_silent)
 {
 /*
 * Note that the current msg position is where messages start.
 */
 void
-msg_starthere()
+msg_starthere(void)
 {
 lines_left = cmdline_row;
 msg_didany = FALSE;
 }
 void
-msg_putchar(c)
+msg_putchar(int c)
-int		c;
 {
 msg_putchar_attr(c, 0);
 }
 void
-msg_putchar_attr(c, attr)
+msg_putchar_attr(int c, int attr)
-int		c;
-int		attr;
 {
 #ifdef FEAT_MBYTE
 char_u	buf[MB_MAXBYTES + 1];
 #else
 char_u	buf[4];
 }
 msg_puts_attr(buf, attr);
 }
 void
-msg_outnum(n)
+msg_outnum(long n)
-long	n;
 {
 char_u	buf[20];
 sprintf((char *)buf, "%ld", n);
 msg_puts(buf);
 }
 void
-msg_home_replace(fname)
+msg_home_replace(char_u *fname)
-char_u	*fname;
 {
 msg_home_replace_attr(fname, 0);
 }
 #if defined(FEAT_FIND_ID) || defined(PROTO)
 void
-msg_home_replace_hl(fname)
+msg_home_replace_hl(char_u *fname)
-char_u	*fname;
 {
 msg_home_replace_attr(fname, hl_attr(HLF_D));
 }
 #endif
 static void
-msg_home_replace_attr(fname, attr)
+msg_home_replace_attr(char_u *fname, int attr)
-char_u  *fname;
-int	    attr;
 {
 char_u	*name;
 name = home_replace_save(NULL, fname);
 if (name != NULL)
 * if 'len' is -1, output upto a NUL character.
 * Use attributes 'attr'.
 * Return the number of characters it takes on the screen.
 */
 int
-msg_outtrans(str)
+msg_outtrans(char_u *str)
-char_u	    *str;
 {
 return msg_outtrans_attr(str, 0);
 }
 int
-msg_outtrans_attr(str, attr)
+msg_outtrans_attr(char_u *str, int attr)
-char_u	*str;
-int		attr;
 {
 return msg_outtrans_len_attr(str, (int)STRLEN(str), attr);
 }
 int
-msg_outtrans_len(str, len)
+msg_outtrans_len(char_u *str, int len)
-char_u	*str;
-int		len;
 {
 return msg_outtrans_len_attr(str, len, 0);
 }
 /*
 * Output one character at "p".  Return pointer to the next character.
 * Handles multi-byte characters.
 */
 char_u *
-msg_outtrans_one(p, attr)
+msg_outtrans_one(char_u *p, int attr)
-char_u	*p;
-int		attr;
 {
 #ifdef FEAT_MBYTE
 int		l;
 if (has_mbyte && (l = (*mb_ptr2len)(p)) > 1)
 msg_puts_attr(transchar_byte(*p), attr);
 return p + 1;
 }
 int
-msg_outtrans_len_attr(msgstr, len, attr)
+msg_outtrans_len_attr(char_u *msgstr, int len, int attr)
-char_u	*msgstr;
-int		len;
-int		attr;
 {
 int		retval = 0;
 char_u	*str = msgstr;
 char_u	*plain_start = msgstr;
 char_u	*s;
 return retval;
 }
 #if defined(FEAT_QUICKFIX) || defined(PROTO)
 void
-msg_make(arg)
+msg_make(char_u *arg)
-char_u  *arg;
 {
 int	    i;
 static char_u *str = (char_u *)"eeffoc", *rs = (char_u *)"Plon#dqg#vxjduB";
 arg = skipwhite(arg);
 * Otherwise characters are not highlighted.
 * This function is used to show mappings, where we want to see how to type
 * the character/string -- webb
 */
 int
-msg_outtrans_special(strstart, from)
+msg_outtrans_special(
-char_u	*strstart;
+char_u	*strstart,
-int		from;	/* TRUE for lhs of a mapping */
+int		from)	/* TRUE for lhs of a mapping */
 {
 char_u	*str = strstart;
 int		retval = 0;
 char_u	*string;
 int		attr;
 /*
 * Return the lhs or rhs of a mapping, with the key codes turned into printable
 * strings, in an allocated string.
 */
 char_u *
-str2special_save(str, is_lhs)
+str2special_save(
-char_u  *str;
+char_u  *str,
-int	    is_lhs;  /* TRUE for lhs, FALSE for rhs */
+int	    is_lhs)  /* TRUE for lhs, FALSE for rhs */
 {
 garray_T	ga;
 char_u	*p = str;
 ga_init2(&ga, 1, 40);
 * Return the printable string for the key codes at "*sp".
 * Used for translating the lhs or rhs of a mapping to printable chars.
 * Advances "sp" to the next code.
 */
 char_u *
-str2special(sp, from)
+str2special(
-char_u	**sp;
+char_u	**sp,
-int		from;	/* TRUE for lhs of mapping */
+int		from)	/* TRUE for lhs of mapping */
 {
 int			c;
 static char_u	buf[7];
 char_u		*str = *sp;
 int			modifiers = 0;
 /*
 * Translate a key sequence into special key names.
 */
 void
-str2specialbuf(sp, buf, len)
+str2specialbuf(char_u *sp, char_u *buf, int len)
-char_u	*sp;
-char_u	*buf;
-int		len;
 {
 char_u	*s;
 *buf = NUL;
 while (*sp)
 /*
 * print line for :print or :list command
 */
 void
-msg_prt_line(s, list)
+msg_prt_line(char_u *s, int list)
-char_u	*s;
-int		list;
 {
 int		c;
 int		col = 0;
 int		n_extra = 0;
 int		c_extra = 0;
 /*
 * Use screen_puts() to output one multi-byte character.
 * Return the pointer "s" advanced to the next character.
 */
 static char_u *
-screen_puts_mbyte(s, l, attr)
+screen_puts_mbyte(char_u *s, int l, int attr)
-char_u	*s;
-int		l;
-int		attr;
 {
 int		cw;
 msg_didout = TRUE;		/* remember that line is not empty */
 cw = (*mb_ptr2cells)(s);
 /*
 * Output a string to the screen at position msg_row, msg_col.
 * Update msg_row and msg_col for the next message.
 */
 void
-msg_puts(s)
+msg_puts(char_u *s)
-char_u	*s;
+{
-{
+msg_puts_attr(s, 0);
-msg_puts_attr(s, 0);
 }
 void
-msg_puts_title(s)
+msg_puts_title(
-char_u	*s;
+char_u	*s)
 {
 msg_puts_attr(s, hl_attr(HLF_T));
 }
 /*
 * Show a message in such a way that it always fits in the line.  Cut out a
 * part in the middle and replace it with "..." when necessary.
 * Does not handle multi-byte characters!
 */
 void
-msg_puts_long_attr(longstr, attr)
+msg_puts_long_attr(char_u *longstr, int attr)
-char_u	*longstr;
-int		attr;
 {
 msg_puts_long_len_attr(longstr, (int)STRLEN(longstr), attr);
 }
 void
-msg_puts_long_len_attr(longstr, len, attr)
+msg_puts_long_len_attr(char_u *longstr, int len, int attr)
-char_u	*longstr;
-int		len;
-int		attr;
 {
 int		slen = len;
 int		room;
 room = Columns - msg_col;
 /*
 * Basic function for writing a message with highlight attributes.
 */
 void
-msg_puts_attr(s, attr)
+msg_puts_attr(char_u *s, int attr)
-char_u	*s;
-int		attr;
 {
 msg_puts_attr_len(s, -1, attr);
 }
 /*
 * Like msg_puts_attr(), but with a maximum length "maxlen" (in bytes).
 * When "maxlen" is -1 there is no maximum length.
 * When "maxlen" is >= 0 the message is not put in the history.
 */
 static void
-msg_puts_attr_len(str, maxlen, attr)
+msg_puts_attr_len(char_u *str, int maxlen, int attr)
-char_u	*str;
-int		maxlen;
-int		attr;
 {
 /*
 * If redirection is on, also write to the redirection file.
 */
 redir_write(str, maxlen);
 /*
 * The display part of msg_puts_attr_len().
 * May be called recursively to display scroll-back text.
 */
 static void
-msg_puts_display(str, maxlen, attr, recurse)
+msg_puts_display(
-char_u	*str;
+char_u	*str,
-int		maxlen;
+int		maxlen,
-int		attr;
+int		attr,
-int		recurse;
+int		recurse)
 {
 char_u	*s = str;
 char_u	*t_s = str;	/* string from "t_s" to "s" is still todo */
 int		t_col = 0;	/* screen cells todo, 0 when "t_s" not used */
 #ifdef FEAT_MBYTE
 /*
 * Scroll the screen up one line for displaying the next message line.
 */
 static void
-msg_scroll_up()
+msg_scroll_up(void)
 {
 #ifdef FEAT_GUI
 /* Remove the cursor before scrolling, ScreenLines[] is going
 * to become invalid. */
 if (gui.in_use)
 /*
 * Increment "msg_scrolled".
 */
 static void
-inc_msg_scrolled()
+inc_msg_scrolled(void)
 {
 #ifdef FEAT_EVAL
 if (*get_vim_var_str(VV_SCROLLSTART) == NUL)
 {
 	char_u	    *p = sourcing_name;
 /*
 * Store part of a printed message for displaying when scrolling back.
 */
 static void
-store_sb_text(sb_str, s, attr, sb_col, finish)
+store_sb_text(
-char_u	**sb_str;	/* start of string */
+char_u	**sb_str,	/* start of string */
-char_u	*s;		/* just after string */
+char_u	*s,		/* just after string */
-int		attr;
+int		attr,
-int		*sb_col;
+int		*sb_col,
-int		finish;		/* line ends */
+int		finish)		/* line ends */
 {
 msgchunk_T	*mp;
 if (do_clear_sb_text)
 {
 /*
 * Finished showing messages, clear the scroll-back text on the next message.
 */
 void
-may_clear_sb_text()
+may_clear_sb_text(void)
 {
 do_clear_sb_text = TRUE;
 }
 /*
 * Clear any text remembered for scrolling back.
 * Called when redrawing the screen.
 */
 void
-clear_sb_text()
+clear_sb_text(void)
 {
 msgchunk_T	*mp;
 while (last_msgchunk != NULL)
 {
 /*
 * "g<" command.
 */
 void
-show_sb_text()
+show_sb_text(void)
 {
 msgchunk_T	*mp;
 /* Only show something if there is more than one line, otherwise it looks
 * weird, typing a command without output results in one line. */
 /*
 * Move to the start of screen line in already displayed text.
 */
 static msgchunk_T *
-msg_sb_start(mps)
+msg_sb_start(msgchunk_T *mps)
-msgchunk_T *mps;
 {
 msgchunk_T *mp = mps;
 while (mp != NULL && mp->sb_prev != NULL && !mp->sb_prev->sb_eol)
 	mp = mp->sb_prev;
 /*
 * Mark the last message chunk as finishing the line.
 */
 void
-msg_sb_eol()
+msg_sb_eol(void)
 {
 if (last_msgchunk != NULL)
 	last_msgchunk->sb_eol = TRUE;
 }
 /*
 * Display a screen line from previously displayed text at row "row".
 * Returns a pointer to the text for the next line (can be NULL).
 */
 static msgchunk_T *
-disp_sb_line(row, smp)
+disp_sb_line(int row, msgchunk_T *smp)
-int		row;
-msgchunk_T	*smp;
 {
 msgchunk_T	*mp = smp;
 char_u	*p;
 for (;;)
 /*
 * Output any postponed text for msg_puts_attr_len().
 */
 static void
-t_puts(t_col, t_s, s, attr)
+t_puts(
-int		*t_col;
+int		*t_col,
-char_u	*t_s;
+char_u	*t_s,
-char_u	*s;
+char_u	*s,
-int		attr;
+int		attr)
 {
 /* output postponed text */
 msg_didout = TRUE;		/* remember that line is not empty */
 screen_puts_len(t_s, (int)(s - t_s), msg_row, msg_col, attr);
 msg_col += *t_col;
 * window, cursor positioning may not work correctly (window size may be
 * different, e.g. for Win32 console) or we just don't know where the
 * cursor is.
 */
 int
-msg_use_printf()
+msg_use_printf(void)
 {
 return (!msg_check_screen()
 #if defined(WIN3264) && !defined(FEAT_GUI_MSWIN)
 	    || !termcap_active
 #endif
 /*
 * Print a message when there is no valid screen.
 */
 static void
-msg_puts_printf(str, maxlen)
+msg_puts_printf(char_u *str, int maxlen)
-char_u	*str;
-int		maxlen;
 {
 char_u	*s = str;
 char_u	buf[4];
 char_u	*p;
 * When at hit-enter prompt "typed_char" is the already typed character,
 * otherwise it's NUL.
 * Returns TRUE when jumping ahead to "confirm_msg_tail".
 */
 static int
-do_more_prompt(typed_char)
+do_more_prompt(int typed_char)
-int		typed_char;
 {
 int		used_typed_char = typed_char;
 int		oldState = State;
 int		c;
 #ifdef FEAT_CON_DIALOG
 * Give an error message.  To be used when the screen hasn't been initialized
 * yet.  When stderr can't be used, collect error messages until the GUI has
 * started and they can be displayed in a message box.
 */
 void
-mch_errmsg(str)
+mch_errmsg(char *str)
-char	*str;
 {
 int		len;
 #if (defined(UNIX) || defined(FEAT_GUI)) && !defined(ALWAYS_USE_GUI)
 /* On Unix use stderr if it's a tty.
 * Give a message.  To be used when the screen hasn't been initialized yet.
 * When there is no tty, collect messages until the GUI has started and they
 * can be displayed in a message box.
 */
 void
-mch_msg(str)
+mch_msg(char *str)
-char	*str;
 {
 #if (defined(UNIX) || defined(FEAT_GUI)) && !defined(ALWAYS_USE_GUI)
 /* On Unix use stdout if we have a tty.  This allows "vim -h | more" and
 * uses mch_errmsg() when started from the desktop.
 * When not going to start the GUI also use stdout.
 /*
 * Put a character on the screen at the current message position and advance
 * to the next position.  Only for printable ASCII!
 */
 static void
-msg_screen_putchar(c, attr)
+msg_screen_putchar(int c, int attr)
-int		c;
-int		attr;
 {
 msg_didout = TRUE;		/* remember that line is not empty */
 screen_putchar(c, msg_row, msg_col, attr);
 #ifdef FEAT_RIGHTLEFT
 if (cmdmsg_rl)
 	}
 }
 }
 void
-msg_moremsg(full)
+msg_moremsg(int full)
-int	    full;
 {
 int		attr;
 char_u	*s = (char_u *)_("-- More --");
 attr = hl_attr(HLF_M);
 /*
 * Repeat the message for the current mode: ASKMORE, EXTERNCMD, CONFIRM or
 * exmode_active.
 */
 void
-repeat_message()
+repeat_message(void)
 {
 if (State == ASKMORE)
 {
 	msg_moremsg(TRUE);	/* display --more-- message again */
 	msg_row = Rows - 1;
 * Also check msg_row and msg_col, if they are too big it may cause a crash.
 * While starting the GUI the terminal codes will be set for the GUI, but the
 * output goes to the terminal.  Don't use the terminal codes then.
 */
 static int
-msg_check_screen()
+msg_check_screen(void)
 {
 if (!full_screen || !screen_valid(FALSE))
 	return FALSE;
 if (msg_row >= Rows)
 /*
 * Clear from current message position to end of screen.
 * Skip this when ":silent" was used, no need to clear for redirection.
 */
 void
-msg_clr_eos()
+msg_clr_eos(void)
 {
 if (msg_silent == 0)
 	msg_clr_eos_force();
 }
 * Clear from current message position to end of screen.
 * Note: msg_col is not updated, so we remember the end of the message
 * for msg_check().
 */
 void
-msg_clr_eos_force()
+msg_clr_eos_force(void)
 {
 if (msg_use_printf())
 {
 	if (full_screen)	/* only when termcap codes are valid */
 	{
 /*
 * Clear the command line.
 */
 void
-msg_clr_cmdline()
+msg_clr_cmdline(void)
 {
 msg_row = cmdline_row;
 msg_col = 0;
 msg_clr_eos_force();
 }
 * end putting a message on the screen
 * call wait_return if the message does not fit in the available space
 * return TRUE if wait_return not called.
 */
 int
-msg_end()
+msg_end(void)
 {
 /*
 * If the string is larger than the window,
 * or the ruler option is set and we run into it,
 * we have to redraw the window.
 /*
 * If the written message runs into the shown command or ruler, we have to
 * wait for hit-return and redraw the window later.
 */
 void
-msg_check()
+msg_check(void)
 {
 if (msg_row == Rows - 1 && msg_col >= sc_col)
 {
 	need_wait_return = TRUE;
 	redraw_cmdline = TRUE;
 /*
 * May write a string to the redirection file.
 * When "maxlen" is -1 write the whole string, otherwise up to "maxlen" bytes.
 */
 static void
-redir_write(str, maxlen)
+redir_write(char_u *str, int maxlen)
-char_u	*str;
-int		maxlen;
 {
 char_u	*s = str;
 static int	cur_col = 0;
 /* Don't do anything for displaying prompts and the like. */
 	    msg_col = cur_col;
 }
 }
 int
-redirecting()
+redirecting(void)
 {
 return redir_fd != NULL || *p_vfile != NUL
 #ifdef FEAT_EVAL
 			  || redir_reg || redir_vname
 #endif
 /*
 * Before giving verbose message.
 * Must always be called paired with verbose_leave()!
 */
 void
-verbose_enter()
+verbose_enter(void)
 {
 if (*p_vfile != NUL)
 	++msg_silent;
 }
 /*
 * After giving verbose message.
 * Must always be called paired with verbose_enter()!
 */
 void
-verbose_leave()
+verbose_leave(void)
 {
 if (*p_vfile != NUL)
 	if (--msg_silent < 0)
 	    msg_silent = 0;
 }
 /*
 * Like verbose_enter() and set msg_scroll when displaying the message.
 */
 void
-verbose_enter_scroll()
+verbose_enter_scroll(void)
 {
 if (*p_vfile != NUL)
 	++msg_silent;
 else
 	/* always scroll up, don't overwrite */
 /*
 * Like verbose_leave() and set cmdline_row when displaying the message.
 */
 void
-verbose_leave_scroll()
+verbose_leave_scroll(void)
 {
 if (*p_vfile != NUL)
 {
 	if (--msg_silent < 0)
 	    msg_silent = 0;
 /*
 * Called when 'verbosefile' is set: stop writing to the file.
 */
 void
-verbose_stop()
+verbose_stop(void)
 {
 if (verbose_fd != NULL)
 {
 	fclose(verbose_fd);
 	verbose_fd = NULL;
 /*
 * Open the file 'verbosefile'.
 * Return FAIL or OK.
 */
 int
-verbose_open()
+verbose_open(void)
 {
 if (verbose_fd == NULL && !verbose_did_open)
 {
 	/* Only give the error message once. */
 	verbose_did_open = TRUE;
 /*
 * Give a warning message (for searching).
 * Use 'w' highlighting and may repeat the message after redrawing
 */
 void
-give_warning(message, hl)
+give_warning(char_u *message, int hl)
-char_u  *message;
-int	    hl;
 {
 /* Don't do this for ":silent". */
 if (msg_silent != 0)
 	return;
 /*
 * Advance msg cursor to column "col".
 */
 void
-msg_advance(col)
+msg_advance(int col)
-int	    col;
 {
 if (msg_silent != 0)	/* nothing to advance to */
 {
 	msg_col = col;		/* for redirection, may fill it up later */
 	return;
 * Other buttons- use your imagination!
 * A '&' in a button name becomes a shortcut, so each '&' should be before a
 * different letter.
 */
 int
-do_dialog(type, title, message, buttons, dfltbutton, textfield, ex_cmd)
+do_dialog(
-int		type UNUSED;
+int		type UNUSED,
-char_u	*title UNUSED;
+char_u	*title UNUSED,
-char_u	*message;
+char_u	*message,
-char_u	*buttons;
+char_u	*buttons,
-int		dfltbutton;
+int		dfltbutton,
-char_u	*textfield UNUSED;	/* IObuff for inputdialog(), NULL
+char_u	*textfield UNUSED,	/* IObuff for inputdialog(), NULL
 					   otherwise */
-int		ex_cmd;	    /* when TRUE pressing : accepts default and starts
+int		ex_cmd)	    /* when TRUE pressing : accepts default and starts
 			       Ex command */
 {
 int		oldState;
 int		retval = 0;
 char_u	*hotkeys;
 /*
 * Copy one character from "*from" to "*to", taking care of multi-byte
 * characters.  Return the length of the character in bytes.
 */
 static int
-copy_char(from, to, lowercase)
+copy_char(
-char_u	*from;
+char_u	*from,
-char_u	*to;
+char_u	*to,
-int		lowercase;	/* make character lower case */
+int		lowercase)	/* make character lower case */
 {
 #ifdef FEAT_MBYTE
 int		len;
 int		c;
 * The hotkeys can be multi-byte characters, but without combining chars.
 *
 * Returns an allocated string with hotkeys, or NULL for error.
 */
 static char_u *
-msg_show_console_dialog(message, buttons, dfltbutton)
+msg_show_console_dialog(
-char_u	*message;
+char_u	*message,
-char_u	*buttons;
+char_u	*buttons,
-int		dfltbutton;
+int		dfltbutton)
 {
 int		len = 0;
 #ifdef FEAT_MBYTE
 # define HOTK_LEN (has_mbyte ? MB_MAXBYTES : 1)
 #else
 /*
 * Display the ":confirm" message.  Also called when screen resized.
 */
 void
-display_confirm_msg()
+display_confirm_msg(void)
 {
 /* avoid that 'q' at the more prompt truncates the message here */
 ++confirm_msg_used;
 if (confirm_msg != NULL)
 	msg_puts_attr(confirm_msg, hl_attr(HLF_M));
 #endif /* FEAT_CON_DIALOG */
 #if defined(FEAT_CON_DIALOG) || defined(FEAT_GUI_DIALOG)
 int
-vim_dialog_yesno(type, title, message, dflt)
+vim_dialog_yesno(
-int		type;
+int		type,
-char_u	*title;
+char_u	*title,
-char_u	*message;
+char_u	*message,
-int		dflt;
+int		dflt)
 {
 if (do_dialog(type,
 		title == NULL ? (char_u *)_("Question") : title,
 		message,
 		(char_u *)_("&Yes\n&No"), dflt, NULL, FALSE) == 1)
 	return VIM_YES;
 return VIM_NO;
 }
 int
-vim_dialog_yesnocancel(type, title, message, dflt)
+vim_dialog_yesnocancel(
-int		type;
+int		type,
-char_u	*title;
+char_u	*title,
-char_u	*message;
+char_u	*message,
-int		dflt;
+int		dflt)
 {
 switch (do_dialog(type,
 		title == NULL ? (char_u *)_("Question") : title,
 		message,
 		(char_u *)_("&Yes\n&No\n&Cancel"), dflt, NULL, FALSE))
 }
 return VIM_CANCEL;
 }
 int
-vim_dialog_yesnoallcancel(type, title, message, dflt)
+vim_dialog_yesnoallcancel(
-int		type;
+int		type,
-char_u	*title;
+char_u	*title,
-char_u	*message;
+char_u	*message,
-int		dflt;
+int		dflt)
 {
 switch (do_dialog(type,
 		title == NULL ? (char_u *)"Question" : title,
 		message,
 		(char_u *)_("&Yes\n&No\nSave &All\n&Discard All\n&Cancel"),
 /*
 * Generic browse function.  Calls gui_mch_browse() when possible.
 * Later this may pop-up a non-GUI file selector (external command?).
 */
 char_u *
-do_browse(flags, title, dflt, ext, initdir, filter, buf)
+do_browse(
-int		flags;		/* BROWSE_SAVE and BROWSE_DIR */
+int		flags,		/* BROWSE_SAVE and BROWSE_DIR */
-char_u	*title;		/* title for the window */
+char_u	*title,		/* title for the window */
-char_u	*dflt;		/* default file name (may include directory) */
+char_u	*dflt,		/* default file name (may include directory) */
-char_u	*ext;		/* extension added */
+char_u	*ext,		/* extension added */
-char_u	*initdir;	/* initial directory, NULL for current dir or
+char_u	*initdir,	/* initial directory, NULL for current dir or
 				   when using path from "dflt" */
-char_u	*filter;	/* file name filter */
+char_u	*filter,	/* file name filter */
-buf_T	*buf;		/* buffer to read/write for */
+buf_T	*buf)		/* buffer to read/write for */
 {
 char_u		*fname;
 static char_u	*last_dir = NULL;    /* last used directory */
 char_u		*tofree = NULL;
 int			save_browse = cmdmod.browse;
 /*
 * Get number argument from "idxp" entry in "tvs".  First entry is 1.
 */
 static long
-tv_nr(tvs, idxp)
+tv_nr(typval_T *tvs, int *idxp)
-typval_T	*tvs;
-int		*idxp;
 {
 int		idx = *idxp - 1;
 long	n = 0;
 int		err = FALSE;
 /*
 * Get string argument from "idxp" entry in "tvs".  First entry is 1.
 * Returns NULL for an error.
 */
 static char *
-tv_str(tvs, idxp)
+tv_str(typval_T *tvs, int *idxp)
-typval_T	*tvs;
-int		*idxp;
 {
 int		idx = *idxp - 1;
 char	*s = NULL;
 if (tvs[idx].v_type == VAR_UNKNOWN)
 # ifdef FEAT_FLOAT
 /*
 * Get float argument from "idxp" entry in "tvs".  First entry is 1.
 */
 static double
-tv_float(tvs, idxp)
+tv_float(typval_T *tvs, int *idxp)
-typval_T	*tvs;
-int		*idxp;
 {
 int		idx = *idxp - 1;
 double	f = 0;
 if (tvs[idx].v_type == VAR_UNKNOWN)
 va_end(ap);
 return str_l;
 }
 int
-vim_vsnprintf(str, str_m, fmt, ap, tvs)
+vim_vsnprintf(
-char	*str;
+char	*str,
-size_t	str_m;
+size_t	str_m,
-char	*fmt;
+char	*fmt,
-va_list	ap;
+va_list	ap,
-typval_T	*tvs;
+typval_T	*tvs)
 {
 size_t	str_l = 0;
 char	*p = fmt;
 int		arg_idx = 1;

Mercurial > vim

comparison src/message.c @ 7827:41789f16d6b2 v7.4.1210