vim: src/undo.c comparison

comparison src/undo.c @ 7835:4d7ce6c03fda v7.4.1214

commit https://github.com/vim/vim/commit/764b23c8fd3369cb05ae9122abf3ca16fec539d7 Author: Bram Moolenaar <Bram@vim.org> Date: Sat Jan 30 21:10:09 2016 +0100 patch 7.4.1214 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:15:04 +0100
parents	0b6c37dd858d
children	985cd5917560

comparison

equal deleted inserted replaced

-:2d1dc9ec41ce
+:4d7ce6c03fda
 * Save the current line for both the "u" and "U" command.
 * Careful: may trigger autocommands that reload the buffer.
 * Returns OK or FAIL.
 */
 int
-u_save_cursor()
+u_save_cursor(void)
 {
 return (u_save((linenr_T)(curwin->w_cursor.lnum - 1),
 				      (linenr_T)(curwin->w_cursor.lnum + 1)));
 }
 * "top" may be 0 and bot may be curbuf->b_ml.ml_line_count + 1.
 * Careful: may trigger autocommands that reload the buffer.
 * Returns FAIL when lines could not be saved, OK otherwise.
 */
 int
-u_save(top, bot)
+u_save(linenr_T top, linenr_T bot)
-linenr_T top, bot;
 {
 if (undo_off)
 	return OK;
 if (top > curbuf->b_ml.ml_line_count
 * The line is replaced, so the new bottom line is lnum + 1.
 * Careful: may trigger autocommands that reload the buffer.
 * Returns FAIL when lines could not be saved, OK otherwise.
 */
 int
-u_savesub(lnum)
+u_savesub(linenr_T lnum)
-linenr_T	lnum;
 {
 if (undo_off)
 	return OK;
 return (u_savecommon(lnum - 1, lnum + 1, lnum + 1, FALSE));
 * The line is inserted, so the new bottom line is lnum + 1.
 * Careful: may trigger autocommands that reload the buffer.
 * Returns FAIL when lines could not be saved, OK otherwise.
 */
 int
-u_inssub(lnum)
+u_inssub(linenr_T lnum)
-linenr_T	lnum;
 {
 if (undo_off)
 	return OK;
 return (u_savecommon(lnum - 1, lnum, lnum + 1, FALSE));
 * becomes empty.
 * Careful: may trigger autocommands that reload the buffer.
 * Returns FAIL when lines could not be saved, OK otherwise.
 */
 int
-u_savedel(lnum, nlines)
+u_savedel(linenr_T lnum, long nlines)
-linenr_T	lnum;
-long	nlines;
 {
 if (undo_off)
 	return OK;
 return (u_savecommon(lnum - 1, lnum + nlines,
 /*
 * Return TRUE when undo is allowed.  Otherwise give an error message and
 * return FALSE.
 */
 int
-undo_allowed()
+undo_allowed(void)
 {
 /* Don't allow changes when 'modifiable' is off.  */
 if (!curbuf->b_p_ma)
 {
 	EMSG(_(e_modifiable));
 /*
 * Get the undolevle value for the current buffer.
 */
 static long
-get_undolevel()
+get_undolevel(void)
 {
 if (curbuf->b_p_ul == NO_LOCAL_UNDOLEVEL)
 	return p_ul;
 return curbuf->b_p_ul;
 }
 * "reload" is TRUE when saving for a buffer reload.
 * Careful: may trigger autocommands that reload the buffer.
 * Returns FAIL when lines could not be saved, OK otherwise.
 */
 int
-u_savecommon(top, bot, newbot, reload)
+u_savecommon(
-linenr_T	top, bot;
+linenr_T	top,
-linenr_T	newbot;
+linenr_T	bot,
-int		reload;
+linenr_T	newbot,
+int		reload)
 {
 linenr_T	lnum;
 long	i;
 u_header_T	*uhp;
 u_header_T	*old_curhead;
 /*
 * Compute the hash for the current buffer text into hash[UNDO_HASH_SIZE].
 */
 void
-u_compute_hash(hash)
+u_compute_hash(char_u *hash)
-char_u *hash;
 {
 context_sha256_T	ctx;
 linenr_T		lnum;
 char_u		*p;
 * 'undodir'.
 * When "reading" is FALSE use the first name where the directory exists.
 * Returns NULL when there is no place to write or no file to read.
 */
 char_u *
-u_get_undo_file_name(buf_ffname, reading)
+u_get_undo_file_name(char_u *buf_ffname, int reading)
-char_u	*buf_ffname;
-int		reading;
 {
 char_u	*dirp;
 char_u	dir_name[IOSIZE + 1];
 char_u	*munged_name = NULL;
 char_u	*undo_file_name = NULL;
 vim_free(munged_name);
 return undo_file_name;
 }
 static void
-corruption_error(mesg, file_name)
+corruption_error(char *mesg, char_u *file_name)
-char *mesg;
-char_u *file_name;
 {
 EMSG3(_("E825: Corrupted undo file (%s): %s"), mesg, file_name);
 }
 static void
-u_free_uhp(uhp)
+u_free_uhp(u_header_T *uhp)
-u_header_T	*uhp;
 {
 u_entry_T	*nuep;
 u_entry_T	*uep;
 uep = uhp->uh_entry;
 * Write a sequence of bytes to the undo file.
 * Buffers and encrypts as needed.
 * Returns OK or FAIL.
 */
 static int
-undo_write(bi, ptr, len)
+undo_write(bufinfo_T *bi, char_u *ptr, size_t len)
-bufinfo_T	*bi;
-char_u	*ptr;
-size_t	len;
 {
 #ifdef FEAT_CRYPT
 if (bi->bi_buffer != NULL)
 {
 	size_t	len_todo = len;
 return OK;
 }
 #ifdef FEAT_CRYPT
 static int
-undo_flush(bi)
+undo_flush(bufinfo_T *bi)
-bufinfo_T	*bi;
 {
 if (bi->bi_buffer != NULL && bi->bi_used > 0)
 {
 	crypt_encode_inplace(bi->bi_state, bi->bi_buffer, bi->bi_used);
 	if (fwrite(bi->bi_buffer, bi->bi_used, (size_t)1, bi->bi_fp) != 1)
 /*
 * Write "ptr[len]" and crypt the bytes when needed.
 * Returns OK or FAIL.
 */
 static int
-fwrite_crypt(bi, ptr, len)
+fwrite_crypt(bufinfo_T *bi, char_u *ptr, size_t len)
-bufinfo_T	*bi;
-char_u	*ptr;
-size_t	len;
 {
 #ifdef FEAT_CRYPT
 char_u  *copy;
 char_u  small_buf[100];
 size_t  i;
 * Write a number, MSB first, in "len" bytes.
 * Must match with undo_read_?c() functions.
 * Returns OK or FAIL.
 */
 static int
-undo_write_bytes(bi, nr, len)
+undo_write_bytes(bufinfo_T *bi, long_u nr, int len)
-bufinfo_T *bi;
-long_u  nr;
-int	    len;
 {
 char_u  buf[8];
 int	    i;
 int	    bufi = 0;
 /*
 * Write the pointer to an undo header.  Instead of writing the pointer itself
 * we use the sequence number of the header.  This is converted back to
 * pointers when reading. */
 static void
-put_header_ptr(bi, uhp)
+put_header_ptr(bufinfo_T *bi, u_header_T *uhp)
-bufinfo_T	*bi;
-u_header_T	*uhp;
 {
 undo_write_bytes(bi, (long_u)(uhp != NULL ? uhp->uh_seq : 0), 4);
 }
 static int
-undo_read_4c(bi)
+undo_read_4c(bufinfo_T *bi)
-bufinfo_T	*bi;
 {
 #ifdef FEAT_CRYPT
 if (bi->bi_buffer != NULL)
 {
 	char_u  buf[4];
 #endif
 return get4c(bi->bi_fp);
 }
 static int
-undo_read_2c(bi)
+undo_read_2c(bufinfo_T *bi)
-bufinfo_T	*bi;
 {
 #ifdef FEAT_CRYPT
 if (bi->bi_buffer != NULL)
 {
 	char_u  buf[2];
 #endif
 return get2c(bi->bi_fp);
 }
 static int
-undo_read_byte(bi)
+undo_read_byte(bufinfo_T *bi)
-bufinfo_T	*bi;
 {
 #ifdef FEAT_CRYPT
 if (bi->bi_buffer != NULL)
 {
 	char_u  buf[1];
 #endif
 return getc(bi->bi_fp);
 }
 static time_t
-undo_read_time(bi)
+undo_read_time(bufinfo_T *bi)
-bufinfo_T	*bi;
 {
 #ifdef FEAT_CRYPT
 if (bi->bi_buffer != NULL)
 {
 	char_u  buf[8];
 /*
 * Read "buffer[size]" from the undo file.
 * Return OK or FAIL.
 */
 static int
-undo_read(bi, buffer, size)
+undo_read(bufinfo_T *bi, char_u *buffer, size_t size)
-bufinfo_T   *bi;
-char_u	*buffer;
-size_t	size;
 {
 #ifdef FEAT_CRYPT
 if (bi->bi_buffer != NULL)
 {
 	int	size_todo = (int)size;
 * Decrypt the bytes if needed.
 * Append a NUL.
 * Returns a pointer to allocated memory or NULL for failure.
 */
 static char_u *
-read_string_decrypt(bi, len)
+read_string_decrypt(bufinfo_T *bi, int len)
-bufinfo_T	*bi;
-int		len;
 {
 char_u  *ptr = alloc((unsigned)len + 1);
 if (ptr != NULL)
 {
 /*
 * Writes the (not encrypted) header and initializes encryption if needed.
 */
 static int
-serialize_header(bi, hash)
+serialize_header(bufinfo_T *bi, char_u *hash)
-bufinfo_T	*bi;
-char_u	*hash;
 {
 int		len;
 buf_T	*buf = bi->bi_buf;
 FILE	*fp = bi->bi_fp;
 char_u	time_buf[8];
 return OK;
 }
 static int
-serialize_uhp(bi, uhp)
+serialize_uhp(bufinfo_T *bi, u_header_T *uhp)
-bufinfo_T	*bi;
-u_header_T	*uhp;
 {
 int		i;
 u_entry_T	*uep;
 char_u	time_buf[8];
 undo_write_bytes(bi, (long_u)UF_ENTRY_END_MAGIC, 2);
 return OK;
 }
 static u_header_T *
-unserialize_uhp(bi, file_name)
+unserialize_uhp(bufinfo_T *bi, char_u *file_name)
-bufinfo_T	*bi;
-char_u	*file_name;
 {
 u_header_T	*uhp;
 int		i;
 u_entry_T	*uep, *last_uep;
 int		c;
 /*
 * Serialize "uep".
 */
 static int
-serialize_uep(bi, uep)
+serialize_uep(
-bufinfo_T	*bi;
+bufinfo_T	*bi,
-u_entry_T	*uep;
+u_entry_T	*uep)
 {
 int		i;
 size_t	len;
 undo_write_bytes(bi, (long_u)uep->ue_top, 4);
 }
 return OK;
 }
 static u_entry_T *
-unserialize_uep(bi, error, file_name)
+unserialize_uep(bufinfo_T *bi, int *error, char_u *file_name)
-bufinfo_T	*bi;
-int		*error;
-char_u	*file_name;
 {
 int		i;
 u_entry_T	*uep;
 char_u	**array;
 char_u	*line;
 /*
 * Serialize "pos".
 */
 static void
-serialize_pos(bi, pos)
+serialize_pos(bufinfo_T *bi, pos_T pos)
-bufinfo_T *bi;
-pos_T pos;
 {
 undo_write_bytes(bi, (long_u)pos.lnum, 4);
 undo_write_bytes(bi, (long_u)pos.col, 4);
 #ifdef FEAT_VIRTUALEDIT
 undo_write_bytes(bi, (long_u)pos.coladd, 4);
 /*
 * Unserialize the pos_T at the current position.
 */
 static void
-unserialize_pos(bi, pos)
+unserialize_pos(bufinfo_T *bi, pos_T *pos)
-bufinfo_T *bi;
-pos_T *pos;
 {
 pos->lnum = undo_read_4c(bi);
 if (pos->lnum < 0)
 	pos->lnum = 0;
 pos->col = undo_read_4c(bi);
 /*
 * Serialize "info".
 */
 static void
-serialize_visualinfo(bi, info)
+serialize_visualinfo(bufinfo_T *bi, visualinfo_T *info)
-bufinfo_T	    *bi;
-visualinfo_T    *info;
 {
 serialize_pos(bi, info->vi_start);
 serialize_pos(bi, info->vi_end);
 undo_write_bytes(bi, (long_u)info->vi_mode, 4);
 undo_write_bytes(bi, (long_u)info->vi_curswant, 4);
 /*
 * Unserialize the visualinfo_T at the current position.
 */
 static void
-unserialize_visualinfo(bi, info)
+unserialize_visualinfo(bufinfo_T *bi, visualinfo_T *info)
-bufinfo_T	    *bi;
-visualinfo_T    *info;
 {
 unserialize_pos(bi, &info->vi_start);
 unserialize_pos(bi, &info->vi_end);
 info->vi_mode = undo_read_4c(bi);
 info->vi_curswant = undo_read_4c(bi);
 * permissions.
 * "forceit" is TRUE for ":wundo!", FALSE otherwise.
 * "hash[UNDO_HASH_SIZE]" must be the hash value of the buffer text.
 */
 void
-u_write_undo(name, forceit, buf, hash)
+u_write_undo(
-char_u	*name;
+char_u	*name,
-int		forceit;
+int		forceit,
-buf_T	*buf;
+buf_T	*buf,
-char_u	*hash;
+char_u	*hash)
 {
 u_header_T	*uhp;
 char_u	*file_name;
 int		mark;
 #ifdef U_DEBUG
 * a bit more verbose.
 * Otherwise use curbuf->b_ffname to generate the undo file name.
 * "hash[UNDO_HASH_SIZE]" must be the hash value of the buffer text.
 */
 void
-u_read_undo(name, hash, orig_name)
+u_read_undo(char_u *name, char_u *hash, char_u *orig_name)
-char_u *name;
-char_u *hash;
-char_u *orig_name;
 {
 char_u	*file_name;
 FILE	*fp;
 long	version, str_len;
 char_u	*line_ptr = NULL;
 /*
 * If 'cpoptions' contains 'u': Undo the previous undo or redo (vi compatible).
 * If 'cpoptions' does not contain 'u': Always undo.
 */
 void
-u_undo(count)
+u_undo(int count)
-int count;
 {
 /*
 * If we get an undo command while executing a macro, we behave like the
 * original vi. If this happens twice in one macro the result will not
 * be compatible.
 /*
 * If 'cpoptions' contains 'u': Repeat the previous undo or redo.
 * If 'cpoptions' does not contain 'u': Always redo.
 */
 void
-u_redo(count)
+u_redo(int count)
-int count;
 {
 if (vim_strchr(p_cpo, CPO_UNDO) == NULL)
 	undo_undoes = FALSE;
 u_doit(count);
 }
 /*
 * Undo or redo, depending on 'undo_undoes', 'count' times.
 */
 static void
-u_doit(startcount)
+u_doit(int startcount)
-int startcount;
 {
 int count = startcount;
 if (!undo_allowed())
 	return;
 * When "file" is TRUE use "step" as a number of file writes.
 * When "absolute" is TRUE use "step" as the sequence number to jump to.
 * "sec" must be FALSE then.
 */
 void
-undo_time(step, sec, file, absolute)
+undo_time(
-long	step;
+long	step,
-int		sec;
+int		sec,
-int		file;
+int		file,
-int		absolute;
+int		absolute)
 {
 long	    target;
 long	    closest;
 long	    closest_start;
 long	    closest_seq = 0;
 * list for the next undo/redo.
 *
 * When "undo" is TRUE we go up in the tree, when FALSE we go down.
 */
 static void
-u_undoredo(undo)
+u_undoredo(int undo)
-int		undo;
 {
 char_u	**newarray = NULL;
 linenr_T	oldsize;
 linenr_T	newsize;
 linenr_T	top, bot;
 * If we deleted or added lines, report the number of less/more lines.
 * Otherwise, report the number of changes (this may be incorrect
 * in some cases, but it's better than nothing).
 */
 static void
-u_undo_end(did_undo, absolute)
+u_undo_end(
-int		did_undo;	/* just did an undo */
+int		did_undo,	/* just did an undo */
-int		absolute;	/* used ":undo N" */
+int		absolute)	/* used ":undo N" */
 {
 char	*msgstr;
 u_header_T	*uhp;
 char_u	msgbuf[80];
 /*
 * u_sync: stop adding to the current entry list
 */
 void
-u_sync(force)
+u_sync(
-int	    force;	/* Also sync when no_u_sync is set. */
+int	    force)	/* Also sync when no_u_sync is set. */
 {
 /* Skip it when already synced or syncing is disabled. */
 if (curbuf->b_u_synced || (!force && no_u_sync > 0))
 	return;
 #if defined(FEAT_XIM) && defined(FEAT_GUI_GTK)
 /*
 * ":undolist": List the leafs of the undo tree
 */
 void
-ex_undolist(eap)
+ex_undolist(exarg_T *eap UNUSED)
-exarg_T *eap UNUSED;
 {
 garray_T	ga;
 u_header_T	*uhp;
 int		mark;
 int		nomark;
 /*
 * Put the timestamp of an undo header in "buf[buflen]" in a nice format.
 */
 static void
-u_add_time(buf, buflen, tt)
+u_add_time(char_u *buf, size_t buflen, time_t tt)
-char_u	*buf;
-size_t	buflen;
-time_t	tt;
 {
 #ifdef HAVE_STRFTIME
 struct tm	*curtime;
 if (time(NULL) - tt >= 100)
 /*
 * ":undojoin": continue adding to the last entry list
 */
 void
-ex_undojoin(eap)
+ex_undojoin(exarg_T *eap UNUSED)
-exarg_T *eap UNUSED;
 {
 if (curbuf->b_u_newhead == NULL)
 	return;		    /* nothing changed before */
 if (curbuf->b_u_curhead != NULL)
 {
 /*
 * Called after writing or reloading the file and setting b_changed to FALSE.
 * Now an undo means that the buffer is modified.
 */
 void
-u_unchanged(buf)
+u_unchanged(buf_T *buf)
-buf_T	*buf;
 {
 u_unch_branch(buf->b_u_oldhead);
 buf->b_did_warn = FALSE;
 }
 /*
 * After reloading a buffer which was saved for 'undoreload': Find the first
 * line that was changed and set the cursor there.
 */
 void
-u_find_first_changed()
+u_find_first_changed(void)
 {
 u_header_T	*uhp = curbuf->b_u_newhead;
 u_entry_T   *uep;
 linenr_T	lnum;
 /*
 * Increase the write count, store it in the last undo header, what would be
 * used for "u".
 */
 void
-u_update_save_nr(buf)
+u_update_save_nr(buf_T *buf)
-buf_T *buf;
 {
 u_header_T	*uhp;
 ++buf->b_u_save_nr_last;
 buf->b_u_save_nr_cur = buf->b_u_save_nr_last;
 if (uhp != NULL)
 	uhp->uh_save_nr = buf->b_u_save_nr_last;
 }
 static void
-u_unch_branch(uhp)
+u_unch_branch(u_header_T *uhp)
-u_header_T	*uhp;
 {
 u_header_T	*uh;
 for (uh = uhp; uh != NULL; uh = uh->uh_prev.ptr)
 {
 /*
 * Get pointer to last added entry.
 * If it's not valid, give an error message and return NULL.
 */
 static u_entry_T *
-u_get_headentry()
+u_get_headentry(void)
 {
 if (curbuf->b_u_newhead == NULL || curbuf->b_u_newhead->uh_entry == NULL)
 {
 	EMSG(_("E439: undo list corrupt"));
 	return NULL;
 /*
 * u_getbot(): compute the line number of the previous u_save
 *		It is called only when b_u_synced is FALSE.
 */
 static void
-u_getbot()
+u_getbot(void)
 {
 u_entry_T	*uep;
 linenr_T	extra;
 uep = u_get_headentry();	/* check for corrupt undo list */
 /*
 * Free one header "uhp" and its entry list and adjust the pointers.
 */
 static void
-u_freeheader(buf, uhp, uhpp)
+u_freeheader(
-buf_T	    *buf;
+buf_T	    *buf,
-u_header_T	    *uhp;
+u_header_T	    *uhp,
-u_header_T	    **uhpp;	/* if not NULL reset when freeing this header */
+u_header_T	    **uhpp)	/* if not NULL reset when freeing this header */
 {
 u_header_T	    *uhap;
 /* When there is an alternate redo list free that branch completely,
 * because we can never go there. */
 /*
 * Free an alternate branch and any following alternate branches.
 */
 static void
-u_freebranch(buf, uhp, uhpp)
+u_freebranch(
-buf_T	    *buf;
+buf_T	    *buf,
-u_header_T	    *uhp;
+u_header_T	    *uhp,
-u_header_T	    **uhpp;	/* if not NULL reset when freeing this header */
+u_header_T	    **uhpp)	/* if not NULL reset when freeing this header */
 {
 u_header_T	    *tofree, *next;
 /* If this is the top branch we may need to use u_freeheader() to update
 * all the pointers. */
 /*
 * Free all the undo entries for one header and the header itself.
 * This means that "uhp" is invalid when returning.
 */
 static void
-u_freeentries(buf, uhp, uhpp)
+u_freeentries(
-buf_T	    *buf;
+buf_T	    *buf,
-u_header_T	    *uhp;
+u_header_T	    *uhp,
-u_header_T	    **uhpp;	/* if not NULL reset when freeing this header */
+u_header_T	    **uhpp)	/* if not NULL reset when freeing this header */
 {
 u_entry_T	    *uep, *nuep;
 /* Check for pointers to the header that become invalid now. */
 if (buf->b_u_curhead == uhp)
 /*
 * free entry 'uep' and 'n' lines in uep->ue_array[]
 */
 static void
-u_freeentry(uep, n)
+u_freeentry(u_entry_T *uep, long n)
-u_entry_T	*uep;
-long	    n;
 {
 while (n > 0)
 	vim_free(uep->ue_array[--n]);
 vim_free((char_u *)uep->ue_array);
 #ifdef U_DEBUG
 /*
 * invalidate the undo buffer; called when storage has already been released
 */
 void
-u_clearall(buf)
+u_clearall(buf_T *buf)
-buf_T	*buf;
 {
 buf->b_u_newhead = buf->b_u_oldhead = buf->b_u_curhead = NULL;
 buf->b_u_synced = TRUE;
 buf->b_u_numhead = 0;
 buf->b_u_line_ptr = NULL;
 /*
 * save the line "lnum" for the "U" command
 */
 void
-u_saveline(lnum)
+u_saveline(linenr_T lnum)
-linenr_T lnum;
 {
 if (lnum == curbuf->b_u_line_lnum)	    /* line is already saved */
 	return;
 if (lnum < 1 || lnum > curbuf->b_ml.ml_line_count) /* should never happen */
 	return;
 /*
 * clear the line saved for the "U" command
 * (this is used externally for crossing a line while in insert mode)
 */
 void
-u_clearline()
+u_clearline(void)
 {
 if (curbuf->b_u_line_ptr != NULL)
 {
 	vim_free(curbuf->b_u_line_ptr);
 	curbuf->b_u_line_ptr = NULL;
 * Differentiation from vi: "U" can be undone with the next "U".
 * We also allow the cursor to be in another line.
 * Careful: may trigger autocommands that reload the buffer.
 */
 void
-u_undoline()
+u_undoline(void)
 {
 colnr_T t;
 char_u  *oldp;
 if (undo_off)
 /*
 * Free all allocated memory blocks for the buffer 'buf'.
 */
 void
-u_blockfree(buf)
+u_blockfree(buf_T *buf)
-buf_T	*buf;
 {
 while (buf->b_u_oldhead != NULL)
 	u_freeheader(buf, buf->b_u_oldhead, NULL);
 vim_free(buf->b_u_line_ptr);
 }
 /*
 * u_save_line(): allocate memory and copy line 'lnum' into it.
 * Returns NULL when out of memory.
 */
 static char_u *
-u_save_line(lnum)
+u_save_line(linenr_T lnum)
-linenr_T	lnum;
 {
 return vim_strsave(ml_get(lnum));
 }
 /*
 * Check if the 'modified' flag is set, or 'ff' has changed (only need to
 * check the first character, because it can only be "dos", "unix" or "mac").
 * "nofile" and "scratch" type buffers are considered to always be unchanged.
 */
 int
-bufIsChanged(buf)
+bufIsChanged(buf_T *buf)
-buf_T	*buf;
 {
 return
 #ifdef FEAT_QUICKFIX
 	    !bt_dontwrite(buf) &&
 #endif
 	    (buf->b_changed || file_ff_differs(buf, TRUE));
 }
 int
-curbufIsChanged()
+curbufIsChanged(void)
 {
 return
 #ifdef FEAT_QUICKFIX
 	!bt_dontwrite(curbuf) &&
 #endif
 /*
 * For undotree(): Append the list of undo blocks at "first_uhp" to "list".
 * Recursive.
 */
 void
-u_eval_tree(first_uhp, list)
+u_eval_tree(u_header_T *first_uhp, list_T *list)
-u_header_T  *first_uhp;
-list_T	*list;
 {
 u_header_T  *uhp = first_uhp;
 dict_T	*dict;
 while (uhp != NULL)

Mercurial > vim

comparison src/undo.c @ 7835:4d7ce6c03fda v7.4.1214