vim: src/window.c comparison

comparison src/window.c @ 7837:33ba2adb6065

commit https://github.com/vim/vim/commit/b638a7be952544ceb03052c25b84224577a6494b Author: Bram Moolenaar <Bram@vim.org> Date: Sat Jan 30 21:29:58 2016 +0100 patch 7.4.1215 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 21:30:04 +0100
parents	0b6c37dd858d
children	05b88224cea1

comparison

equal deleted inserted replaced

-:4f052afd5b05
+:33ba2adb6065
 /*
 * all CTRL-W window commands are handled here, called from normal_cmd().
 */
 void
-do_window(nchar, Prenum, xchar)
+do_window(
-int		nchar;
+int		nchar,
-long	Prenum;
+long	Prenum,
-int		xchar;	    /* extra char from ":wincmd gx" or NUL */
+int		xchar)	    /* extra char from ":wincmd gx" or NUL */
 {
 long	Prenum1;
 win_T	*wp;
 #if defined(FEAT_SEARCHPATH) || defined(FEAT_FIND_ID)
 char_u	*ptr;
 /*
 * Figure out the address type for ":wnncmd".
 */
 void
-get_wincmd_addr_type(arg, eap)
+get_wincmd_addr_type(char_u *arg, exarg_T *eap)
-char_u	*arg;
-exarg_T	*eap;
 {
 switch (*arg)
 {
 case 'S':
 case Ctrl_S:
 		break;
 }
 }
 static void
-cmd_with_count(cmd, bufp, bufsize, Prenum)
+cmd_with_count(
-char	*cmd;
+char	*cmd,
-char_u	*bufp;
+char_u	*bufp,
-size_t	bufsize;
+size_t	bufsize,
-long	Prenum;
+long	Prenum)
 {
 size_t	len = STRLEN(cmd);
 STRCPY(bufp, cmd);
 if (Prenum > 0)
 * WSP_HELP: creating the help window, keep layout snapshot
 *
 * return FAIL for failure, OK otherwise
 */
 int
-win_split(size, flags)
+win_split(int size, int flags)
-int		size;
-int		flags;
 {
 /* When the ":tab" modifier was used open a new tab page instead. */
 if (may_open_tabpage() == OK)
 	return OK;
 * When "new_wp" is not NULL: insert this window at the far
 * top/left/right/bottom.
 * return FAIL for failure, OK otherwise
 */
 int
-win_split_ins(size, flags, new_wp, dir)
+win_split_ins(
-int		size;
+int		size,
-int		flags;
+int		flags,
-win_T	*new_wp;
+win_T	*new_wp,
-int		dir;
+int		dir)
 {
 win_T	*wp = new_wp;
 win_T	*oldwin;
 int		new_size = size;
 int		i;
 * The windows will both edit the same buffer.
 * WSP_NEWLOC may be specified in flags to prevent the location list from
 * being copied.
 */
 static void
-win_init(newp, oldp, flags)
+win_init(win_T *newp, win_T *oldp, int flags UNUSED)
-win_T	*newp;
-win_T	*oldp;
-int		 flags UNUSED;
 {
 int		i;
 newp->w_buffer = oldp->w_buffer;
 #ifdef FEAT_SYN_HL
 /*
 * Initialize window "newp" from window "old".
 * Only the essential things are copied.
 */
 static void
-win_init_some(newp, oldp)
+win_init_some(win_T *newp, win_T *oldp)
-win_T	*newp;
-win_T	*oldp;
 {
 /* Use the same argument list. */
 newp->w_alist = oldp->w_alist;
 ++newp->w_alist->al_refcount;
 newp->w_arg_idx = oldp->w_arg_idx;
 #if defined(FEAT_WINDOWS) || defined(PROTO)
 /*
 * Check if "win" is a pointer to an existing window.
 */
 int
-win_valid(win)
+win_valid(win_T *win)
-win_T	*win;
 {
 win_T	*wp;
 if (win == NULL)
 	return FALSE;
 /*
 * Return the number of windows.
 */
 int
-win_count()
+win_count(void)
 {
 win_T	*wp;
 int		count = 0;
 for (wp = firstwin; wp != NULL; wp = wp->w_next)
 * Return actual number of windows on the screen.
 * Must be called when there is just one window, filling the whole screen
 * (excluding the command line).
 */
 int
-make_windows(count, vertical)
+make_windows(
-int		count;
+int		count,
-int		vertical UNUSED;  /* split windows vertically if TRUE */
+int		vertical UNUSED)  /* split windows vertically if TRUE */
 {
 int		maxcount;
 int		todo;
 #ifdef FEAT_VERTSPLIT
 /*
 * Exchange current and next window
 */
 static void
-win_exchange(Prenum)
+win_exchange(long Prenum)
-long	Prenum;
 {
 frame_T	*frp;
 frame_T	*frp2;
 win_T	*wp;
 win_T	*wp2;
 /*
 * rotate windows: if upwards TRUE the second window becomes the first one
 *		   if upwards FALSE the first window becomes the second one
 */
 static void
-win_rotate(upwards, count)
+win_rotate(int upwards, int count)
-int		upwards;
-int		count;
 {
 win_T	*wp1;
 win_T	*wp2;
 frame_T	*frp;
 int		n;
 /*
 * Move the current window to the very top/bottom/left/right of the screen.
 */
 static void
-win_totop(size, flags)
+win_totop(int size, int flags)
-int		size;
-int		flags;
 {
 int		dir;
 int		height = curwin->w_height;
 if (lastwin == firstwin)
 /*
 * Move window "win1" to below/right of "win2" and make "win1" the current
 * window.  Only works within the same frame!
 */
 void
-win_move_after(win1, win2)
+win_move_after(win_T *win1, win_T *win2)
-win_T	*win1, *win2;
 {
 int		height;
 /* check if the arguments are reasonable */
 if (win1 == win2)
 * Make all windows the same height.
 * 'next_curwin' will soon be the current window, make sure it has enough
 * rows.
 */
 void
-win_equal(next_curwin, current, dir)
+win_equal(
-win_T	*next_curwin;	/* pointer to current window to be or NULL */
+win_T	*next_curwin,	/* pointer to current window to be or NULL */
-int		current;	/* do only frame with current window */
+int		current,	/* do only frame with current window */
-int		dir;		/* 'v' for vertically, 'h' for horizontally,
+int		dir)		/* 'v' for vertically, 'h' for horizontally,
 				   'b' for both, 0 for using p_ead */
 {
 if (dir == 0)
 #ifdef FEAT_VERTSPLIT
 	dir = *p_ead;
 * equally over contained frames.
 * The window "next_curwin" (if not NULL) should at least get the size from
 * 'winheight' and 'winwidth' if possible.
 */
 static void
-win_equal_rec(next_curwin, current, topfr, dir, col, row, width, height)
+win_equal_rec(
-win_T	*next_curwin;	/* pointer to current window to be or NULL */
+win_T	*next_curwin,	/* pointer to current window to be or NULL */
-int		current;	/* do only frame with current window */
+int		current,	/* do only frame with current window */
-frame_T	*topfr;		/* frame to set size off */
+frame_T	*topfr,		/* frame to set size off */
-int		dir;		/* 'v', 'h' or 'b', see win_equal() */
+int		dir,		/* 'v', 'h' or 'b', see win_equal() */
-int		col;		/* horizontal position for frame */
+int		col,		/* horizontal position for frame */
-int		row;		/* vertical position for frame */
+int		row,		/* vertical position for frame */
-int		width;		/* new width of frame */
+int		width,		/* new width of frame */
-int		height;		/* new height of frame */
+int		height)		/* new height of frame */
 {
 int		n, m;
 int		extra_sep = 0;
 int		wincount, totwincount = 0;
 frame_T	*fr;
 /*
 * close all windows for buffer 'buf'
 */
 void
-close_windows(buf, keep_curwin)
+close_windows(
-buf_T	*buf;
+buf_T	*buf,
-int		keep_curwin;	    /* don't close "curwin" */
+int		keep_curwin)	    /* don't close "curwin" */
 {
 win_T	*wp;
 tabpage_T   *tp, *nexttp;
 int		h = tabline_height();
 * Return TRUE if the current window is the only window that exists (ignoring
 * "aucmd_win").
 * Returns FALSE if there is a window, possibly in another tab page.
 */
 static int
-last_window()
+last_window(void)
 {
 return (one_window() && first_tabpage->tp_next == NULL);
 }
 /*
 * Return TRUE if there is only one window other than "aucmd_win" in the
 * current tab page.
 */
 int
-one_window()
+one_window(void)
 {
 #ifdef FEAT_AUTOCMD
 win_T	*wp;
 int		seen_one = FALSE;
 /*
 * Close the possibly last window in a tab page.
 * Returns TRUE when the window was closed already.
 */
 static int
-close_last_window_tabpage(win, free_buf, prev_curtab)
+close_last_window_tabpage(
-win_T	*win;
+win_T	*win,
-int		free_buf;
+int		free_buf,
-tabpage_T   *prev_curtab;
+tabpage_T   *prev_curtab)
 {
 if (firstwin == lastwin)
 {
 #ifdef FEAT_AUTOCMD
 	buf_T	*old_curbuf = curbuf;
 *
 * Called by :quit, :close, :xit, :wq and findtag().
 * Returns FAIL when the window was not closed.
 */
 int
-win_close(win, free_buf)
+win_close(win_T *win, int free_buf)
-win_T	*win;
-int		free_buf;
 {
 win_T	*wp;
 #ifdef FEAT_AUTOCMD
 int		other_buffer = FALSE;
 #endif
 * thus "tp" may become invalid!
 * Caller must check if buffer is hidden and whether the tabline needs to be
 * updated.
 */
 void
-win_close_othertab(win, free_buf, tp)
+win_close_othertab(win_T *win, int free_buf, tabpage_T *tp)
-win_T	*win;
-int		free_buf;
-tabpage_T	*tp;
 {
 win_T	*wp;
 int		dir;
 tabpage_T   *ptp = NULL;
 int		free_tp = FALSE;
 /*
 * Free the memory used for a window.
 * Returns a pointer to the window that got the freed up space.
 */
 static win_T *
-win_free_mem(win, dirp, tp)
+win_free_mem(
-win_T	*win;
+win_T	*win,
-int		*dirp;		/* set to 'v' or 'h' for direction if 'ea' */
+int		*dirp,		/* set to 'v' or 'h' for direction if 'ea' */
-tabpage_T	*tp;		/* tab page "win" is in, NULL for current */
+tabpage_T	*tp)		/* tab page "win" is in, NULL for current */
 {
 frame_T	*frp;
 win_T	*wp;
 /* Remove the window and its frame from the tree of frames. */
 return wp;
 }
 #if defined(EXITFREE) || defined(PROTO)
 void
-win_free_all()
+win_free_all(void)
 {
 int		dummy;
 # ifdef FEAT_WINDOWS
 while (first_tabpage->tp_next != NULL)
 /*
 * Remove a window and its frame from the tree of frames.
 * Returns a pointer to the window that got the freed up space.
 */
 win_T *
-winframe_remove(win, dirp, tp)
+winframe_remove(
-win_T	*win;
+win_T	*win,
-int		*dirp UNUSED;	/* set to 'v' or 'h' for direction if 'ea' */
+int		*dirp UNUSED,	/* set to 'v' or 'h' for direction if 'ea' */
-tabpage_T	*tp;		/* tab page "win" is in, NULL for current */
+tabpage_T	*tp)		/* tab page "win" is in, NULL for current */
 {
 frame_T	*frp, *frp2, *frp3;
 frame_T	*frp_close = win->w_frame;
 win_T	*wp;
 * if 'nosplitbelow'/'nosplitleft' the space goes to the window below/right.
 * This makes opening a window and closing it immediately keep the same window
 * layout.
 */
 static frame_T *
-win_altframe(win, tp)
+win_altframe(
-win_T	*win;
+win_T	*win,
-tabpage_T	*tp;		/* tab page "win" is in, NULL for current */
+tabpage_T	*tp)		/* tab page "win" is in, NULL for current */
 {
 frame_T	*frp;
 int		b;
 if (tp == NULL ? firstwin == lastwin : tp->tp_firstwin == tp->tp_lastwin)
 /*
 * Return the tabpage that will be used if the current one is closed.
 */
 static tabpage_T *
-alt_tabpage()
+alt_tabpage(void)
 {
 tabpage_T	*tp;
 /* Use the next tab page if possible. */
 if (curtab->tp_next != NULL)
 /*
 * Find the left-upper window in frame "frp".
 */
 static win_T *
-frame2win(frp)
+frame2win(frame_T *frp)
-frame_T	*frp;
 {
 while (frp->fr_win == NULL)
 	frp = frp->fr_child;
 return frp->fr_win;
 }
 /*
 * Return TRUE if frame "frp" contains window "wp".
 */
 static int
-frame_has_win(frp, wp)
+frame_has_win(frame_T *frp, win_T *wp)
-frame_T	*frp;
-win_T	*wp;
 {
 frame_T	*p;
 if (frp->fr_layout == FR_LEAF)
 	return frp->fr_win == wp;
 /*
 * Set a new height for a frame.  Recursively sets the height for contained
 * frames and windows.  Caller must take care of positions.
 */
 static void
-frame_new_height(topfrp, height, topfirst, wfh)
+frame_new_height(
-frame_T	*topfrp;
+frame_T	*topfrp,
-int		height;
+int		height,
-int		topfirst;	/* resize topmost contained frame first */
+int		topfirst,	/* resize topmost contained frame first */
-int		wfh;		/* obey 'winfixheight' when there is a choice;
+int		wfh)		/* obey 'winfixheight' when there is a choice;
 				   may cause the height not to be set */
 {
 frame_T	*frp;
 int		extra_lines;
 int		h;
 /*
 * Return TRUE if height of frame "frp" should not be changed because of
 * the 'winfixheight' option.
 */
 static int
-frame_fixed_height(frp)
+frame_fixed_height(frame_T *frp)
-frame_T	*frp;
 {
 /* frame with one window: fixed height if 'winfixheight' set. */
 if (frp->fr_win != NULL)
 	return frp->fr_win->w_p_wfh;
 /*
 * Return TRUE if width of frame "frp" should not be changed because of
 * the 'winfixwidth' option.
 */
 static int
-frame_fixed_width(frp)
+frame_fixed_width(frame_T *frp)
-frame_T	*frp;
 {
 /* frame with one window: fixed width if 'winfixwidth' set. */
 if (frp->fr_win != NULL)
 	return frp->fr_win->w_p_wfw;
 /*
 * Add a status line to windows at the bottom of "frp".
 * Note: Does not check if there is room!
 */
 static void
-frame_add_statusline(frp)
+frame_add_statusline(frame_T *frp)
-frame_T	*frp;
 {
 win_T	*wp;
 if (frp->fr_layout == FR_LEAF)
 {
 /*
 * Set width of a frame.  Handles recursively going through contained frames.
 * May remove separator line for windows at the right side (for win_close()).
 */
 static void
-frame_new_width(topfrp, width, leftfirst, wfw)
+frame_new_width(
-frame_T	*topfrp;
+frame_T	*topfrp,
-int		width;
+int		width,
-int		leftfirst;	/* resize leftmost contained frame first */
+int		leftfirst,	/* resize leftmost contained frame first */
-int		wfw;		/* obey 'winfixwidth' when there is a choice;
+int		wfw)		/* obey 'winfixwidth' when there is a choice;
 				   may cause the width not to be set */
 {
 frame_T	*frp;
 int		extra_cols;
 int		w;
 /*
 * Add the vertical separator to windows at the right side of "frp".
 * Note: Does not check if there is room!
 */
 static void
-frame_add_vsep(frp)
+frame_add_vsep(frame_T *frp)
-frame_T	*frp;
 {
 win_T	*wp;
 if (frp->fr_layout == FR_LEAF)
 {
 /*
 * Set frame width from the window it contains.
 */
 static void
-frame_fix_width(wp)
+frame_fix_width(win_T *wp)
-win_T	*wp;
 {
 wp->w_frame->fr_width = wp->w_width + wp->w_vsep_width;
 }
 #endif
 /*
 * Set frame height from the window it contains.
 */
 static void
-frame_fix_height(wp)
+frame_fix_height(win_T *wp)
-win_T	*wp;
 {
 wp->w_frame->fr_height = wp->w_height + wp->w_status_height;
 }
 /*
 * When "next_curwin" isn't NULL, use p_wh for this window.
 * When "next_curwin" is NOWIN, don't use at least one line for the current
 * window.
 */
 static int
-frame_minheight(topfrp, next_curwin)
+frame_minheight(frame_T *topfrp, win_T *next_curwin)
-frame_T	*topfrp;
-win_T	*next_curwin;
 {
 frame_T	*frp;
 int		m;
 #ifdef FEAT_VERTSPLIT
 int		n;
 * When "next_curwin" isn't NULL, use p_wiw for this window.
 * When "next_curwin" is NOWIN, don't use at least one column for the current
 * window.
 */
 static int
-frame_minwidth(topfrp, next_curwin)
+frame_minwidth(
-frame_T	*topfrp;
+frame_T	*topfrp,
-win_T	*next_curwin;	/* use p_wh and p_wiw for next_curwin */
+win_T	*next_curwin)	/* use p_wh and p_wiw for next_curwin */
 {
 frame_T	*frp;
 int		m, n;
 if (topfrp->fr_win != NULL)
 * used and the buffer was modified.
 *
 * Used by ":bdel" and ":only".
 */
 void
-close_others(message, forceit)
+close_others(
-int		message;
+int		message,
-int		forceit;	    /* always hide all other windows */
+int		forceit)	    /* always hide all other windows */
 {
 win_T	*wp;
 win_T	*nextwp;
 int		r;
 /*
 * Init the current window "curwin".
 * Called when a new file is being edited.
 */
 void
-curwin_init()
+curwin_init(void)
 {
 win_init_empty(curwin);
 }
 void
-win_init_empty(wp)
+win_init_empty(win_T *wp)
-win_T *wp;
 {
 redraw_win_later(wp, NOT_VALID);
 wp->w_lines_valid = 0;
 wp->w_cursor.lnum = 1;
 wp->w_curswant = wp->w_cursor.col = 0;
 * Allocate the first window and put an empty buffer in it.
 * Called from main().
 * Return FAIL when something goes wrong (out of memory).
 */
 int
-win_alloc_first()
+win_alloc_first(void)
 {
 if (win_alloc_firstwin(NULL) == FAIL)
 	return FAIL;
 #ifdef FEAT_WINDOWS
 /*
 * Init "aucmd_win".  This can only be done after the first
 * window is fully initialized, thus it can't be in win_alloc_first().
 */
 void
-win_alloc_aucmd_win()
+win_alloc_aucmd_win(void)
 {
 aucmd_win = win_alloc(NULL, TRUE);
 if (aucmd_win != NULL)
 {
 	win_init_some(aucmd_win, curwin);
 * When "oldwin" is not NULL copy info from it to the new window (only with
 * FEAT_WINDOWS).
 * Return FAIL when something goes wrong (out of memory).
 */
 static int
-win_alloc_firstwin(oldwin)
+win_alloc_firstwin(win_T *oldwin)
-win_T	*oldwin;
 {
 curwin = win_alloc(NULL, FALSE);
 if (oldwin == NULL)
 {
 	/* Very first window, need to create an empty buffer for it and
 /*
 * Initialize the window and frame size to the maximum.
 */
 void
-win_init_size()
+win_init_size(void)
 {
 firstwin->w_height = ROWS_AVAIL;
 topframe->fr_height = ROWS_AVAIL;
 #ifdef FEAT_VERTSPLIT
 firstwin->w_width = Columns;
 /*
 * Allocate a new tabpage_T and init the values.
 * Returns NULL when out of memory.
 */
 static tabpage_T *
-alloc_tabpage()
+alloc_tabpage(void)
 {
 tabpage_T	*tp;
 # ifdef FEAT_GUI
 int		i;
 # endif
 return tp;
 }
 void
-free_tabpage(tp)
+free_tabpage(tabpage_T *tp)
-tabpage_T	*tp;
 {
 int idx;
 # ifdef FEAT_DIFF
 diff_clear(tp);
 * When "after" is 0 put it just after the current Tab page.
 * Otherwise put it just before tab page "after".
 * Return FAIL or OK.
 */
 int
-win_new_tabpage(after)
+win_new_tabpage(int after)
-int		after;
 {
 tabpage_T	*tp = curtab;
 tabpage_T	*newtp;
 int		n;
 * Open a new tab page if ":tab cmd" was used.  It will edit the same buffer,
 * like with ":split".
 * Returns OK if a new tab page was created, FAIL otherwise.
 */
 int
-may_open_tabpage()
+may_open_tabpage(void)
 {
 int		n = (cmdmod.tab == 0) ? postponed_split_tab : cmdmod.tab;
 if (n != 0)
 {
 /*
 * Create up to "maxcount" tabpages with empty windows.
 * Returns the number of resulting tab pages.
 */
 int
-make_tabpages(maxcount)
+make_tabpages(int maxcount)
-int		maxcount;
 {
 int		count = maxcount;
 int		todo;
 /* Limit to 'tabpagemax' tabs. */
 /*
 * Return TRUE when "tpc" points to a valid tab page.
 */
 int
-valid_tabpage(tpc)
+valid_tabpage(tabpage_T *tpc)
-tabpage_T	*tpc;
 {
 tabpage_T	*tp;
 for (tp = first_tabpage; tp != NULL; tp = tp->tp_next)
 	if (tp == tpc)
 /*
 * Find tab page "n" (first one is 1).  Returns NULL when not found.
 */
 tabpage_T *
-find_tabpage(n)
+find_tabpage(int n)
-int		n;
 {
 tabpage_T	*tp;
 int		i = 1;
 for (tp = first_tabpage; tp != NULL && i != n; tp = tp->tp_next)
 /*
 * Get index of tab page "tp".  First one has index 1.
 * When not found returns number of tab pages plus one.
 */
 int
-tabpage_index(ftp)
+tabpage_index(tabpage_T *ftp)
-tabpage_T	*ftp;
 {
 int		i = 1;
 tabpage_T	*tp;
 for (tp = first_tabpage; tp != NULL && tp != ftp; tp = tp->tp_next)
 * When autocommands change "curtab" we don't leave the tab page and return
 * FAIL.
 * Careful: When OK is returned need to get a new tab page very very soon!
 */
 static int
-leave_tabpage(new_curbuf, trigger_leave_autocmds)
+leave_tabpage(
-buf_T	*new_curbuf UNUSED;    /* what is going to be the new curbuf,
+buf_T	*new_curbuf UNUSED,    /* what is going to be the new curbuf,
 				       NULL if unknown */
-int		trigger_leave_autocmds UNUSED;
+int		trigger_leave_autocmds UNUSED)
 {
 tabpage_T	*tp = curtab;
 reset_VIsual_and_resel();	/* stop Visual mode */
 #ifdef FEAT_AUTOCMD
 * Only to be used after leave_tabpage() or freeing the current tab page.
 * Only trigger *Enter autocommands when trigger_enter_autocmds is TRUE.
 * Only trigger *Leave autocommands when trigger_leave_autocmds is TRUE.
 */
 static void
-enter_tabpage(tp, old_curbuf, trigger_enter_autocmds, trigger_leave_autocmds)
+enter_tabpage(
-tabpage_T	*tp;
+tabpage_T	*tp,
-buf_T	*old_curbuf UNUSED;
+buf_T	*old_curbuf UNUSED,
-int		trigger_enter_autocmds UNUSED;
+int		trigger_enter_autocmds UNUSED,
-int		trigger_leave_autocmds UNUSED;
+int		trigger_leave_autocmds UNUSED)
 {
 int		old_off = tp->tp_firstwin->w_winrow;
 win_T	*next_prevwin = tp->tp_prevwin;
 curtab = tp;
 /*
 * Go to tab page "n".  For ":tab N" and "Ngt".
 * When "n" is 9999 go to the last tab page.
 */
 void
-goto_tabpage(n)
+goto_tabpage(int n)
-int	    n;
 {
 tabpage_T	*tp;
 tabpage_T	*ttp;
 int		i;
 * Only trigger *Enter autocommands when trigger_enter_autocmds is TRUE.
 * Only trigger *Leave autocommands when trigger_leave_autocmds is TRUE.
 * Note: doesn't update the GUI tab.
 */
 void
-goto_tabpage_tp(tp, trigger_enter_autocmds, trigger_leave_autocmds)
+goto_tabpage_tp(
-tabpage_T	*tp;
+tabpage_T	*tp,
-int		trigger_enter_autocmds;
+int		trigger_enter_autocmds,
-int		trigger_leave_autocmds;
+int		trigger_leave_autocmds)
 {
 /* Don't repeat a message in another tab page. */
 set_keep_msg(NULL, 0);
 if (tp != curtab && leave_tabpage(tp->tp_curwin->w_buffer,
 /*
 * Enter window "wp" in tab page "tp".
 * Also updates the GUI tab.
 */
 void
-goto_tabpage_win(tp, wp)
+goto_tabpage_win(tabpage_T *tp, win_T *wp)
-tabpage_T	*tp;
-win_T	*wp;
 {
 goto_tabpage_tp(tp, TRUE, TRUE);
 if (curtab == tp && win_valid(wp))
 {
 	win_enter(wp, TRUE);
 /*
 * Move the current tab page to after tab page "nr".
 */
 void
-tabpage_move(nr)
+tabpage_move(int nr)
-int		nr;
 {
 int		n = 1;
 tabpage_T	*tp, *tp_dst;
 if (first_tabpage->tp_next == NULL)
 * changing windows so we can yank the selection into the '*' register.
 * When jumping to another window on the same buffer, adjust its cursor
 * position to keep the same Visual area.
 */
 void
-win_goto(wp)
+win_goto(win_T *wp)
-win_T	*wp;
 {
 #ifdef FEAT_CONCEAL
 win_T	*owp = curwin;
 #endif
 #if defined(FEAT_PERL) || defined(PROTO)
 /*
 * Find window number "winnr" (counting top to bottom).
 */
 win_T *
-win_find_nr(winnr)
+win_find_nr(int winnr)
-int		winnr;
 {
 win_T	*wp;
 # ifdef FEAT_WINDOWS
 for (wp = firstwin; wp != NULL; wp = wp->w_next)
 	|| defined(PROTO)
 /*
 * Find the tabpage for window "win".
 */
 tabpage_T *
-win_find_tabpage(win)
+win_find_tabpage(win_T *win)
-win_T	*win;
 {
 win_T	*wp;
 tabpage_T	*tp;
 for (tp = first_tabpage; tp != NULL; tp = tp->tp_next)
 #ifdef FEAT_VERTSPLIT
 /*
 * Move to window above or below "count" times.
 */
 static void
-win_goto_ver(up, count)
+win_goto_ver(
-int		up;		/* TRUE to go to win above */
+int		up,		/* TRUE to go to win above */
-long	count;
+long	count)
 {
 frame_T	*fr;
 frame_T	*nfr;
 frame_T	*foundfr;
 /*
 * Move to left or right window.
 */
 static void
-win_goto_hor(left, count)
+win_goto_hor(
-int		left;		/* TRUE to go to left win */
+int		left,		/* TRUE to go to left win */
-long	count;
+long	count)
 {
 frame_T	*fr;
 frame_T	*nfr;
 frame_T	*foundfr;
 /*
 * Make window "wp" the current window.
 */
 void
-win_enter(wp, undo_sync)
+win_enter(win_T *wp, int undo_sync)
-win_T	*wp;
-int		undo_sync;
 {
 win_enter_ext(wp, undo_sync, FALSE, TRUE, TRUE);
 }
 /*
 * Make window wp the current window.
 * Can be called with "curwin_invalid" TRUE, which means that curwin has just
 * been closed and isn't valid.
 */
 static void
-win_enter_ext(wp, undo_sync, curwin_invalid, trigger_enter_autocmds, trigger_leave_autocmds)
+win_enter_ext(
-win_T	*wp;
+win_T	*wp,
-int		undo_sync;
+int		undo_sync,
-int		curwin_invalid;
+int		curwin_invalid,
-int		trigger_enter_autocmds UNUSED;
+int		trigger_enter_autocmds UNUSED,
-int		trigger_leave_autocmds UNUSED;
+int		trigger_leave_autocmds UNUSED)
 {
 #ifdef FEAT_AUTOCMD
 int		other_buffer = FALSE;
 #endif
 /*
 * Jump to the first open window that contains buffer "buf", if one exists.
 * Returns a pointer to the window found, otherwise NULL.
 */
 win_T *
-buf_jump_open_win(buf)
+buf_jump_open_win(buf_T *buf)
-buf_T	*buf;
 {
 win_T	*wp = NULL;
 if (curwin->w_buffer == buf)
 	wp = curwin;
 * Jump to the first open window in any tab page that contains buffer "buf",
 * if one exists.
 * Returns a pointer to the window found, otherwise NULL.
 */
 win_T *
-buf_jump_open_tab(buf)
+buf_jump_open_tab(buf_T *buf)
-buf_T	*buf;
 {
 win_T	*wp = buf_jump_open_win(buf);
 # ifdef FEAT_WINDOWS
 tabpage_T	*tp;
 /*
 * Allocate a window structure and link it in the window list when "hidden" is
 * FALSE.
 */
 static win_T *
-win_alloc(after, hidden)
+win_alloc(win_T *after UNUSED, int hidden UNUSED)
-win_T	*after UNUSED;
-int		hidden UNUSED;
 {
 win_T	*new_wp;
 /*
 * allocate window structure and linesizes arrays
 /*
 * Remove window 'wp' from the window list and free the structure.
 */
 static void
-win_free(wp, tp)
+win_free(
-win_T	*wp;
+win_T	*wp,
-tabpage_T	*tp;		/* tab page "win" is in, NULL for current */
+tabpage_T	*tp)		/* tab page "win" is in, NULL for current */
 {
 int		i;
 buf_T	*buf;
 wininfo_T	*wip;
 /*
 * Append window "wp" in the window list after window "after".
 */
 void
-win_append(after, wp)
+win_append(win_T *after, win_T *wp)
-win_T	*after, *wp;
 {
 win_T	*before;
 if (after == NULL)	    /* after NULL is in front of the first */
 	before = firstwin;
 /*
 * Remove a window from the window list.
 */
 void
-win_remove(wp, tp)
+win_remove(
-win_T	*wp;
+win_T	*wp,
-tabpage_T	*tp;		/* tab page "win" is in, NULL for current */
+tabpage_T	*tp)		/* tab page "win" is in, NULL for current */
 {
 if (wp->w_prev != NULL)
 	wp->w_prev->w_next = wp->w_next;
 else if (tp == NULL)
 	firstwin = wp->w_next;
 /*
 * Append frame "frp" in a frame list after frame "after".
 */
 static void
-frame_append(after, frp)
+frame_append(frame_T *after, frame_T *frp)
-frame_T	*after, *frp;
 {
 frp->fr_next = after->fr_next;
 after->fr_next = frp;
 if (frp->fr_next != NULL)
 	frp->fr_next->fr_prev = frp;
 /*
 * Insert frame "frp" in a frame list before frame "before".
 */
 static void
-frame_insert(before, frp)
+frame_insert(frame_T *before, frame_T *frp)
-frame_T	*before, *frp;
 {
 frp->fr_next = before;
 frp->fr_prev = before->fr_prev;
 before->fr_prev = frp;
 if (frp->fr_prev != NULL)
 /*
 * Remove a frame from a frame list.
 */
 static void
-frame_remove(frp)
+frame_remove(frame_T *frp)
-frame_T	*frp;
 {
 if (frp->fr_prev != NULL)
 	frp->fr_prev->fr_next = frp->fr_next;
 else
 	frp->fr_parent->fr_child = frp->fr_next;
 /*
 * Allocate w_lines[] for window "wp".
 * Return FAIL for failure, OK for success.
 */
 int
-win_alloc_lines(wp)
+win_alloc_lines(win_T *wp)
-win_T	*wp;
 {
 wp->w_lines_valid = 0;
 wp->w_lines = (wline_T *)alloc_clear((unsigned)(Rows * sizeof(wline_T)));
 if (wp->w_lines == NULL)
 	return FAIL;
 /*
 * free lsize arrays for a window
 */
 void
-win_free_lsize(wp)
+win_free_lsize(win_T *wp)
-win_T	*wp;
 {
 /* TODO: why would wp be NULL here? */
 if (wp != NULL)
 {
 	vim_free(wp->w_lines);
 /*
 * Called from win_new_shellsize() after Rows changed.
 * This only does the current tab page, others must be done when made active.
 */
 void
-shell_new_rows()
+shell_new_rows(void)
 {
 int		h = (int)ROWS_AVAIL;
 if (firstwin == NULL)	/* not initialized yet */
 	return;
 #if defined(FEAT_VERTSPLIT) || defined(PROTO)
 /*
 * Called from win_new_shellsize() after Columns changed.
 */
 void
-shell_new_columns()
+shell_new_columns(void)
 {
 if (firstwin == NULL)	/* not initialized yet */
 	return;
 /* First try setting the widths of windows with 'winfixwidth'.  If that
 #if defined(FEAT_CMDWIN) || defined(PROTO)
 /*
 * Save the size of all windows in "gap".
 */
 void
-win_size_save(gap)
+win_size_save(garray_T *gap)
-garray_T	*gap;
 {
 win_T	*wp;
 ga_init2(gap, (int)sizeof(int), 1);
 /*
 * Restore window sizes, but only if the number of windows is still the same.
 * Does not free the growarray.
 */
 void
-win_size_restore(gap)
+win_size_restore(garray_T *gap)
-garray_T	*gap;
 {
 win_T	*wp;
 int		i, j;
 if (win_count() * 2 == gap->ga_len)
 * Update the position for all windows, using the width and height of the
 * frames.
 * Returns the row just after the last window.
 */
 int
-win_comp_pos()
+win_comp_pos(void)
 {
 int		row = tabline_height();
 int		col = 0;
 frame_comp_pos(topframe, &row, &col);
 * height of the frames.
 * "*row" and "*col" are the top-left position of the frame.  They are updated
 * to the bottom-right position plus one.
 */
 static void
-frame_comp_pos(topfrp, row, col)
+frame_comp_pos(frame_T *topfrp, int *row, int *col)
-frame_T	*topfrp;
-int		*row;
-int		*col;
 {
 win_T	*wp;
 frame_T	*frp;
 #ifdef FEAT_VERTSPLIT
 int		startcol;
 /*
 * Set current window height and take care of repositioning other windows to
 * fit around it.
 */
 void
-win_setheight(height)
+win_setheight(int height)
-int		height;
 {
 win_setheight_win(height, curwin);
 }
 /*
 * Set the window height of window "win" and take care of repositioning other
 * windows to fit around it.
 */
 void
-win_setheight_win(height, win)
+win_setheight_win(int height, win_T *win)
-int		height;
-win_T	*win;
 {
 int		row;
 if (win == curwin)
 {
 * If the frame is part of a FR_ROW frame, all frames must be resized as well.
 * Check for the minimal height of the FR_ROW frame.
 * At the top level we can also use change the command line height.
 */
 static void
-frame_setheight(curfrp, height)
+frame_setheight(frame_T *curfrp, int height)
-frame_T	*curfrp;
-int		height;
 {
 int		room;		/* total number of lines available */
 int		take;		/* number of lines taken from other windows */
 int		room_cmdline;	/* lines available from cmdline */
 int		run;
 /*
 * Set current window width and take care of repositioning other windows to
 * fit around it.
 */
 void
-win_setwidth(width)
+win_setwidth(int width)
-int		width;
 {
 win_setwidth_win(width, curwin);
 }
 void
-win_setwidth_win(width, wp)
+win_setwidth_win(int width, win_T *wp)
-int		width;
-win_T	*wp;
 {
 /* Always keep current window at least one column wide, even when
 * 'winminwidth' is zero. */
 if (wp == curwin)
 {
 * are in the same FR_ROW frame.
 *
 * Strategy is similar to frame_setheight().
 */
 static void
-frame_setwidth(curfrp, width)
+frame_setwidth(frame_T *curfrp, int width)
-frame_T	*curfrp;
-int		width;
 {
 int		room;		/* total number of lines available */
 int		take;		/* number of lines taken from other windows */
 int		run;
 frame_T	*frp;
 /*
 * Check 'winminheight' for a valid value.
 */
 void
-win_setminheight()
+win_setminheight(void)
 {
 int		room;
 int		first = TRUE;
 win_T	*wp;
 /*
 * Status line of dragwin is dragged "offset" lines down (negative is up).
 */
 void
-win_drag_status_line(dragwin, offset)
+win_drag_status_line(win_T *dragwin, int offset)
-win_T	*dragwin;
-int		offset;
 {
 frame_T	*curfr;
 frame_T	*fr;
 int		room;
 int		row;
 # if defined(FEAT_VERTSPLIT) || defined(PROTO)
 /*
 * Separator line of dragwin is dragged "offset" lines right (negative is left).
 */
 void
-win_drag_vsep_line(dragwin, offset)
+win_drag_vsep_line(win_T *dragwin, int offset)
-win_T	*dragwin;
-int		offset;
 {
 frame_T	*curfr;
 frame_T	*fr;
 int		room;
 int		left;	/* if TRUE, drag separator line left, otherwise right */
 /*
 * Set wp->w_fraction for the current w_wrow and w_height.
 */
 void
-set_fraction(wp)
+set_fraction(win_T *wp)
-win_T	*wp;
 {
 wp->w_fraction = ((long)wp->w_wrow * FRACTION_MULT
 				    + wp->w_height / 2) / (long)wp->w_height;
 }
 * Set the height of a window.
 * This takes care of the things inside the window, not what happens to the
 * window position, the frame or to other windows.
 */
 void
-win_new_height(wp, height)
+win_new_height(win_T *wp, int height)
-win_T	*wp;
-int		height;
 {
 linenr_T	lnum;
 int		sline, line_size;
 int		prev_height = wp->w_height;
 #ifdef FEAT_VERTSPLIT
 /*
 * Set the width of a window.
 */
 void
-win_new_width(wp, width)
+win_new_width(win_T *wp, int width)
-win_T	*wp;
-int		width;
 {
 wp->w_width = width;
 wp->w_lines_valid = 0;
 changed_line_abv_curs_win(wp);
 invalidate_botline_win(wp);
 wp->w_redr_status = TRUE;
 }
 #endif
 void
-win_comp_scroll(wp)
+win_comp_scroll(win_T *wp)
-win_T	*wp;
 {
 wp->w_p_scr = ((unsigned)wp->w_height >> 1);
 if (wp->w_p_scr == 0)
 	wp->w_p_scr = 1;
 }
 /*
 * command_height: called whenever p_ch has been changed
 */
 void
-command_height()
+command_height(void)
 {
 #ifdef FEAT_WINDOWS
 int		h;
 frame_T	*frp;
 int		old_p_ch = curtab->tp_ch_used;
 /*
 * Resize frame "frp" to be "n" lines higher (negative for less high).
 * Also resize the frames it is contained in.
 */
 static void
-frame_add_height(frp, n)
+frame_add_height(frame_T *frp, int n)
-frame_T	*frp;
-int		n;
 {
 frame_new_height(frp, frp->fr_height + n, FALSE, FALSE);
 for (;;)
 {
 	frp = frp->fr_parent;
 /*
 * Add or remove a status line for the bottom window(s), according to the
 * value of 'laststatus'.
 */
 void
-last_status(morewin)
+last_status(
-int		morewin;	/* pretend there are two or more windows */
+int		morewin)	/* pretend there are two or more windows */
 {
 /* Don't make a difference between horizontal or vertical split. */
 last_status_rec(topframe, (p_ls == 2
 			  || (p_ls == 1 && (morewin || lastwin != firstwin))));
 }
 static void
-last_status_rec(fr, statusline)
+last_status_rec(frame_T *fr, int statusline)
-frame_T	*fr;
-int		statusline;
 {
 frame_T	*fp;
 win_T	*wp;
 if (fr->fr_layout == FR_LEAF)
 /*
 * Return the number of lines used by the tab page line.
 */
 int
-tabline_height()
+tabline_height(void)
 {
 #ifdef FEAT_GUI_TABLINE
 /* When the GUI has the tabline then this always returns zero. */
 if (gui_use_tabline())
 	return 0;
 * Get the file name at the cursor.
 * If Visual mode is active, use the selected text if it's in one line.
 * Returns the name in allocated memory, NULL for failure.
 */
 char_u *
-grab_file_name(count, file_lnum)
+grab_file_name(long count, linenr_T *file_lnum)
-long	count;
-linenr_T	*file_lnum;
 {
 int options = FNAME_MESS|FNAME_EXP|FNAME_REL|FNAME_UNESC;
 if (VIsual_active)
 {
 * FNAME_EXP	    expand to path
 * FNAME_HYP	    check for hypertext link
 * FNAME_INCL	    apply "includeexpr"
 */
 char_u *
-file_name_at_cursor(options, count, file_lnum)
+file_name_at_cursor(int options, long count, linenr_T *file_lnum)
-int		options;
-long	count;
-linenr_T	*file_lnum;
 {
 return file_name_in_line(ml_get_curline(),
 		      curwin->w_cursor.col, options, count, curbuf->b_ffname,
 		      file_lnum);
 }
 /*
 * Return the name of the file under or after ptr[col].
 * Otherwise like file_name_at_cursor().
 */
 char_u *
-file_name_in_line(line, col, options, count, rel_fname, file_lnum)
+file_name_in_line(
-char_u	*line;
+char_u	*line,
-int		col;
+int		col,
-int		options;
+int		options,
-long	count;
+long	count,
-char_u	*rel_fname;	/* file we are searching relative to */
+char_u	*rel_fname,	/* file we are searching relative to */
-linenr_T	*file_lnum;	/* line number after the file name */
+linenr_T	*file_lnum)	/* line number after the file name */
 {
 char_u	*ptr;
 int		len;
 /*
 # if defined(FEAT_FIND_ID) && defined(FEAT_EVAL)
 static char_u *eval_includeexpr(char_u *ptr, int len);
 static char_u *
-eval_includeexpr(ptr, len)
+eval_includeexpr(char_u *ptr, int len)
-char_u	*ptr;
-int		len;
 {
 char_u	*res;
 set_vim_var_string(VV_FNAME, ptr, len);
 res = eval_to_string_safe(curbuf->b_p_inex, NULL,
 /*
 * Return the name of the file ptr[len] in 'path'.
 * Otherwise like file_name_at_cursor().
 */
 char_u *
-find_file_name_in_path(ptr, len, options, count, rel_fname)
+find_file_name_in_path(
-char_u	*ptr;
+char_u	*ptr,
-int		len;
+int		len,
-int		options;
+int		options,
-long	count;
+long	count,
-char_u	*rel_fname;	/* file we are searching relative to */
+char_u	*rel_fname)	/* file we are searching relative to */
 {
 char_u	*file_name;
 int		c;
 # if defined(FEAT_FIND_ID) && defined(FEAT_EVAL)
 char_u	*tofree = NULL;
 * Check if the "://" of a URL is at the pointer, return URL_SLASH.
 * Also check for ":\\", which MS Internet Explorer accepts, return
 * URL_BACKSLASH.
 */
 static int
-path_is_url(p)
+path_is_url(char_u *p)
-char_u  *p;
 {
 if (STRNCMP(p, "://", (size_t)3) == 0)
 	return URL_SLASH;
 else if (STRNCMP(p, ":\\\\", (size_t)3) == 0)
 	return URL_BACKSLASH;
 * Check if "fname" starts with "name://".  Return URL_SLASH if it does.
 * Return URL_BACKSLASH for "name:\\".
 * Return zero otherwise.
 */
 int
-path_with_url(fname)
+path_with_url(char_u *fname)
-char_u *fname;
 {
 char_u *p;
 for (p = fname; isalpha(*p); ++p)
 	;
 /*
 * Return TRUE if "name" is a full (absolute) path name or URL.
 */
 int
-vim_isAbsName(name)
+vim_isAbsName(char_u *name)
-char_u	*name;
 {
 return (path_with_url(name) != 0 || mch_isFullName(name));
 }
 /*
 * Get absolute file name into buffer "buf[len]".
 *
 * return FAIL for failure, OK otherwise
 */
 int
-vim_FullName(fname, buf, len, force)
+vim_FullName(
-char_u	*fname, *buf;
+char_u	*fname,
-int		len;
+char_u	*buf,
-int		force;	    /* force expansion even when already absolute */
+int		len,
+int		force)	    /* force expansion even when already absolute */
 {
 int		retval = OK;
 int		url;
 *buf = NUL;
 /*
 * Return the minimal number of rows that is needed on the screen to display
 * the current number of windows.
 */
 int
-min_rows()
+min_rows(void)
 {
 int		total;
 #ifdef FEAT_WINDOWS
 tabpage_T	*tp;
 int		n;
 * Return TRUE if there is only one window (in the current tab page), not
 * counting a help or preview window, unless it is the current window.
 * Does not count "aucmd_win".
 */
 int
-only_one_window()
+only_one_window(void)
 {
 #ifdef FEAT_WINDOWS
 int		count = 0;
 win_T	*wp;
 * Correct the cursor line number in other windows.  Used after changing the
 * current buffer, and before applying autocommands.
 * When "do_curwin" is TRUE, also check current window.
 */
 void
-check_lnums(do_curwin)
+check_lnums(int do_curwin)
-int		do_curwin;
 {
 win_T	*wp;
 #ifdef FEAT_WINDOWS
 tabpage_T	*tp;
 /*
 * Create a snapshot of the current frame sizes.
 */
 void
-make_snapshot(idx)
+make_snapshot(int idx)
-int idx;
 {
 clear_snapshot(curtab, idx);
 make_snapshot_rec(topframe, &curtab->tp_snapshot[idx]);
 }
 static void
-make_snapshot_rec(fr, frp)
+make_snapshot_rec(frame_T *fr, frame_T **frp)
-frame_T	*fr;
-frame_T	**frp;
 {
 *frp = (frame_T *)alloc_clear((unsigned)sizeof(frame_T));
 if (*frp == NULL)
 	return;
 (*frp)->fr_layout = fr->fr_layout;
 /*
 * Remove any existing snapshot.
 */
 static void
-clear_snapshot(tp, idx)
+clear_snapshot(tabpage_T *tp, int idx)
-tabpage_T	*tp;
-int		idx;
 {
 clear_snapshot_rec(tp->tp_snapshot[idx]);
 tp->tp_snapshot[idx] = NULL;
 }
 static void
-clear_snapshot_rec(fr)
+clear_snapshot_rec(frame_T *fr)
-frame_T	*fr;
 {
 if (fr != NULL)
 {
 	clear_snapshot_rec(fr->fr_next);
 	clear_snapshot_rec(fr->fr_child);
 * Restore a previously created snapshot, if there is any.
 * This is only done if the screen size didn't change and the window layout is
 * still the same.
 */
 void
-restore_snapshot(idx, close_curwin)
+restore_snapshot(
-int		idx;
+int		idx,
-int		close_curwin;	    /* closing current window */
+int		close_curwin)	    /* closing current window */
 {
 win_T	*wp;
 if (curtab->tp_snapshot[idx] != NULL
 # ifdef FEAT_VERTSPLIT
 /*
 * Check if frames "sn" and "fr" have the same layout, same following frames
 * and same children.
 */
 static int
-check_snapshot_rec(sn, fr)
+check_snapshot_rec(frame_T *sn, frame_T *fr)
-frame_T	*sn;
-frame_T	*fr;
 {
 if (sn->fr_layout != fr->fr_layout
 	    || (sn->fr_next == NULL) != (fr->fr_next == NULL)
 	    || (sn->fr_child == NULL) != (fr->fr_child == NULL)
 	    || (sn->fr_next != NULL
 * Copy the size of snapshot frame "sn" to frame "fr".  Do the same for all
 * following frames and children.
 * Returns a pointer to the old current window, or NULL.
 */
 static win_T *
-restore_snapshot_rec(sn, fr)
+restore_snapshot_rec(frame_T *sn, frame_T *fr)
-frame_T	*sn;
-frame_T	*fr;
 {
 win_T	*wp = NULL;
 win_T	*wp2;
 fr->fr_height = sn->fr_height;
 * When "no_display" is TRUE the display won't be affected, no redraw is
 * triggered, another tabpage access is limited.
 * Returns FAIL if switching to "win" failed.
 */
 int
-switch_win(save_curwin, save_curtab, win, tp, no_display)
+switch_win(
-win_T	**save_curwin UNUSED;
+win_T	**save_curwin UNUSED,
-tabpage_T	**save_curtab UNUSED;
+tabpage_T	**save_curtab UNUSED,
-win_T	*win UNUSED;
+win_T	*win UNUSED,
-tabpage_T	*tp UNUSED;
+tabpage_T	*tp UNUSED,
-int		no_display UNUSED;
+int		no_display UNUSED)
 {
 # ifdef FEAT_AUTOCMD
 block_autocmds();
 # endif
 # ifdef FEAT_WINDOWS
 * Restore current tabpage and window saved by switch_win(), if still valid.
 * When "no_display" is TRUE the display won't be affected, no redraw is
 * triggered.
 */
 void
-restore_win(save_curwin, save_curtab, no_display)
+restore_win(
-win_T	*save_curwin UNUSED;
+win_T	*save_curwin UNUSED,
-tabpage_T	*save_curtab UNUSED;
+tabpage_T	*save_curtab UNUSED,
-int		no_display UNUSED;
+int		no_display UNUSED)
 {
 # ifdef FEAT_WINDOWS
 if (save_curtab != NULL && valid_tabpage(save_curtab))
 {
 	if (no_display)
 /*
 * Make "buf" the current buffer.  restore_buffer() MUST be called to undo.
 * No autocommands will be executed.  Use aucmd_prepbuf() if there are any.
 */
 void
-switch_buffer(save_curbuf, buf)
+switch_buffer(buf_T **save_curbuf, buf_T *buf)
-buf_T *buf;
-buf_T **save_curbuf;
 {
 # ifdef FEAT_AUTOCMD
 block_autocmds();
 # endif
 *save_curbuf = curbuf;
 /*
 * Restore the current buffer after using switch_buffer().
 */
 void
-restore_buffer(save_curbuf)
+restore_buffer(buf_T *save_curbuf)
-buf_T *save_curbuf;
 {
 # ifdef FEAT_AUTOCMD
 unblock_autocmds();
 # endif
 /* Check for valid buffer, just in case. */
 #if (defined(FEAT_GUI) && defined(FEAT_VERTSPLIT)) || defined(PROTO)
 /*
 * Return TRUE if there is any vertically split window.
 */
 int
-win_hasvertsplit()
+win_hasvertsplit(void)
 {
 frame_T	*fr;
 if (topframe->fr_layout == FR_ROW)
 	return TRUE;
 * Optionally, a desired ID 'id' can be specified (greater than or equal to 1).
 * If no particular ID is desired, -1 must be specified for 'id'.
 * Return ID of added match, -1 on failure.
 */
 int
-match_add(wp, grp, pat, prio, id, pos_list, conceal_char)
+match_add(
-win_T	*wp;
+win_T	*wp,
-char_u	*grp;
+char_u	*grp,
-char_u	*pat;
+char_u	*pat,
-int		prio;
+int		prio,
-int		id;
+int		id,
-list_T	*pos_list;
+list_T	*pos_list,
-char_u      *conceal_char UNUSED; /* pointer to conceal replacement char */
+char_u      *conceal_char UNUSED) /* pointer to conceal replacement char */
 {
 matchitem_T	*cur;
 matchitem_T	*prev;
 matchitem_T	*m;
 int		hlg_id;
 /*
 * Delete match with ID 'id' in the match list of window 'wp'.
 * Print error messages if 'perr' is TRUE.
 */
 int
-match_delete(wp, id, perr)
+match_delete(win_T *wp, int id, int perr)
-win_T	*wp;
-int		id;
-int		perr;
 {
 matchitem_T	*cur = wp->w_match_head;
 matchitem_T	*prev = cur;
 int		rtype = SOME_VALID;
 /*
 * Delete all matches in the match list of window 'wp'.
 */
 void
-clear_matches(wp)
+clear_matches(win_T *wp)
-win_T	*wp;
 {
 matchitem_T *m;
 while (wp->w_match_head != NULL)
 {
 /*
 * Get match from ID 'id' in window 'wp'.
 * Return NULL if match not found.
 */
 matchitem_T *
-get_match(wp, id)
+get_match(win_T *wp, int id)
-win_T	*wp;
-int		id;
 {
 matchitem_T *cur = wp->w_match_head;
 while (cur != NULL && cur->id != id)
 	cur = cur->next;
 #if defined(FEAT_WINDOWS) || defined(PROTO)
 /*
 * Return TRUE if "topfrp" and its children are at the right height.
 */
 static int
-frame_check_height(topfrp, height)
+frame_check_height(frame_T *topfrp, int height)
-frame_T *topfrp;
-int	    height;
 {
 frame_T *frp;
 if (topfrp->fr_height != height)
 	return FALSE;
 #if defined(FEAT_VERTSPLIT) || defined(PROTO)
 /*
 * Return TRUE if "topfrp" and its children are at the right width.
 */
 static int
-frame_check_width(topfrp, width)
+frame_check_width(frame_T *topfrp, int width)
-frame_T *topfrp;
-int	    width;
 {
 frame_T *frp;
 if (topfrp->fr_width != width)
 	return FALSE;

Mercurial > vim

comparison src/window.c @ 7837:33ba2adb6065