patch 7.4.1205

Problem:    Using old style function declarations.
Solution:   Change to new style function declarations. (script by Hirohito
            Higashi)

src/arabic.c

@@ -43,8 +43,7 @@ static int  A_is_special(int c);
  * Returns True if c is an ISO-8859-6 shaped ARABIC letter (user entered)
  */
     static int
-A_is_a(cur_c)
+A_is_a(int cur_c)
-    int cur_c;
 {
     switch (cur_c)
     {
@@ -96,8 +95,7 @@ A_is_a(cur_c)
  * Returns True if c is an Isolated Form-B ARABIC letter
  */
     static int
-A_is_s(cur_c)
+A_is_s(int cur_c)
-    int cur_c;
 {
     switch (cur_c)
     {
@@ -148,8 +146,7 @@ A_is_s(cur_c)
  * Returns True if c is a Final shape of an ARABIC letter
  */
     static int
-A_is_f(cur_c)
+A_is_f(int cur_c)
-    int cur_c;
 {
     switch (cur_c)
     {
@@ -202,8 +199,7 @@ A_is_f(cur_c)
  * Change shape - from ISO-8859-6/Isolated to Form-B Isolated
  */
     static int
-chg_c_a2s(cur_c)
+chg_c_a2s(int cur_c)
-    int cur_c;
 {
     int tempc;
 
@@ -332,8 +328,7 @@ chg_c_a2s(cur_c)
  * Change shape - from ISO-8859-6/Isolated to Initial
  */
     static int
-chg_c_a2i(cur_c)
+chg_c_a2i(int cur_c)
-    int cur_c;
 {
     int tempc;
 
@@ -462,8 +457,7 @@ chg_c_a2i(cur_c)
  * Change shape - from ISO-8859-6/Isolated to Medial
  */
     static int
-chg_c_a2m(cur_c)
+chg_c_a2m(int cur_c)
-    int cur_c;
 {
     int tempc;
 
@@ -592,8 +586,7 @@ chg_c_a2m(cur_c)
  * Change shape - from ISO-8859-6/Isolated to final
  */
     static int
-chg_c_a2f(cur_c)
+chg_c_a2f(int cur_c)
-    int cur_c;
 {
     int tempc;
 
@@ -732,8 +725,7 @@ chg_c_a2f(cur_c)
  * Change shape - from Initial to Medial
  */
     static int
-chg_c_i2m(cur_c)
+chg_c_i2m(int cur_c)
-    int cur_c;
 {
     int tempc;
 
@@ -820,8 +812,7 @@ chg_c_i2m(cur_c)
  * Change shape - from Final to Medial
  */
     static int
-chg_c_f2m(cur_c)
+chg_c_f2m(int cur_c)
-    int cur_c;
 {
     int tempc;
 
@@ -930,8 +921,7 @@ chg_c_f2m(cur_c)
  * Change shape - from Combination (2 char) to an Isolated
  */
     static int
-chg_c_laa2i(hid_c)
+chg_c_laa2i(int hid_c)
-    int hid_c;
 {
     int tempc;
 
@@ -961,8 +951,7 @@ chg_c_laa2i(hid_c)
  * Change shape - from Combination-Isolated to Final
  */
     static int
-chg_c_laa2f(hid_c)
+chg_c_laa2f(int hid_c)
-    int hid_c;
 {
     int tempc;
 
@@ -991,8 +980,7 @@ chg_c_laa2f(hid_c)
  * Do "half-shaping" on character "c".  Return zero if no shaping.
  */
     static int
-half_shape(c)
+half_shape(int c)
-    int		c;
 {
     if (A_is_a(c))
 	return chg_c_a2i(c);
@@ -1011,13 +999,13 @@ half_shape(c)
  * in:     "next_c"  is the next character (not shaped).
  */
     int
-arabic_shape(c, ccp, c1p, prev_c, prev_c1, next_c)
+arabic_shape(
-    int		c;
+    int		c,
-    int		*ccp;
+    int		*ccp,
-    int		*c1p;
+    int		*c1p,
-    int		prev_c;
+    int		prev_c,
-    int		prev_c1;
+    int		prev_c1,
-    int		next_c;
+    int		next_c)
 {
     int		curr_c;
     int		shape_c;
@@ -1082,9 +1070,9 @@ arabic_shape(c, ccp, c1p, prev_c, prev_c1, next_c)
  * A_firstc_laa returns first character of LAA combination if it exists
  */
     static int
-A_firstc_laa(c, c1)
+A_firstc_laa(
-    int c;	/* base character */
+    int c,	/* base character */
-    int c1;	/* first composing character */
+    int c1)	/* first composing character */
 {
     if (c1 != NUL && c == a_LAM && !A_is_harakat(c1))
 	return c1;
@@ -1097,8 +1085,7 @@ A_firstc_laa(c, c1)
  *		(harakat/tanween)
  */
     static int
-A_is_harakat(c)
+A_is_harakat(int c)
-    int c;
 {
     return (c >= a_FATHATAN && c <= a_SUKUN);
 }
@@ -1109,8 +1096,7 @@ A_is_harakat(c)
  *		(alphabet/number/punctuation)
  */
     static int
-A_is_iso(c)
+A_is_iso(int c)
-    int c;
 {
     return ((c >= a_HAMZA && c <= a_GHAIN)
 	    || (c >= a_TATWEEL && c <= a_HAMZA_BELOW)
@@ -1123,8 +1109,7 @@ A_is_iso(c)
  *		(alphabet/number/punctuation)
  */
     static int
-A_is_formb(c)
+A_is_formb(int c)
-    int c;
 {
     return ((c >= a_s_FATHATAN && c <= a_s_DAMMATAN)
 	    || c == a_s_KASRATAN
@@ -1137,8 +1122,7 @@ A_is_formb(c)
  * A_is_ok returns TRUE if 'c' is an Arabic 10646 (8859-6 or Form-B)
  */
     static int
-A_is_ok(c)
+A_is_ok(int c)
-    int c;
 {
     return (A_is_iso(c) || A_is_formb(c));
 }
@@ -1149,8 +1133,7 @@ A_is_ok(c)
  *		with some exceptions/exclusions
  */
     static int
-A_is_valid(c)
+A_is_valid(int c)
-    int c;
 {
     return (A_is_ok(c) && !A_is_special(c));
 }
@@ -1161,8 +1144,7 @@ A_is_valid(c)
  *		Specials don't adhere to most of the rules.
  */
     static int
-A_is_special(c)
+A_is_special(int c)
-    int c;
 {
     return (c == a_HAMZA || c == a_s_HAMZA);
 }

src/blowfish.c

@@ -348,10 +348,10 @@ static UINT32_T sbx_init[4][256] = {
     bfs->sbx[3][xr & 0xFF];
 
     static void
-bf_e_block(bfs, p_xl, p_xr)
+bf_e_block(
-    bf_state_T *bfs;
+    bf_state_T *bfs,
-    UINT32_T *p_xl;
+    UINT32_T *p_xl,
-    UINT32_T *p_xr;
+    UINT32_T *p_xr)
 {
     UINT32_T temp;
     UINT32_T xl = *p_xl;
@@ -384,9 +384,9 @@ bf_e_block(bfs, p_xl, p_xr)
 #endif
 
     static void
-bf_e_cblock(bfs, block)
+bf_e_cblock(
-    bf_state_T *bfs;
+    bf_state_T *bfs,
-    char_u *block;
+    char_u *block)
 {
     block8	bk;
 
@@ -404,11 +404,11 @@ bf_e_cblock(bfs, block)
  * "salt[salt_len]" as the salt.
  */
     static void
-bf_key_init(bfs, password, salt, salt_len)
+bf_key_init(
-    bf_state_T	*bfs;
+    bf_state_T	*bfs,
-    char_u	*password;
+    char_u	*password,
-    char_u	*salt;
+    char_u	*salt,
-    int		salt_len;
+    int		salt_len)
 {
     int      i, j, keypos = 0;
     unsigned u;
@@ -470,10 +470,10 @@ bf_key_init(bfs, password, salt, salt_len)
  * Blowfish self-test for corrupted tables or instructions.
  */
     static int
-bf_check_tables(pax, sbx, val)
+bf_check_tables(
-    UINT32_T pax[18];
+    UINT32_T pax[18],
-    UINT32_T sbx[4][256];
+    UINT32_T sbx[4][256],
-    UINT32_T val;
+    UINT32_T val)
 {
     int i, j;
     UINT32_T c = 0;
@@ -514,7 +514,7 @@ static struct_bf_test_data bf_test_data[] = {
  * Return FAIL when there is something wrong with blowfish encryption.
  */
     static int
-bf_self_test()
+bf_self_test(void)
 {
     int    i, bn;
     int    err = 0;
@@ -566,10 +566,10 @@ bf_self_test()
  * Initialize with seed "seed[seed_len]".
  */
     static void
-bf_cfb_init(bfs, seed, seed_len)
+bf_cfb_init(
-    bf_state_T	*bfs;
+    bf_state_T	*bfs,
-    char_u	*seed;
+    char_u	*seed,
-    int		seed_len;
+    int		seed_len)
 {
     int i, mi;
 
@@ -602,11 +602,11 @@ bf_cfb_init(bfs, seed, seed_len)
  * "from" and "to" can be equal to encrypt in place.
  */
     void
-crypt_blowfish_encode(state, from, len, to)
+crypt_blowfish_encode(
-    cryptstate_T *state;
+    cryptstate_T *state,
-    char_u	*from;
+    char_u	*from,
-    size_t	len;
+    size_t	len,
-    char_u	*to;
+    char_u	*to)
 {
     bf_state_T *bfs = state->method_state;
     size_t	i;
@@ -625,11 +625,11 @@ crypt_blowfish_encode(state, from, len, to)
  * Decrypt "from[len]" into "to[len]".
  */
     void
-crypt_blowfish_decode(state, from, len, to)
+crypt_blowfish_decode(
-    cryptstate_T *state;
+    cryptstate_T *state,
-    char_u	*from;
+    char_u	*from,
-    size_t	len;
+    size_t	len,
-    char_u	*to;
+    char_u	*to)
 {
     bf_state_T *bfs = state->method_state;
     size_t	i;
@@ -644,13 +644,13 @@ crypt_blowfish_decode(state, from, len, to)
 }
 
     void
-crypt_blowfish_init(state, key, salt, salt_len, seed, seed_len)
+crypt_blowfish_init(
-    cryptstate_T	*state;
+    cryptstate_T	*state,
-    char_u*		key;
+    char_u*		key,
-    char_u*		salt;
+    char_u*		salt,
-    int			salt_len;
+    int			salt_len,
-    char_u*		seed;
+    char_u*		seed,
-    int			seed_len;
+    int			seed_len)
 {
     bf_state_T	*bfs = (bf_state_T *)alloc_clear(sizeof(bf_state_T));
 
@@ -672,7 +672,7 @@ crypt_blowfish_init(state, key, salt, salt_len, seed, seed_len)
  * Give an error and return FAIL when not.
  */
     int
-blowfish_self_test()
+blowfish_self_test(void)
 {
     if (sha256_self_test() == FAIL)
     {

src/channel.c

@@ -745,7 +745,7 @@ channel_wait(int fd, int timeout)
  * Return a unique ID to be used in a message.
  */
     int
-channel_get_id()
+channel_get_id(void)
 {
     static int next_id = 1;
 

src/charset.c

@@ -68,15 +68,15 @@ static char_u	g_chartab[256];
  * error, OK otherwise.
  */
     int
-init_chartab()
+init_chartab(void)
 {
     return buf_init_chartab(curbuf, TRUE);
 }
 
     int
-buf_init_chartab(buf, global)
+buf_init_chartab(
-    buf_T	*buf;
+    buf_T	*buf,
-    int		global;		/* FALSE: only set buf->b_chartab[] */
+    int		global)		/* FALSE: only set buf->b_chartab[] */
 {
     int		c;
     int		c2;
@@ -313,9 +313,9 @@ buf_init_chartab(buf, global)
  * enough room, not all characters will be translated.
  */
     void
-trans_characters(buf, bufsize)
+trans_characters(
-    char_u	*buf;
+    char_u	*buf,
-    int		bufsize;
+    int		bufsize)
 {
     int		len;		/* length of string needing translation */
     int		room;		/* room in buffer after string */
@@ -356,8 +356,7 @@ trans_characters(buf, bufsize)
  * printable chars.  Returns NULL when out of memory.
  */
     char_u *
-transstr(s)
+transstr(char_u *s)
-    char_u	*s;
 {
     char_u	*res;
     char_u	*p;
@@ -434,11 +433,11 @@ transstr(s)
  * Otherwise puts the result in "buf[buflen]".
  */
     char_u *
-str_foldcase(str, orglen, buf, buflen)
+str_foldcase(
-    char_u	*str;
+    char_u	*str,
-    int		orglen;
+    int		orglen,
-    char_u	*buf;
+    char_u	*buf,
-    int		buflen;
+    int		buflen)
 {
     garray_T	ga;
     int		i;
@@ -552,8 +551,7 @@ str_foldcase(str, orglen, buf, buflen)
 static char_u	transchar_buf[7];
 
     char_u *
-transchar(c)
+transchar(int c)
-    int		c;
 {
     int			i;
 
@@ -592,8 +590,7 @@ transchar(c)
  * for an illegal UTF-8 byte.
  */
     char_u *
-transchar_byte(c)
+transchar_byte(int c)
-    int		c;
 {
     if (enc_utf8 && c >= 0x80)
     {
@@ -610,9 +607,7 @@ transchar_byte(c)
  * Does NOT work for multi-byte characters, c must be <= 255.
  */
     void
-transchar_nonprint(buf, c)
+transchar_nonprint(char_u *buf, int c)
-    char_u	*buf;
-    int		c;
 {
     if (c == NL)
 	c = NUL;		/* we use newline in place of a NUL */
@@ -679,9 +674,7 @@ transchar_nonprint(buf, c)
 }
 
     void
-transchar_hex(buf, c)
+transchar_hex(char_u *buf, int c)
-    char_u	*buf;
-    int		c;
 {
     int		i = 0;
 
@@ -705,8 +698,7 @@ transchar_hex(buf, c)
  * function key 1.
  */
     static unsigned
-nr2hex(c)
+nr2hex(unsigned c)
-    unsigned	c;
 {
     if ((c & 0xf) <= 9)
 	return (c & 0xf) + '0';
@@ -722,8 +714,7 @@ nr2hex(c)
  * cells depends on further bytes.
  */
     int
-byte2cells(b)
+byte2cells(int b)
-    int		b;
 {
 #ifdef FEAT_MBYTE
     if (enc_utf8 && b >= 0x80)
@@ -738,8 +729,7 @@ byte2cells(b)
  * A TAB is counted as two cells: "^I" or four: "<09>".
  */
     int
-char2cells(c)
+char2cells(int c)
-    int		c;
 {
     if (IS_SPECIAL(c))
 	return char2cells(K_SECOND(c)) + 2;
@@ -767,8 +757,7 @@ char2cells(c)
  * A TAB is counted as two cells: "^I" or four: "<09>".
  */
     int
-ptr2cells(p)
+ptr2cells(char_u *p)
-    char_u	*p;
 {
 #ifdef FEAT_MBYTE
     /* For UTF-8 we need to look at more bytes if the first byte is >= 0x80. */
@@ -784,8 +773,7 @@ ptr2cells(p)
  * counting TABs as two characters: "^I".
  */
     int
-vim_strsize(s)
+vim_strsize(char_u *s)
-    char_u	*s;
 {
     return vim_strnsize(s, (int)MAXCOL);
 }
@@ -795,9 +783,7 @@ vim_strsize(s)
  * screen, counting TABs as two characters: "^I".
  */
     int
-vim_strnsize(s, len)
+vim_strnsize(char_u *s, int len)
-    char_u	*s;
-    int		len;
 {
     int		size = 0;
 
@@ -839,9 +825,7 @@ vim_strnsize(s, len)
 #if defined(FEAT_VREPLACE) || defined(FEAT_EX_EXTRA) || defined(FEAT_GUI) \
 	|| defined(FEAT_VIRTUALEDIT) || defined(PROTO)
     int
-chartabsize(p, col)
+chartabsize(char_u *p, colnr_T col)
-    char_u	*p;
-    colnr_T	col;
 {
     RET_WIN_BUF_CHARTABSIZE(curwin, curbuf, p, col)
 }
@@ -849,10 +833,7 @@ chartabsize(p, col)
 
 #ifdef FEAT_LINEBREAK
     static int
-win_chartabsize(wp, p, col)
+win_chartabsize(win_T *wp, char_u *p, colnr_T col)
-    win_T	*wp;
-    char_u	*p;
-    colnr_T	col;
 {
     RET_WIN_BUF_CHARTABSIZE(wp, wp->w_buffer, p, col)
 }
@@ -863,8 +844,7 @@ win_chartabsize(wp, p, col)
  * taking into account the size of a tab.
  */
     int
-linetabsize(s)
+linetabsize(char_u *s)
-    char_u	*s;
 {
     return linetabsize_col(0, s);
 }
@@ -873,9 +853,7 @@ linetabsize(s)
  * Like linetabsize(), but starting at column "startcol".
  */
     int
-linetabsize_col(startcol, s)
+linetabsize_col(int startcol, char_u *s)
-    int		startcol;
-    char_u	*s;
 {
     colnr_T	col = startcol;
     char_u	*line = s; /* pointer to start of line, for breakindent */
@@ -889,10 +867,7 @@ linetabsize_col(startcol, s)
  * Like linetabsize(), but for a given window instead of the current one.
  */
     int
-win_linetabsize(wp, line, len)
+win_linetabsize(win_T *wp, char_u *line, colnr_T len)
-    win_T	*wp;
-    char_u	*line;
-    colnr_T	len;
 {
     colnr_T	col = 0;
     char_u	*s;
@@ -908,8 +883,7 @@ win_linetabsize(wp, line, len)
  * Letters and characters from the 'isident' option.
  */
     int
-vim_isIDc(c)
+vim_isIDc(int c)
-    int c;
 {
     return (c > 0 && c < 0x100 && (g_chartab[c] & CT_ID_CHAR));
 }
@@ -920,16 +894,13 @@ vim_isIDc(c)
  * For multi-byte characters mb_get_class() is used (builtin rules).
  */
     int
-vim_iswordc(c)
+vim_iswordc(int c)
-    int c;
 {
     return vim_iswordc_buf(c, curbuf);
 }
 
     int
-vim_iswordc_buf(c, buf)
+vim_iswordc_buf(int c, buf_T *buf)
-    int		c;
-    buf_T	*buf;
 {
 #ifdef FEAT_MBYTE
     if (c >= 0x100)
@@ -947,8 +918,7 @@ vim_iswordc_buf(c, buf)
  * Just like vim_iswordc() but uses a pointer to the (multi-byte) character.
  */
     int
-vim_iswordp(p)
+vim_iswordp(char_u *p)
-    char_u *p;
 {
 #ifdef FEAT_MBYTE
     if (has_mbyte && MB_BYTE2LEN(*p) > 1)
@@ -958,9 +928,7 @@ vim_iswordp(p)
 }
 
     int
-vim_iswordp_buf(p, buf)
+vim_iswordp_buf(char_u *p, buf_T *buf)
-    char_u	*p;
-    buf_T	*buf;
 {
 #ifdef FEAT_MBYTE
     if (has_mbyte && MB_BYTE2LEN(*p) > 1)
@@ -974,8 +942,7 @@ vim_iswordp_buf(p, buf)
  * Assume characters above 0x100 are valid (multi-byte).
  */
     int
-vim_isfilec(c)
+vim_isfilec(int c)
-    int	c;
 {
     return (c >= 0x100 || (c > 0 && (g_chartab[c] & CT_FNAME_CHAR)));
 }
@@ -987,8 +954,7 @@ vim_isfilec(c)
  * returns false.
  */
     int
-vim_isfilec_or_wc(c)
+vim_isfilec_or_wc(int c)
-    int c;
 {
     char_u buf[2];
 
@@ -1003,8 +969,7 @@ vim_isfilec_or_wc(c)
  * Unicode.
  */
     int
-vim_isprintc(c)
+vim_isprintc(int c)
-    int c;
 {
 #ifdef FEAT_MBYTE
     if (enc_utf8 && c >= 0x100)
@@ -1018,8 +983,7 @@ vim_isprintc(c)
  * byte of a double-byte character.
  */
     int
-vim_isprintc_strict(c)
+vim_isprintc_strict(int c)
-    int	c;
 {
 #ifdef FEAT_MBYTE
     if (enc_dbcs != 0 && c < 0x100 && MB_BYTE2LEN(c) > 1)
@@ -1034,10 +998,10 @@ vim_isprintc_strict(c)
  * like chartabsize(), but also check for line breaks on the screen
  */
     int
-lbr_chartabsize(line, s, col)
+lbr_chartabsize(
-    char_u		*line UNUSED; /* start of the line */
+    char_u		*line UNUSED, /* start of the line */
-    unsigned char	*s;
+    unsigned char	*s,
-    colnr_T		col;
+    colnr_T		col)
 {
 #ifdef FEAT_LINEBREAK
     if (!curwin->w_p_lbr && *p_sbr == NUL && !curwin->w_p_bri)
@@ -1058,10 +1022,10 @@ lbr_chartabsize(line, s, col)
  * Call lbr_chartabsize() and advance the pointer.
  */
     int
-lbr_chartabsize_adv(line, s, col)
+lbr_chartabsize_adv(
-    char_u	*line; /* start of the line */
+    char_u	*line, /* start of the line */
-    char_u	**s;
+    char_u	**s,
-    colnr_T	col;
+    colnr_T	col)
 {
     int		retval;
 
@@ -1078,12 +1042,12 @@ lbr_chartabsize_adv(line, s, col)
  * value, init to 0 before calling.
  */
     int
-win_lbr_chartabsize(wp, line, s, col, headp)
+win_lbr_chartabsize(
-    win_T	*wp;
+    win_T	*wp,
-    char_u	*line UNUSED; /* start of the line */
+    char_u	*line UNUSED, /* start of the line */
-    char_u	*s;
+    char_u	*s,
-    colnr_T	col;
+    colnr_T	col,
-    int		*headp UNUSED;
+    int		*headp UNUSED)
 {
 #ifdef FEAT_LINEBREAK
     int		c;
@@ -1254,11 +1218,11 @@ win_lbr_chartabsize(wp, line, s, col, headp)
  * doesn't fit at the end of the screen line.
  */
     static int
-win_nolbr_chartabsize(wp, s, col, headp)
+win_nolbr_chartabsize(
-    win_T	*wp;
+    win_T	*wp,
-    char_u	*s;
+    char_u	*s,
-    colnr_T	col;
+    colnr_T	col,
-    int		*headp;
+    int		*headp)
 {
     int		n;
 
@@ -1284,9 +1248,7 @@ win_nolbr_chartabsize(wp, s, col, headp)
  * "wp".
  */
     int
-in_win_border(wp, vcol)
+in_win_border(win_T *wp, colnr_T vcol)
-    win_T	*wp;
-    colnr_T	vcol;
 {
     int		width1;		/* width of first line (after line number) */
     int		width2;		/* width of further lines */
@@ -1316,12 +1278,12 @@ in_win_border(wp, vcol)
  * This is used very often, keep it fast!
  */
     void
-getvcol(wp, pos, start, cursor, end)
+getvcol(
-    win_T	*wp;
+    win_T	*wp,
-    pos_T	*pos;
+    pos_T	*pos,
-    colnr_T	*start;
+    colnr_T	*start,
-    colnr_T	*cursor;
+    colnr_T	*cursor,
-    colnr_T	*end;
+    colnr_T	*end)
 {
     colnr_T	vcol;
     char_u	*ptr;		/* points to current char */
@@ -1446,8 +1408,7 @@ getvcol(wp, pos, start, cursor, end)
  * Get virtual cursor column in the current window, pretending 'list' is off.
  */
     colnr_T
-getvcol_nolist(posp)
+getvcol_nolist(pos_T *posp)
-    pos_T	*posp;
 {
     int		list_save = curwin->w_p_list;
     colnr_T	vcol;
@@ -1463,12 +1424,12 @@ getvcol_nolist(posp)
  * Get virtual column in virtual mode.
  */
     void
-getvvcol(wp, pos, start, cursor, end)
+getvvcol(
-    win_T	*wp;
+    win_T	*wp,
-    pos_T	*pos;
+    pos_T	*pos,
-    colnr_T	*start;
+    colnr_T	*start,
-    colnr_T	*cursor;
+    colnr_T	*cursor,
-    colnr_T	*end;
+    colnr_T	*end)
 {
     colnr_T	col;
     colnr_T	coladd;
@@ -1519,10 +1480,12 @@ getvvcol(wp, pos, start, cursor, end)
  * Used for Visual block mode.
  */
     void
-getvcols(wp, pos1, pos2, left, right)
+getvcols(
-    win_T	*wp;
+    win_T	*wp,
-    pos_T	*pos1, *pos2;
+    pos_T	*pos1,
-    colnr_T	*left, *right;
+    pos_T	*pos2,
+    colnr_T	*left,
+    colnr_T	*right)
 {
     colnr_T	from1, from2, to1, to2;
 
@@ -1555,8 +1518,7 @@ getvcols(wp, pos1, pos2, left, right)
  * skipwhite: skip over ' ' and '\t'.
  */
     char_u *
-skipwhite(q)
+skipwhite(char_u *q)
-    char_u	*q;
 {
     char_u	*p = q;
 
@@ -1569,8 +1531,7 @@ skipwhite(q)
  * skip over digits
  */
     char_u *
-skipdigits(q)
+skipdigits(char_u *q)
-    char_u	*q;
 {
     char_u	*p = q;
 
@@ -1584,8 +1545,7 @@ skipdigits(q)
  * skip over binary digits
  */
     char_u *
-skipbin(q)
+skipbin(char_u *q)
-    char_u	*q;
 {
     char_u	*p = q;
 
@@ -1598,8 +1558,7 @@ skipbin(q)
  * skip over digits and hex characters
  */
     char_u *
-skiphex(q)
+skiphex(char_u *q)
-    char_u	*q;
 {
     char_u	*p = q;
 
@@ -1614,8 +1573,7 @@ skiphex(q)
  * skip to bin digit (or NUL after the string)
  */
     char_u *
-skiptobin(q)
+skiptobin(char_u *q)
-    char_u	*q;
 {
     char_u	*p = q;
 
@@ -1628,8 +1586,7 @@ skiptobin(q)
  * skip to digit (or NUL after the string)
  */
     char_u *
-skiptodigit(q)
+skiptodigit(char_u *q)
-    char_u	*q;
 {
     char_u	*p = q;
 
@@ -1642,8 +1599,7 @@ skiptodigit(q)
  * skip to hex character (or NUL after the string)
  */
     char_u *
-skiptohex(q)
+skiptohex(char_u *q)
-    char_u	*q;
 {
     char_u	*p = q;
 
@@ -1660,8 +1616,7 @@ skiptohex(q)
  * Use the VIM_ISDIGIT() macro for simple arguments.
  */
     int
-vim_isdigit(c)
+vim_isdigit(int c)
-    int		c;
 {
     return (c >= '0' && c <= '9');
 }
@@ -1672,8 +1627,7 @@ vim_isdigit(c)
  * superscript 1 to be a digit.
  */
     int
-vim_isxdigit(c)
+vim_isxdigit(int c)
-    int		c;
 {
     return (c >= '0' && c <= '9')
 	|| (c >= 'a' && c <= 'f')
@@ -1685,8 +1639,7 @@ vim_isxdigit(c)
  * characters > 0x100.
  */
     int
-vim_isbdigit(c)
+vim_isbdigit(int c)
-    int		c;
 {
     return (c == '0' || c == '1');
 }
@@ -1706,8 +1659,7 @@ static char_u latin1upper[257] = "                                 !\"#$%&'()*+,
 static char_u latin1lower[257] = "                                 !\"#$%&'()*+,-./0123456789:;<=>?@abcdefghijklmnopqrstuvwxyz[\\]^_`abcdefghijklmnopqrstuvwxyz{|}~\x7f\x80\x81\x82\x83\x84\x85\x86\x87\x88\x89\x8a\x8b\x8c\x8d\x8e\x8f\x90\x91\x92\x93\x94\x95\x96\x97\x98\x99\x9a\x9b\x9c\x9d\x9e\x9f\xa0\xa1\xa2\xa3\xa4\xa5\xa6\xa7\xa8\xa9\xaa\xab\xac\xad\xae\xaf\xb0\xb1\xb2\xb3\xb4\xb5\xb6\xb7\xb8\xb9\xba\xbb\xbc\xbd\xbe\xbf\xe0\xe1\xe2\xe3\xe4\xe5\xe6\xe7\xe8\xe9\xea\xeb\xec\xed\xee\xef\xf0\xf1\xf2\xf3\xf4\xf5\xf6\xd7\xf8\xf9\xfa\xfb\xfc\xfd\xfe\xdf\xe0\xe1\xe2\xe3\xe4\xe5\xe6\xe7\xe8\xe9\xea\xeb\xec\xed\xee\xef\xf0\xf1\xf2\xf3\xf4\xf5\xf6\xf7\xf8\xf9\xfa\xfb\xfc\xfd\xfe\xff";
 
     int
-vim_islower(c)
+vim_islower(int c)
-    int	    c;
 {
     if (c <= '@')
 	return FALSE;
@@ -1731,8 +1683,7 @@ vim_islower(c)
 }
 
     int
-vim_isupper(c)
+vim_isupper(int c)
-    int	    c;
 {
     if (c <= '@')
 	return FALSE;
@@ -1756,8 +1707,7 @@ vim_isupper(c)
 }
 
     int
-vim_toupper(c)
+vim_toupper(int c)
-    int	    c;
 {
     if (c <= '@')
 	return c;
@@ -1781,8 +1731,7 @@ vim_toupper(c)
 }
 
     int
-vim_tolower(c)
+vim_tolower(int c)
-    int	    c;
 {
     if (c <= '@')
 	return c;
@@ -1810,8 +1759,7 @@ vim_tolower(c)
  * skiptowhite: skip over text until ' ' or '\t' or NUL.
  */
     char_u *
-skiptowhite(p)
+skiptowhite(char_u *p)
-    char_u	*p;
 {
     while (*p != ' ' && *p != '\t' && *p != NUL)
 	++p;
@@ -1824,8 +1772,7 @@ skiptowhite(p)
  * skiptowhite_esc: Like skiptowhite(), but also skip escaped chars
  */
     char_u *
-skiptowhite_esc(p)
+skiptowhite_esc(char_u *p)
-    char_u	*p;
 {
     while (*p != ' ' && *p != '\t' && *p != NUL)
     {
@@ -1842,8 +1789,7 @@ skiptowhite_esc(p)
  * Note: the argument is a pointer to a char_u pointer!
  */
     long
-getdigits(pp)
+getdigits(char_u **pp)
-    char_u **pp;
 {
     char_u	*p;
     long	retval;
@@ -1861,8 +1807,7 @@ getdigits(pp)
  * Return TRUE if "lbuf" is empty or only contains blanks.
  */
     int
-vim_isblankline(lbuf)
+vim_isblankline(char_u *lbuf)
-    char_u	*lbuf;
 {
     char_u	*p;
 
@@ -1890,16 +1835,16 @@ vim_isblankline(lbuf)
  * If maxlen > 0, check at a maximum maxlen chars
  */
     void
-vim_str2nr(start, prep, len, what, nptr, unptr, maxlen)
+vim_str2nr(
-    char_u		*start;
+    char_u		*start,
-    int			*prep;	    /* return: type of number 0 = decimal, 'x'
+    int			*prep,	    /* return: type of number 0 = decimal, 'x'
 				       or 'X' is hex, '0' = octal, 'b' or 'B'
 				       is bin */
-    int			*len;	    /* return: detected length of number */
+    int			*len,	    /* return: detected length of number */
-    int			what;	    /* what numbers to recognize */
+    int			what,	    /* what numbers to recognize */
-    long		*nptr;	    /* return: signed result */
+    long		*nptr,	    /* return: signed result */
-    unsigned long	*unptr;	    /* return: unsigned result */
+    unsigned long	*unptr,	    /* return: unsigned result */
-    int			maxlen;     /* max length of string to check */
+    int			maxlen)     /* max length of string to check */
 {
     char_u	    *ptr = start;
     int		    pre = 0;		/* default is decimal */
@@ -2024,8 +1969,7 @@ vim_str2nr(start, prep, len, what, nptr, unptr, maxlen)
  * Only valid when the argument is '0' - '9', 'A' - 'F' or 'a' - 'f'.
  */
     int
-hex2nr(c)
+hex2nr(int c)
-    int		c;
 {
     if (c >= 'a' && c <= 'f')
 	return c - 'a' + 10;
@@ -2041,8 +1985,7 @@ hex2nr(c)
  * Return -1 if one of the characters is not hex.
  */
     int
-hexhex2nr(p)
+hexhex2nr(char_u *p)
-    char_u	*p;
 {
     if (!vim_isxdigit(p[0]) || !vim_isxdigit(p[1]))
 	return -1;
@@ -2064,8 +2007,7 @@ hexhex2nr(p)
  * characters.
  */
     int
-rem_backslash(str)
+rem_backslash(char_u *str)
-    char_u  *str;
 {
 #ifdef BACKSLASH_IN_FILENAME
     return (str[0] == '\\'
@@ -2088,8 +2030,7 @@ rem_backslash(str)
  * is not a normal file character.
  */
     void
-backslash_halve(p)
+backslash_halve(char_u *p)
-    char_u	*p;
 {
     for ( ; *p; ++p)
 	if (rem_backslash(p))
@@ -2100,8 +2041,7 @@ backslash_halve(p)
  * backslash_halve() plus save the result in allocated memory.
  */
     char_u *
-backslash_halve_save(p)
+backslash_halve_save(char_u *p)
-    char_u	*p;
 {
     char_u	*res;
 
@@ -2159,9 +2099,7 @@ static char_u ebcdic2ascii_tab[256] =
  * wanting 7-bit ASCII characters out the other end.
  */
     void
-ebcdic2ascii(buffer, len)
+ebcdic2ascii(char_u *buffer, int len)
-    char_u	*buffer;
-    int		len;
 {
     int		i;
 

src/crypt.c

@@ -130,8 +130,7 @@ static char	crypt_magic_head[] = "VimCrypt~";
  * 2 for "blowfish2".
  */
     int
-crypt_method_nr_from_name(name)
+crypt_method_nr_from_name(char_u *name)
-    char_u  *name;
 {
     int i;
 
@@ -147,9 +146,7 @@ crypt_method_nr_from_name(name)
  * Returns -1 when no encryption used.
  */
     int
-crypt_method_nr_from_magic(ptr, len)
+crypt_method_nr_from_magic(char *ptr, int len)
-    char  *ptr;
-    int   len;
 {
     int i;
 
@@ -171,8 +168,7 @@ crypt_method_nr_from_magic(ptr, len)
  * Return TRUE if the crypt method for "method_nr" can be done in-place.
  */
     int
-crypt_works_inplace(state)
+crypt_works_inplace(cryptstate_T *state)
-    cryptstate_T *state;
 {
     return cryptmethods[state->method_nr].works_inplace;
 }
@@ -181,8 +177,7 @@ crypt_works_inplace(state)
  * Get the crypt method for buffer "buf" as a number.
  */
     int
-crypt_get_method_nr(buf)
+crypt_get_method_nr(buf_T *buf)
-    buf_T *buf;
 {
     return crypt_method_nr_from_name(*buf->b_p_cm == NUL ? p_cm : buf->b_p_cm);
 }
@@ -192,8 +187,7 @@ crypt_get_method_nr(buf)
  * whole undo file, not only the text.
  */
     int
-crypt_whole_undofile(method_nr)
+crypt_whole_undofile(int method_nr)
-    int method_nr;
 {
     return cryptmethods[method_nr].whole_undofile;
 }
@@ -202,8 +196,7 @@ crypt_whole_undofile(method_nr)
  * Get crypt method specifc length of the file header in bytes.
  */
     int
-crypt_get_header_len(method_nr)
+crypt_get_header_len(int method_nr)
-    int method_nr;
 {
     return CRYPT_MAGIC_LEN
 	+ cryptmethods[method_nr].salt_len
@@ -215,9 +208,7 @@ crypt_get_header_len(method_nr)
  * returned by crypt_method_nr_from_name().
  */
     void
-crypt_set_cm_option(buf, method_nr)
+crypt_set_cm_option(buf_T *buf, int method_nr)
-    buf_T   *buf;
-    int	    method_nr;
 {
     free_string_option(buf->b_p_cm);
     buf->b_p_cm = vim_strsave((char_u *)cryptmethods[method_nr].name);
@@ -228,7 +219,7 @@ crypt_set_cm_option(buf, method_nr)
  * return OK/FAIL.
  */
     int
-crypt_self_test()
+crypt_self_test(void)
 {
     int method_nr = crypt_get_method_nr(curbuf);
 
@@ -241,13 +232,13 @@ crypt_self_test()
  * Allocate a crypt state and initialize it.
  */
     cryptstate_T *
-crypt_create(method_nr, key, salt, salt_len, seed, seed_len)
+crypt_create(
-    int		method_nr;
+    int		method_nr,
-    char_u	*key;
+    char_u	*key,
-    char_u	*salt;
+    char_u	*salt,
-    int		salt_len;
+    int		salt_len,
-    char_u	*seed;
+    char_u	*seed,
-    int		seed_len;
+    int		seed_len)
 {
     cryptstate_T *state = (cryptstate_T *)alloc((int)sizeof(cryptstate_T));
 
@@ -262,10 +253,10 @@ crypt_create(method_nr, key, salt, salt_len, seed, seed_len)
  * crypt_get_header_len() returns for "method_nr".
  */
     cryptstate_T *
-crypt_create_from_header(method_nr, key, header)
+crypt_create_from_header(
-    int		method_nr;
+    int		method_nr,
-    char_u	*key;
+    char_u	*key,
-    char_u	*header;
+    char_u	*header)
 {
     char_u	*salt = NULL;
     char_u	*seed = NULL;
@@ -285,9 +276,7 @@ crypt_create_from_header(method_nr, key, header)
  * Return an allocated cryptstate_T or NULL on error.
  */
     cryptstate_T *
-crypt_create_from_file(fp, key)
+crypt_create_from_file(FILE *fp, char_u *key)
-    FILE    *fp;
-    char_u  *key;
 {
     int		method_nr;
     int		header_len;
@@ -326,11 +315,11 @@ crypt_create_from_file(fp, key)
  * Returns the state or NULL on failure.
  */
     cryptstate_T *
-crypt_create_for_writing(method_nr, key, header, header_len)
+crypt_create_for_writing(
-    int	    method_nr;
+    int	    method_nr,
-    char_u  *key;
+    char_u  *key,
-    char_u  **header;
+    char_u  **header,
-    int	    *header_len;
+    int	    *header_len)
 {
     int	    len = crypt_get_header_len(method_nr);
     char_u  *salt = NULL;
@@ -371,8 +360,7 @@ crypt_create_for_writing(method_nr, key, header, header_len)
  * Free the crypt state.
  */
     void
-crypt_free_state(state)
+crypt_free_state(cryptstate_T *state)
-    cryptstate_T	*state;
 {
     vim_free(state->method_state);
     vim_free(state);
@@ -384,11 +372,11 @@ crypt_free_state(state)
  * Return number of bytes in "newptr", 0 for need more or -1 on error.
  */
     long
-crypt_encode_alloc(state, from, len, newptr)
+crypt_encode_alloc(
-    cryptstate_T *state;
+    cryptstate_T *state,
-    char_u	*from;
+    char_u	*from,
-    size_t	len;
+    size_t	len,
-    char_u	**newptr;
+    char_u	**newptr)
 {
     cryptmethod_T *method = &cryptmethods[state->method_nr];
 
@@ -412,11 +400,11 @@ crypt_encode_alloc(state, from, len, newptr)
  * Return number of bytes in "newptr", 0 for need more or -1 on error.
  */
     long
-crypt_decode_alloc(state, ptr, len, newptr)
+crypt_decode_alloc(
-    cryptstate_T *state;
+    cryptstate_T *state,
-    char_u	*ptr;
+    char_u	*ptr,
-    long	len;
+    long	len,
-    char_u      **newptr;
+    char_u      **newptr)
 {
     cryptmethod_T *method = &cryptmethods[state->method_nr];
 
@@ -439,11 +427,11 @@ crypt_decode_alloc(state, ptr, len, newptr)
  * Encrypting "from[len]" into "to[len]".
  */
     void
-crypt_encode(state, from, len, to)
+crypt_encode(
-    cryptstate_T *state;
+    cryptstate_T *state,
-    char_u	*from;
+    char_u	*from,
-    size_t	len;
+    size_t	len,
-    char_u	*to;
+    char_u	*to)
 {
     cryptmethods[state->method_nr].encode_fn(state, from, len, to);
 }
@@ -452,11 +440,11 @@ crypt_encode(state, from, len, to)
  * decrypting "from[len]" into "to[len]".
  */
     void
-crypt_decode(state, from, len, to)
+crypt_decode(
-    cryptstate_T *state;
+    cryptstate_T *state,
-    char_u	*from;
+    char_u	*from,
-    size_t	len;
+    size_t	len,
-    char_u	*to;
+    char_u	*to)
 {
     cryptmethods[state->method_nr].decode_fn(state, from, len, to);
 }
@@ -465,10 +453,10 @@ crypt_decode(state, from, len, to)
  * Simple inplace encryption, modifies "buf[len]" in place.
  */
     void
-crypt_encode_inplace(state, buf, len)
+crypt_encode_inplace(
-    cryptstate_T *state;
+    cryptstate_T *state,
-    char_u	*buf;
+    char_u	*buf,
-    size_t	len;
+    size_t	len)
 {
     cryptmethods[state->method_nr].encode_inplace_fn(state, buf, len, buf);
 }
@@ -477,10 +465,10 @@ crypt_encode_inplace(state, buf, len)
  * Simple inplace decryption, modifies "buf[len]" in place.
  */
     void
-crypt_decode_inplace(state, buf, len)
+crypt_decode_inplace(
-    cryptstate_T *state;
+    cryptstate_T *state,
-    char_u	*buf;
+    char_u	*buf,
-    size_t	len;
+    size_t	len)
 {
     cryptmethods[state->method_nr].decode_inplace_fn(state, buf, len, buf);
 }
@@ -490,8 +478,7 @@ crypt_decode_inplace(state, buf, len)
  * in memory anywhere.
  */
     void
-crypt_free_key(key)
+crypt_free_key(char_u *key)
-    char_u *key;
 {
     char_u *p;
 
@@ -507,8 +494,7 @@ crypt_free_key(key)
  * Check the crypt method and give a warning if it's outdated.
  */
     void
-crypt_check_method(method)
+crypt_check_method(int method)
-    int method;
 {
     if (method < CRYPT_M_BF2)
     {
@@ -518,7 +504,7 @@ crypt_check_method(method)
 }
 
     void
-crypt_check_current_method()
+crypt_check_current_method(void)
 {
     crypt_check_method(crypt_get_method_nr(curbuf));
 }
@@ -531,9 +517,9 @@ crypt_check_current_method()
  * Returns NULL on failure.
  */
     char_u *
-crypt_get_key(store, twice)
+crypt_get_key(
-    int		store;
+    int		store,
-    int		twice;	    /* Ask for the key twice. */
+    int		twice)	    /* Ask for the key twice. */
 {
     char_u	*p1, *p2 = NULL;
     int		round;
@@ -589,8 +575,8 @@ crypt_get_key(store, twice)
  * Append a message to IObuff for the encryption/decryption method being used.
  */
     void
-crypt_append_msg(buf)
+crypt_append_msg(
-    buf_T *buf;
+    buf_T *buf)
 {
     if (crypt_get_method_nr(buf) == 0)
 	STRCAT(IObuff, _("[crypted]"));

src/crypt_zip.c

@@ -44,7 +44,7 @@ static u32_T crc_32_table[256];
  * Fill the CRC table, if not done already.
  */
     static void
-make_crc_tab()
+make_crc_tab(void)
 {
     u32_T	s, t, v;
     static int	done = FALSE;
@@ -85,13 +85,13 @@ make_crc_tab()
  * Initialize for encryption/decryption.
  */
     void
-crypt_zip_init(state, key, salt, salt_len, seed, seed_len)
+crypt_zip_init(
-    cryptstate_T    *state;
+    cryptstate_T    *state,
-    char_u	    *key;
+    char_u	    *key,
-    char_u	    *salt UNUSED;
+    char_u	    *salt UNUSED,
-    int		    salt_len UNUSED;
+    int		    salt_len UNUSED,
-    char_u	    *seed UNUSED;
+    char_u	    *seed UNUSED,
-    int		    seed_len UNUSED;
+    int		    seed_len UNUSED)
 {
     char_u	*p;
     zip_state_T	*zs;
@@ -114,11 +114,11 @@ crypt_zip_init(state, key, salt, salt_len, seed, seed_len)
  * "from" and "to" can be equal to encrypt in place.
  */
     void
-crypt_zip_encode(state, from, len, to)
+crypt_zip_encode(
-    cryptstate_T *state;
+    cryptstate_T *state,
-    char_u	*from;
+    char_u	*from,
-    size_t	len;
+    size_t	len,
-    char_u	*to;
+    char_u	*to)
 {
     zip_state_T *zs = state->method_state;
     size_t	i;
@@ -137,11 +137,11 @@ crypt_zip_encode(state, from, len, to)
  * Decrypt "from[len]" into "to[len]".
  */
     void
-crypt_zip_decode(state, from, len, to)
+crypt_zip_decode(
-    cryptstate_T *state;
+    cryptstate_T *state,
-    char_u	*from;
+    char_u	*from,
-    size_t	len;
+    size_t	len,
-    char_u	*to;
+    char_u	*to)
 {
     zip_state_T *zs = state->method_state;
     size_t	i;

src/diff.c

@@ -60,8 +60,7 @@ static diff_T *diff_alloc_new(tabpage_T *tp, diff_T *dprev, diff_T *dp);
  * Called when deleting or unloading a buffer: No longer make a diff with it.
  */
     void
-diff_buf_delete(buf)
+diff_buf_delete(buf_T *buf)
-    buf_T	*buf;
 {
     int		i;
     tabpage_T	*tp;
@@ -84,8 +83,7 @@ diff_buf_delete(buf)
  * diff buffers.
  */
     void
-diff_buf_adjust(win)
+diff_buf_adjust(win_T *win)
-    win_T	*win;
 {
     win_T	*wp;
     int		i;
@@ -121,8 +119,7 @@ diff_buf_adjust(win)
  * about the screen contents.
  */
     void
-diff_buf_add(buf)
+diff_buf_add(buf_T *buf)
-    buf_T	*buf;
 {
     int		i;
 
@@ -146,8 +143,7 @@ diff_buf_add(buf)
  * Return its index or DB_COUNT if not found.
  */
     static int
-diff_buf_idx(buf)
+diff_buf_idx(buf_T *buf)
-    buf_T	*buf;
 {
     int		idx;
 
@@ -162,9 +158,7 @@ diff_buf_idx(buf)
  * Return its index or DB_COUNT if not found.
  */
     static int
-diff_buf_idx_tp(buf, tp)
+diff_buf_idx_tp(buf_T *buf, tabpage_T *tp)
-    buf_T	*buf;
-    tabpage_T	*tp;
 {
     int		idx;
 
@@ -179,8 +173,7 @@ diff_buf_idx_tp(buf, tp)
  * when info is requested.
  */
     void
-diff_invalidate(buf)
+diff_invalidate(buf_T *buf)
-    buf_T	*buf;
 {
     tabpage_T	*tp;
     int		i;
@@ -201,11 +194,11 @@ diff_invalidate(buf)
  * Called by mark_adjust(): update line numbers in "curbuf".
  */
     void
-diff_mark_adjust(line1, line2, amount, amount_after)
+diff_mark_adjust(
-    linenr_T	line1;
+    linenr_T	line1,
-    linenr_T	line2;
+    linenr_T	line2,
-    long	amount;
+    long	amount,
-    long	amount_after;
+    long	amount_after)
 {
     int		idx;
     tabpage_T	*tp;
@@ -227,13 +220,13 @@ diff_mark_adjust(line1, line2, amount, amount_after)
  * When inserting/deleting lines in existing change blocks, update them.
  */
     static void
-diff_mark_adjust_tp(tp, idx, line1, line2, amount, amount_after)
+diff_mark_adjust_tp(
-    tabpage_T	*tp;
+    tabpage_T	*tp,
-    int		idx;
+    int		idx,
-    linenr_T	line1;
+    linenr_T	line1,
-    linenr_T	line2;
+    linenr_T	line2,
-    long	amount;
+    long	amount,
-    long	amount_after;
+    long	amount_after)
 {
     diff_T	*dp;
     diff_T	*dprev;
@@ -479,10 +472,7 @@ diff_mark_adjust_tp(tp, idx, line1, line2, amount, amount_after)
  * Allocate a new diff block and link it between "dprev" and "dp".
  */
     static diff_T *
-diff_alloc_new(tp, dprev, dp)
+diff_alloc_new(tabpage_T *tp, diff_T *dprev, diff_T *dp)
-    tabpage_T	*tp;
-    diff_T	*dprev;
-    diff_T	*dp;
 {
     diff_T	*dnew;
 
@@ -505,9 +495,7 @@ diff_alloc_new(tp, dprev, dp)
  * must take care of removing it.
  */
     static void
-diff_check_unchanged(tp, dp)
+diff_check_unchanged(tabpage_T *tp, diff_T *dp)
-    tabpage_T	*tp;
-    diff_T	*dp;
 {
     int		i_org;
     int		i_new;
@@ -581,9 +569,7 @@ diff_check_unchanged(tp, dp)
  * This can happen when the diff program returns invalid results.
  */
     static int
-diff_check_sanity(tp, dp)
+diff_check_sanity(tabpage_T *tp, diff_T *dp)
-    tabpage_T	*tp;
-    diff_T	*dp;
 {
     int		i;
 
@@ -599,8 +585,8 @@ diff_check_sanity(tp, dp)
  * Mark all diff buffers in the current tab page for redraw.
  */
     static void
-diff_redraw(dofold)
+diff_redraw(
-    int		dofold;	    /* also recompute the folds */
+    int		dofold)	    /* also recompute the folds */
 {
     win_T	*wp;
     int		n;
@@ -633,9 +619,7 @@ diff_redraw(dofold)
  * Return FAIL for failure
  */
     static int
-diff_write(buf, fname)
+diff_write(buf_T *buf, char_u *fname)
-    buf_T	*buf;
-    char_u	*fname;
 {
     int		r;
     char_u	*save_ff;
@@ -656,8 +640,8 @@ diff_write(buf, fname)
  * could have been produced by autocommands, e.g. the netrw plugin).
  */
     void
-ex_diffupdate(eap)
+ex_diffupdate(
-    exarg_T	*eap UNUSED;	    /* can be NULL */
+    exarg_T	*eap UNUSED)	    /* can be NULL */
 {
     buf_T	*buf;
     int		idx_orig;
@@ -832,10 +816,10 @@ theend:
  * Make a diff between files "tmp_orig" and "tmp_new", results in "tmp_diff".
  */
     static void
-diff_file(tmp_orig, tmp_new, tmp_diff)
+diff_file(
-    char_u	*tmp_orig;
+    char_u	*tmp_orig,
-    char_u	*tmp_new;
+    char_u	*tmp_new,
-    char_u	*tmp_diff;
+    char_u	*tmp_diff)
 {
     char_u	*cmd;
     size_t	len;
@@ -888,8 +872,7 @@ diff_file(tmp_orig, tmp_new, tmp_diff)
  * could have been produced by autocommands, e.g. the netrw plugin).
  */
     void
-ex_diffpatch(eap)
+ex_diffpatch(exarg_T *eap)
-    exarg_T	*eap;
 {
     char_u	*tmp_orig;	/* name of original temp file */
     char_u	*tmp_new;	/* name of patched temp file */
@@ -1083,8 +1066,7 @@ theend:
  * Split the window and edit another file, setting options to show the diffs.
  */
     void
-ex_diffsplit(eap)
+ex_diffsplit(exarg_T *eap)
-    exarg_T	*eap;
 {
     win_T	*old_curwin = curwin;
     buf_T	*old_curbuf = curbuf;
@@ -1126,8 +1108,7 @@ ex_diffsplit(eap)
  * Set options to show diffs for the current window.
  */
     void
-ex_diffthis(eap)
+ex_diffthis(exarg_T *eap UNUSED)
-    exarg_T	*eap UNUSED;
 {
     /* Set 'diff', 'scrollbind' on and 'wrap' off. */
     diff_win_options(curwin, TRUE);
@@ -1137,9 +1118,9 @@ ex_diffthis(eap)
  * Set options in window "wp" for diff mode.
  */
     void
-diff_win_options(wp, addbuf)
+diff_win_options(
-    win_T	*wp;
+    win_T	*wp,
-    int		addbuf;		/* Add buffer to diff. */
+    int		addbuf)		/* Add buffer to diff. */
 {
 # ifdef FEAT_FOLDING
     win_T *old_curwin = curwin;
@@ -1209,8 +1190,7 @@ diff_win_options(wp, addbuf)
  * Only in the current tab page.
  */
     void
-ex_diffoff(eap)
+ex_diffoff(exarg_T *eap)
-    exarg_T	*eap;
 {
     win_T	*wp;
 #ifdef FEAT_SCROLLBIND
@@ -1279,10 +1259,10 @@ ex_diffoff(eap)
  * Read the diff output and add each entry to the diff list.
  */
     static void
-diff_read(idx_orig, idx_new, fname)
+diff_read(
-    int		idx_orig;	/* idx of original file */
+    int		idx_orig,	/* idx of original file */
-    int		idx_new;	/* idx of new file */
+    int		idx_new,	/* idx of new file */
-    char_u	*fname;		/* name of diff output file */
+    char_u	*fname)		/* name of diff output file */
 {
     FILE	*fd;
     diff_T	*dprev = NULL;
@@ -1473,11 +1453,11 @@ done:
  * Copy an entry at "dp" from "idx_orig" to "idx_new".
  */
     static void
-diff_copy_entry(dprev, dp, idx_orig, idx_new)
+diff_copy_entry(
-    diff_T	*dprev;
+    diff_T	*dprev,
-    diff_T	*dp;
+    diff_T	*dp,
-    int		idx_orig;
+    int		idx_orig,
-    int		idx_new;
+    int		idx_new)
 {
     long	off;
 
@@ -1494,8 +1474,7 @@ diff_copy_entry(dprev, dp, idx_orig, idx_new)
  * Clear the list of diffblocks for tab page "tp".
  */
     void
-diff_clear(tp)
+diff_clear(tabpage_T *tp)
-    tabpage_T	*tp;
 {
     diff_T	*p, *next_p;
 
@@ -1517,9 +1496,7 @@ diff_clear(tp)
  * This should only be used for windows where 'diff' is set.
  */
     int
-diff_check(wp, lnum)
+diff_check(win_T *wp, linenr_T lnum)
-    win_T	*wp;
-    linenr_T	lnum;
 {
     int		idx;		/* index in tp_diffbuf[] for this buffer */
     diff_T	*dp;
@@ -1611,10 +1588,7 @@ diff_check(wp, lnum)
  * Compare two entries in diff "*dp" and return TRUE if they are equal.
  */
     static int
-diff_equal_entry(dp, idx1, idx2)
+diff_equal_entry(diff_T *dp, int idx1, int idx2)
-    diff_T	*dp;
-    int		idx1;
-    int		idx2;
 {
     int		i;
     char_u	*line;
@@ -1644,9 +1618,7 @@ diff_equal_entry(dp, idx1, idx2)
  * Return non-zero when they are different.
  */
     static int
-diff_cmp(s1, s2)
+diff_cmp(char_u *s1, char_u *s2)
-    char_u	*s1;
-    char_u	*s2;
 {
     char_u	*p1, *p2;
 #ifdef FEAT_MBYTE
@@ -1709,9 +1681,7 @@ diff_cmp(s1, s2)
  * Return the number of filler lines above "lnum".
  */
     int
-diff_check_fill(wp, lnum)
+diff_check_fill(win_T *wp, linenr_T lnum)
-    win_T	*wp;
-    linenr_T	lnum;
 {
     int		n;
 
@@ -1729,9 +1699,7 @@ diff_check_fill(wp, lnum)
  * show the same diff'ed lines.
  */
     void
-diff_set_topline(fromwin, towin)
+diff_set_topline(win_T *fromwin, win_T *towin)
-    win_T	*fromwin;
-    win_T	*towin;
 {
     buf_T	*frombuf = fromwin->w_buffer;
     linenr_T	lnum = fromwin->w_topline;
@@ -1851,7 +1819,7 @@ diff_set_topline(fromwin, towin)
  * This is called when 'diffopt' is changed.
  */
     int
-diffopt_changed()
+diffopt_changed(void)
 {
     char_u	*p;
     int		diff_context_new = 6;
@@ -1929,7 +1897,7 @@ diffopt_changed()
  * Return TRUE if 'diffopt' contains "horizontal".
  */
     int
-diffopt_horizontal()
+diffopt_horizontal(void)
 {
     return (diff_flags & DIFF_HORIZONTAL) != 0;
 }
@@ -1939,11 +1907,11 @@ diffopt_horizontal()
  * Returns TRUE if the line was added, no other buffer has it.
  */
     int
-diff_find_change(wp, lnum, startp, endp)
+diff_find_change(
-    win_T	*wp;
+    win_T	*wp,
-    linenr_T	lnum;
+    linenr_T	lnum,
-    int		*startp;	/* first char of the change */
+    int		*startp,	/* first char of the change */
-    int		*endp;		/* last char of the change */
+    int		*endp)		/* last char of the change */
 {
     char_u	*line_org;
     char_u	*line_new;
@@ -2063,9 +2031,7 @@ diff_find_change(wp, lnum, startp, endp)
  * Return FALSE if there are no diff blocks at all in this window.
  */
     int
-diff_infold(wp, lnum)
+diff_infold(win_T *wp, linenr_T lnum)
-    win_T	*wp;
-    linenr_T	lnum;
 {
     int		i;
     int		idx = -1;
@@ -2112,9 +2078,7 @@ diff_infold(wp, lnum)
  * "dp" and "do" commands.
  */
     void
-nv_diffgetput(put, count)
+nv_diffgetput(int put, long count)
-    int		put;
-    long	count;
 {
     exarg_T	ea;
     char_u	buf[30];
@@ -2141,8 +2105,7 @@ nv_diffgetput(put, count)
  * ":diffput"
  */
     void
-ex_diffgetput(eap)
+ex_diffgetput(exarg_T *eap)
-    exarg_T	*eap;
 {
     linenr_T	lnum;
     int		count;
@@ -2464,9 +2427,7 @@ ex_diffgetput(eap)
  * When there are no diffs, all folds are removed.
  */
     static void
-diff_fold_update(dp, skip_idx)
+diff_fold_update(diff_T *dp, int skip_idx)
-    diff_T	*dp;
-    int		skip_idx;
 {
     int		i;
     win_T	*wp;
@@ -2483,8 +2444,7 @@ diff_fold_update(dp, skip_idx)
  * Return TRUE if buffer "buf" is in diff-mode.
  */
     int
-diff_mode_buf(buf)
+diff_mode_buf(buf_T *buf)
-    buf_T	*buf;
 {
     tabpage_T	*tp;
 
@@ -2499,9 +2459,7 @@ diff_mode_buf(buf)
  * Return FAIL if there isn't such a diff block.
  */
     int
-diff_move_to(dir, count)
+diff_move_to(int dir, long count)
-    int		dir;
-    long	count;
 {
     int		idx;
     linenr_T	lnum = curwin->w_cursor.lnum;
@@ -2554,11 +2512,11 @@ diff_move_to(dir, count)
 }
 
     linenr_T
-diff_get_corresponding_line(buf1, lnum1, buf2, lnum3)
+diff_get_corresponding_line(
-    buf_T	*buf1;
+    buf_T	*buf1,
-    linenr_T	lnum1;
+    linenr_T	lnum1,
-    buf_T	*buf2;
+    buf_T	*buf2,
-    linenr_T	lnum3;
+    linenr_T	lnum3)
 {
     int		idx1;
     int		idx2;
@@ -2628,9 +2586,7 @@ diff_get_corresponding_line(buf1, lnum1, buf2, lnum3)
  * "wp", compensating for inserted/deleted lines.
  */
     linenr_T
-diff_lnum_win(lnum, wp)
+diff_lnum_win(linenr_T lnum, win_T *wp)
-    linenr_T	lnum;
-    win_T	*wp;
 {
     diff_T	*dp;
     int		idx;

src/digraph.c

@@ -2013,8 +2013,7 @@ static digr_T digraphdefault[] =
  * handle digraphs after typing a character
  */
     int
-do_digraph(c)
+do_digraph(int c)
-    int	    c;
 {
     static int	backspaced;	/* character before K_BS */
     static int	lastchar;	/* last typed character */
@@ -2041,8 +2040,8 @@ do_digraph(c)
  * Returns composed character, or NUL when ESC was used.
  */
     int
-get_digraph(cmdline)
+get_digraph(
-    int		cmdline;	/* TRUE when called from the cmdline */
+    int		cmdline)	/* TRUE when called from the cmdline */
 {
     int		c, cc;
 
@@ -2085,10 +2084,7 @@ get_digraph(cmdline)
  * If "meta_char" is TRUE and "char1" is a space, return "char2" | 0x80.
  */
     static int
-getexactdigraph(char1, char2, meta_char)
+getexactdigraph(int char1, int char2, int meta_char)
-    int		char1;
-    int		char2;
-    int		meta_char;
 {
     int		i;
     int		retval = 0;
@@ -2173,10 +2169,7 @@ getexactdigraph(char1, char2, meta_char)
  * Allow for both char1-char2 and char2-char1
  */
     int
-getdigraph(char1, char2, meta_char)
+getdigraph(int char1, int char2, int meta_char)
-    int	char1;
-    int	char2;
-    int	meta_char;
 {
     int	    retval;
 
@@ -2192,8 +2185,7 @@ getdigraph(char1, char2, meta_char)
  * format: {c1}{c2} char {c1}{c2} char ...
  */
     void
-putdigraph(str)
+putdigraph(char_u *str)
-    char_u *str;
 {
     int		char1, char2, n;
     int		i;
@@ -2252,7 +2244,7 @@ putdigraph(str)
 }
 
     void
-listdigraphs()
+listdigraphs(void)
 {
     int		i;
     digr_T	*dp;
@@ -2297,8 +2289,7 @@ listdigraphs()
 }
 
     static void
-printdigraph(dp)
+printdigraph(digr_T *dp)
-    digr_T	*dp;
 {
     char_u	buf[30];
     char_u	*p;
@@ -2366,7 +2357,7 @@ static void keymap_unload(void);
  * checked.
  */
     char_u *
-keymap_init()
+keymap_init(void)
 {
     curbuf->b_kmap_state &= ~KEYMAP_INIT;
 
@@ -2419,8 +2410,7 @@ keymap_init()
  * ":loadkeymap" command: load the following lines as the keymap.
  */
     void
-ex_loadkeymap(eap)
+ex_loadkeymap(exarg_T *eap)
-    exarg_T	*eap;
 {
     char_u	*line;
     char_u	*p;
@@ -2505,7 +2495,7 @@ ex_loadkeymap(eap)
  * Stop using 'keymap'.
  */
     static void
-keymap_unload()
+keymap_unload(void)
 {
     char_u	buf[KMAP_MAXLEN + 10];
     int		i;

src/version.c

@@ -746,6 +746,8 @@ static char *(features[]) =
 
 static int included_patches[] =
 {   /* Add new patch number below this line */
+/**/
+    1205,
 /**/
     1204,
 /**/