vim: src/fileio.c comparison

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

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

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

comparison

equal deleted inserted replaced

-:19dfb097d82d
+:f86adafb28d4
 #ifdef FEAT_AUTOCMD
 static char *e_auchangedbuf = N_("E812: Autocommands changed buffer or buffer name");
 #endif
 void
-filemess(buf, name, s, attr)
+filemess(
-buf_T	*buf;
+buf_T	*buf,
-char_u	*name;
+char_u	*name,
-char_u	*s;
+char_u	*s,
-int		attr;
+int		attr)
 {
 int		msg_scroll_save;
 if (msg_silent != 0)
 	return;
 * READ_KEEP_UNDO  don't clear undo info or read it from a file
 *
 * return FAIL for failure, OK otherwise
 */
 int
-readfile(fname, sfname, from, lines_to_skip, lines_to_read, eap, flags)
+readfile(
-char_u	*fname;
+char_u	*fname,
-char_u	*sfname;
+char_u	*sfname,
-linenr_T	from;
+linenr_T	from,
-linenr_T	lines_to_skip;
+linenr_T	lines_to_skip,
-linenr_T	lines_to_read;
+linenr_T	lines_to_read,
-exarg_T	*eap;			/* can be NULL! */
+exarg_T	*eap,			/* can be NULL! */
-int		flags;
+int		flags)
 {
 int		fd = 0;
 int		newfile = (flags & READ_NEW);
 int		check_readonly;
 int		filtering = (flags & READ_FILTER);
 * which is the name of files used for process substitution output by
 * some shells on some operating systems, e.g., bash on SunOS.
 * Do not accept "/dev/fd/[012]", opening these may hang Vim.
 */
 static int
-is_dev_fd_file(fname)
+is_dev_fd_file(char_u *fname)
-char_u	*fname;
 {
 return (STRNCMP(fname, "/dev/fd/", 8) == 0
 	    && VIM_ISDIGIT(fname[8])
 	    && *skipdigits(fname + 9) == NUL
 	    && (fname[9] != NUL
 * From the current line count and characters read after that, estimate the
 * line number where we are now.
 * Used for error messages that include a line number.
 */
 static linenr_T
-readfile_linenr(linecnt, p, endp)
+readfile_linenr(
-linenr_T	linecnt;	/* line count before reading more bytes */
+linenr_T	linecnt,	/* line count before reading more bytes */
-char_u	*p;		/* start of more bytes read */
+char_u	*p,		/* start of more bytes read */
-char_u	*endp;		/* end of more bytes read */
+char_u	*endp)		/* end of more bytes read */
 {
 char_u	*s;
 linenr_T	lnum;
 lnum = curbuf->b_ml.ml_line_count - linecnt + 1;
 * Fill "*eap" to force the 'fileencoding', 'fileformat' and 'binary to be
 * equal to the buffer "buf".  Used for calling readfile().
 * Returns OK or FAIL.
 */
 int
-prep_exarg(eap, buf)
+prep_exarg(exarg_T *eap, buf_T *buf)
-exarg_T	*eap;
-buf_T	*buf;
 {
 eap->cmd = alloc((unsigned)(STRLEN(buf->b_p_ff)
 #ifdef FEAT_MBYTE
 		+ STRLEN(buf->b_p_fenc)
 #endif
 /*
 * Set default or forced 'fileformat' and 'binary'.
 */
 void
-set_file_options(set_options, eap)
+set_file_options(int set_options, exarg_T *eap)
-int set_options;
-exarg_T *eap;
 {
 /* set default 'fileformat' */
 if (set_options)
 {
 	if (eap != NULL && eap->force_ff != 0)
 #if defined(FEAT_MBYTE) || defined(PROTO)
 /*
 * Set forced 'fileencoding'.
 */
 void
-set_forced_fenc(eap)
+set_forced_fenc(exarg_T *eap)
-exarg_T *eap;
 {
 if (eap->force_enc != 0)
 {
 	char_u *fenc = enc_canonize(eap->cmd + eap->force_enc);
 * When there are no more items, an empty string is returned and *pp is set to
 * NULL.
 * When *pp is not set to NULL, the result is in allocated memory.
 */
 static char_u *
-next_fenc(pp)
+next_fenc(char_u **pp)
-char_u	**pp;
 {
 char_u	*p;
 char_u	*r;
 if (**pp == NUL)
 * Returns name of the resulting converted file (the caller should delete it
 * after reading it).
 * Returns NULL if the conversion failed ("*fdp" is not set) .
 */
 static char_u *
-readfile_charconvert(fname, fenc, fdp)
+readfile_charconvert(
-char_u	*fname;		/* name of input file */
+char_u	*fname,		/* name of input file */
-char_u	*fenc;		/* converted from */
+char_u	*fenc,		/* converted from */
-int		*fdp;		/* in/out: file descriptor of file */
+int		*fdp)		/* in/out: file descriptor of file */
 {
 char_u	*tmpname;
 char_u	*errmsg = NULL;
 tmpname = vim_tempname('r', FALSE);
 /*
 * Read marks for the current buffer from the viminfo file, when we support
 * buffer marks and the buffer has a name.
 */
 static void
-check_marks_read()
+check_marks_read(void)
 {
 if (!curbuf->b_marks_read && get_viminfo_parameter('\'') > 0
 						  && curbuf->b_ffname != NULL)
 	read_viminfo(NULL, VIF_WANT_MARKS);
 * If found, the magic number is removed from ptr[*sizep] and *sizep and
 * *filesizep are updated.
 * Return the (new) encryption key, NULL for no encryption.
 */
 static char_u *
-check_for_cryptkey(cryptkey, ptr, sizep, filesizep, newfile, fname, did_ask)
+check_for_cryptkey(
-char_u	*cryptkey;	/* previous encryption key or NULL */
+char_u	*cryptkey,	/* previous encryption key or NULL */
-char_u	*ptr;		/* pointer to read bytes */
+char_u	*ptr,		/* pointer to read bytes */
-long	*sizep;		/* length of read bytes */
+long	*sizep,		/* length of read bytes */
-off_t	*filesizep;	/* nr of bytes used from file */
+off_t	*filesizep,	/* nr of bytes used from file */
-int		newfile;	/* editing a new buffer */
+int		newfile,	/* editing a new buffer */
-char_u	*fname;		/* file name to display */
+char_u	*fname,		/* file name to display */
-int		*did_ask;	/* flag: whether already asked for key */
+int		*did_ask)	/* flag: whether already asked for key */
 {
 int method = crypt_method_nr_from_magic((char *)ptr, *sizep);
 int b_p_ro = curbuf->b_p_ro;
 if (method >= 0)
 }
 #endif  /* FEAT_CRYPT */
 #ifdef UNIX
 static void
-set_file_time(fname, atime, mtime)
+set_file_time(
-char_u  *fname;
+char_u  *fname,
-time_t  atime;	    /* access time */
+time_t  atime,	    /* access time */
-time_t  mtime;	    /* modification time */
+time_t  mtime)	    /* modification time */
 {
 # if defined(HAVE_UTIME) && defined(HAVE_UTIME_H)
 struct utimbuf  buf;
 buf.actime	= atime;
 /*
 * Return TRUE if a file appears to be read-only from the file permissions.
 */
 int
-check_file_readonly(fname, perm)
+check_file_readonly(
-char_u	*fname;		/* full path to file */
+char_u	*fname,		/* full path to file */
-int		perm;		/* known permissions on file */
+int		perm)		/* known permissions on file */
 {
 #ifndef USE_MCH_ACCESS
 int	    fd = 0;
 #endif
 * This function must NOT use NameBuff (because it's called by autowrite()).
 *
 * return FAIL for failure, OK otherwise
 */
 int
-buf_write(buf, fname, sfname, start, end, eap, append, forceit,
+buf_write(
-						      reset_changed, filtering)
+buf_T	    *buf,
-buf_T	    *buf;
+char_u	    *fname,
-char_u	    *fname;
+char_u	    *sfname,
-char_u	    *sfname;
+linenr_T	    start,
-linenr_T	    start, end;
+linenr_T	    end,
-exarg_T	    *eap;		/* for forced 'ff' and 'fenc', can be
+exarg_T	    *eap,		/* for forced 'ff' and 'fenc', can be
 					   NULL! */
-int		    append;		/* append to the file */
+int		    append,		/* append to the file */
-int		    forceit;
+int		    forceit,
-int		    reset_changed;
+int		    reset_changed,
-int		    filtering;
+int		    filtering)
 {
 int		    fd;
 char_u	    *backup = NULL;
 int		    backup_copy = FALSE; /* copy the original file? */
 int		    dobackup;
 /*
 * Set the name of the current buffer.  Use when the buffer doesn't have a
 * name and a ":r" or ":w" command with a file name is used.
 */
 static int
-set_rw_fname(fname, sfname)
+set_rw_fname(char_u *fname, char_u *sfname)
-char_u	*fname;
-char_u	*sfname;
 {
 #ifdef FEAT_AUTOCMD
 buf_T	*buf = curbuf;
 /* It's like the unnamed buffer is deleted.... */
 /*
 * Put file name into IObuff with quotes.
 */
 void
-msg_add_fname(buf, fname)
+msg_add_fname(buf_T *buf, char_u *fname)
-buf_T	*buf;
-char_u	*fname;
 {
 if (fname == NULL)
 	fname = (char_u *)"-stdin-";
 home_replace(buf, fname, IObuff + 1, IOSIZE - 4, TRUE);
 IObuff[0] = '"';
 /*
 * Append message for text mode to IObuff.
 * Return TRUE if something appended.
 */
 static int
-msg_add_fileformat(eol_type)
+msg_add_fileformat(int eol_type)
-int	    eol_type;
 {
 #ifndef USE_CRNL
 if (eol_type == EOL_DOS)
 {
 	STRCAT(IObuff, shortmess(SHM_TEXT) ? _("[dos]") : _("[dos format]"));
 /*
 * Append line and character count to IObuff.
 */
 void
-msg_add_lines(insert_space, lnum, nchars)
+msg_add_lines(
-int	    insert_space;
+int	    insert_space,
-long    lnum;
+long    lnum,
-off_t   nchars;
+off_t   nchars)
 {
 char_u  *p;
 p = IObuff + STRLEN(IObuff);
 /*
 * Append message for missing line separator to IObuff.
 */
 static void
-msg_add_eol()
+msg_add_eol(void)
 {
 STRCAT(IObuff, shortmess(SHM_LAST) ? _("[noeol]") : _("[Incomplete last line]"));
 }
 /*
 * Check modification time of file, before writing to it.
 * The size isn't checked, because using a tool like "gzip" takes care of
 * using the same timestamp but can't set the size.
 */
 static int
-check_mtime(buf, st)
+check_mtime(buf_T *buf, struct stat *st)
-buf_T		*buf;
-struct stat		*st;
 {
 if (buf->b_mtime_read != 0
 	    && time_differs((long)st->st_mtime, buf->b_mtime_read))
 {
 	msg_scroll = TRUE;	    /* don't overwrite messages here */
 }
 return OK;
 }
 static int
-time_differs(t1, t2)
+time_differs(long t1, long t2)
-long	t1, t2;
 {
 #if defined(__linux__) || defined(MSDOS) || defined(MSWIN)
 /* On a FAT filesystem, esp. under Linux, there are only 5 bits to store
 * the seconds.  Since the roundoff is done when flushing the inode, the
 * time may change unexpectedly by one second!!! */
 * Handles encryption and 'encoding' conversion.
 *
 * Return FAIL for failure, OK otherwise.
 */
 static int
-buf_write_bytes(ip)
+buf_write_bytes(struct bw_info *ip)
-struct bw_info *ip;
 {
 int		wlen;
 char_u	*buf = ip->bw_buf;	/* data to write */
 int		len = ip->bw_len;	/* length of data */
 #ifdef HAS_BW_FLAGS
 /*
 * Convert a Unicode character to bytes.
 * Return TRUE for an error, FALSE when it's OK.
 */
 static int
-ucs2bytes(c, pp, flags)
+ucs2bytes(
-unsigned	c;		/* in: character */
+unsigned	c,		/* in: character */
-char_u	**pp;		/* in/out: pointer to result */
+char_u	**pp,		/* in/out: pointer to result */
-int		flags;		/* FIO_ flags */
+int		flags)		/* FIO_ flags */
 {
 char_u	*p = *pp;
 int		error = FALSE;
 int		cc;
 /*
 * Return TRUE if file encoding "fenc" requires conversion from or to
 * 'encoding'.
 */
 static int
-need_conversion(fenc)
+need_conversion(char_u *fenc)
-char_u	*fenc;
 {
 int		same_encoding;
 int		enc_flags;
 int		fenc_flags;
 * Check "ptr" for a unicode encoding and return the FIO_ flags needed for the
 * internal conversion.
 * if "ptr" is an empty string, use 'encoding'.
 */
 static int
-get_fio_flags(ptr)
+get_fio_flags(char_u *ptr)
-char_u	*ptr;
 {
 int		prop;
 if (*ptr == NUL)
 	ptr = p_enc;
 * Check "ptr" for a MS-Windows codepage name and return the FIO_ flags needed
 * for the conversion MS-Windows can do for us.  Also accept "utf-8".
 * Used for conversion between 'encoding' and 'fileencoding'.
 */
 static int
-get_win_fio_flags(ptr)
+get_win_fio_flags(char_u *ptr)
-char_u	*ptr;
 {
 int		cp;
 /* Cannot do this when 'encoding' is not utf-8 and not a codepage. */
 if (!enc_utf8 && enc_codepage <= 0)
 /*
 * Check "ptr" for a Carbon supported encoding and return the FIO_ flags
 * needed for the internal conversion to/from utf-8 or latin1.
 */
 static int
-get_mac_fio_flags(ptr)
+get_mac_fio_flags(char_u *ptr)
-char_u	*ptr;
 {
 if ((enc_utf8 || STRCMP(p_enc, "latin1") == 0)
 				     && (enc_canon_props(ptr) & ENC_MACROMAN))
 	return FIO_MACROMAN;
 return 0;
 * "size" must be at least 2.
 * Return the name of the encoding and set "*lenp" to the length.
 * Returns NULL when no BOM found.
 */
 static char_u *
-check_for_bom(p, size, lenp, flags)
+check_for_bom(
-char_u	*p;
+char_u	*p,
-long	size;
+long	size,
-int		*lenp;
+int		*lenp,
-int		flags;
+int		flags)
 {
 char	*name = NULL;
 int		len = 2;
 if (p[0] == 0xef && p[1] == 0xbb && size >= 3 && p[2] == 0xbf
 /*
 * Generate a BOM in "buf[4]" for encoding "name".
 * Return the length of the BOM (zero when no BOM).
 */
 static int
-make_bom(buf, name)
+make_bom(char_u *buf, char_u *name)
-char_u	*buf;
-char_u	*name;
 {
 int		flags;
 char_u	*p;
 flags = get_fio_flags(name);
 * Try to find a shortname by comparing the fullname with the current
 * directory.
 * Returns "full_path" or pointer into "full_path" if shortened.
 */
 char_u *
-shorten_fname1(full_path)
+shorten_fname1(char_u *full_path)
-char_u	*full_path;
 {
 char_u	*dirname;
 char_u	*p = full_path;
 dirname = alloc(MAXPATHL);
 * directory.
 * Returns NULL if not shorter name possible, pointer into "full_path"
 * otherwise.
 */
 char_u *
-shorten_fname(full_path, dir_name)
+shorten_fname(char_u *full_path, char_u *dir_name)
-char_u	*full_path;
-char_u	*dir_name;
 {
 int		len;
 char_u	*p;
 if (full_path == NULL)
 * When "force" is FALSE: Only try to shorten absolute file names.
 * For buffers that have buftype "nofile" or "scratch": never change the file
 * name.
 */
 void
-shorten_fnames(force)
+shorten_fnames(int force)
-int		force;
 {
 char_u	dirname[MAXPATHL];
 buf_T	*buf;
 char_u	*p;
 	|| defined(PROTO)
 /*
 * Shorten all filenames in "fnames[count]" by current directory.
 */
 void
-shorten_filenames(fnames, count)
+shorten_filenames(char_u **fnames, int count)
-char_u	**fnames;
-int		count;
 {
 int		i;
 char_u	dirname[MAXPATHL];
 char_u	*p;
 * characters otherwise.
 * Space for the returned name is allocated, must be freed later.
 * Returns NULL when out of memory.
 */
 char_u *
-modname(fname, ext, prepend_dot)
+modname(
-char_u *fname, *ext;
+char_u *fname,
-int	    prepend_dot;	/* may prepend a '.' to file name */
+char_u *ext,
+int	    prepend_dot)	/* may prepend a '.' to file name */
 {
 return buf_modname(
 #ifdef SHORT_FNAME
 			TRUE,
 #else
 #endif
 						     fname, ext, prepend_dot);
 }
 char_u *
-buf_modname(shortname, fname, ext, prepend_dot)
+buf_modname(
-int	    shortname;		/* use 8.3 file name */
+int	    shortname,		/* use 8.3 file name */
-char_u  *fname, *ext;
+char_u  *fname,
-int	    prepend_dot;	/* may prepend a '.' to file name */
+char_u  *ext,
+int	    prepend_dot)	/* may prepend a '.' to file name */
 {
 char_u	*retval;
 char_u	*s;
 char_u	*e;
 char_u	*ptr;
 /*
 * Like fgets(), but if the file line is too long, it is truncated and the
 * rest of the line is thrown away.  Returns TRUE for end-of-file.
 */
 int
-vim_fgets(buf, size, fp)
+vim_fgets(char_u *buf, int size, FILE *fp)
-char_u	*buf;
-int		size;
-FILE	*fp;
 {
 char	*eof;
 #define FGETS_SIZE 200
 char	tbuf[FGETS_SIZE];
 * Like vim_fgets(), but accept any line terminator: CR, CR-LF or LF.
 * Returns TRUE for end-of-file.
 * Only used for the Mac, because it's much slower than vim_fgets().
 */
 int
-tag_fgets(buf, size, fp)
+tag_fgets(char_u *buf, int size, FILE *fp)
-char_u	*buf;
-int		size;
-FILE	*fp;
 {
 int		i = 0;
 int		c;
 int		eof = FALSE;
 * rename() only works if both files are on the same file system, this
 * function will (attempts to?) copy the file across if rename fails -- webb
 * Return -1 for failure, 0 for success.
 */
 int
-vim_rename(from, to)
+vim_rename(char_u *from, char_u *to)
-char_u	*from;
-char_u	*to;
 {
 int		fd_in;
 int		fd_out;
 int		n;
 char	*errmsg = NULL;
 * busy.
 * Returns TRUE if some message was written (screen should be redrawn and
 * cursor positioned).
 */
 int
-check_timestamps(focus)
+check_timestamps(
-int		focus;		/* called for GUI focus event */
+int		focus)		/* called for GUI focus event */
 {
 buf_T	*buf;
 int		didit = 0;
 int		n;
 * Move all the lines from buffer "frombuf" to buffer "tobuf".
 * Return OK or FAIL.  When FAIL "tobuf" is incomplete and/or "frombuf" is not
 * empty.
 */
 static int
-move_lines(frombuf, tobuf)
+move_lines(buf_T *frombuf, buf_T *tobuf)
-buf_T	*frombuf;
-buf_T	*tobuf;
 {
 buf_T	*tbuf = curbuf;
 int		retval = OK;
 linenr_T	lnum;
 char_u	*p;
 * return 1 if a changed buffer was found.
 * return 2 if a message has been displayed.
 * return 0 otherwise.
 */
 int
-buf_check_timestamp(buf, focus)
+buf_check_timestamp(
-buf_T	*buf;
+buf_T	*buf,
-int		focus UNUSED;	/* called for GUI focus event */
+int		focus UNUSED)	/* called for GUI focus event */
 {
 struct stat	st;
 int		stat_res;
 int		retval = 0;
 char_u	*path;
 * Used when the file was changed outside of Vim.
 * "orig_mode" is buf->b_orig_mode before the need for reloading was detected.
 * buf->b_orig_mode may have been reset already.
 */
 void
-buf_reload(buf, orig_mode)
+buf_reload(buf_T *buf, int orig_mode)
-buf_T	*buf;
-int		orig_mode;
 {
 exarg_T	ea;
 pos_T	old_cursor;
 linenr_T	old_topline;
 int		old_ro = buf->b_p_ro;
 aucmd_restbuf(&aco);
 /* Careful: autocommands may have made "buf" invalid! */
 }
 void
-buf_store_time(buf, st, fname)
+buf_store_time(buf_T *buf, struct stat *st, char_u *fname UNUSED)
-buf_T	*buf;
-struct stat	*st;
-char_u	*fname UNUSED;
 {
 buf->b_mtime = (long)st->st_mtime;
 buf->b_orig_size = st->st_size;
 #ifdef HAVE_ST_MODE
 buf->b_orig_mode = (int)st->st_mode;
 /*
 * Adjust the line with missing eol, used for the next write.
 * Used for do_filter(), when the input lines for the filter are deleted.
 */
 void
-write_lnum_adjust(offset)
+write_lnum_adjust(linenr_T offset)
-linenr_T	offset;
 {
 if (curbuf->b_no_eol_lnum != 0)	/* only if there is a missing eol */
 	curbuf->b_no_eol_lnum += offset;
 }
 /*
 * Delete the temp directory and all files it contains.
 */
 void
-vim_deltempdir()
+vim_deltempdir(void)
 {
 if (vim_tempdir != NULL)
 {
 	/* remove the trailing path separator */
 	gettail(vim_tempdir)[-1] = NUL;
 * Directory "tempdir" was created.  Expand this name to a full path and put
 * it in "vim_tempdir".  This avoids that using ":cd" would confuse us.
 * "tempdir" must be no longer than MAXPATHL.
 */
 static void
-vim_settempdir(tempdir)
+vim_settempdir(char_u *tempdir)
-char_u	*tempdir;
 {
 char_u	*buf;
 buf = alloc((unsigned)MAXPATHL + 2);
 if (buf != NULL)
 *
 * The returned pointer is to allocated memory.
 * The returned pointer is NULL if no valid name was found.
 */
 char_u  *
-vim_tempname(extra_char, keep)
+vim_tempname(
-int	    extra_char UNUSED;  /* char to use in the name instead of '?' */
+int	    extra_char UNUSED,  /* char to use in the name instead of '?' */
-int	    keep UNUSED;
+int	    keep UNUSED)
 {
 #ifdef USE_TMPNAM
 char_u	itmp[L_tmpnam];	/* use tmpnam() */
 #else
 char_u	itmp[TEMPNAMELEN];
 /*
 * Convert all backslashes in fname to forward slashes in-place, unless when
 * it looks like a URL.
 */
 void
-forward_slash(fname)
+forward_slash(char_u *fname)
-char_u	*fname;
 {
 char_u	*p;
 if (path_with_url(fname))
 	return;
 /*
 * Show the autocommands for one AutoPat.
 */
 static void
-show_autocmd(ap, event)
+show_autocmd(AutoPat *ap, event_T event)
-AutoPat	*ap;
-event_T	event;
 {
 AutoCmd *ac;
 /* Check for "got_int" (here and at various places below), which is set
 * when "q" has been hit for the "--more--" prompt */
 /*
 * Mark an autocommand pattern for deletion.
 */
 static void
-au_remove_pat(ap)
+au_remove_pat(AutoPat *ap)
-AutoPat *ap;
 {
 vim_free(ap->pat);
 ap->pat = NULL;
 ap->buflocal_nr = -1;
 au_need_clean = TRUE;
 /*
 * Mark all commands for a pattern for deletion.
 */
 static void
-au_remove_cmds(ap)
+au_remove_cmds(AutoPat *ap)
-AutoPat *ap;
 {
 AutoCmd *ac;
 for (ac = ap->cmds; ac != NULL; ac = ac->next)
 {
 /*
 * Cleanup autocommands and patterns that have been deleted.
 * This is only done when not executing autocommands.
 */
 static void
-au_cleanup()
+au_cleanup(void)
 {
 AutoPat	*ap, **prev_ap;
 AutoCmd	*ac, **prev_ac;
 event_T	event;
 /*
 * Called when buffer is freed, to remove/invalidate related buffer-local
 * autocmds.
 */
 void
-aubuflocal_remove(buf)
+aubuflocal_remove(buf_T *buf)
-buf_T	*buf;
 {
 AutoPat	*ap;
 event_T	event;
 AutoPatCmd	*apc;
 /*
 * Add an autocmd group name.
 * Return it's ID.  Returns AUGROUP_ERROR (< 0) for error.
 */
 static int
-au_new_group(name)
+au_new_group(char_u *name)
-char_u	*name;
 {
 int		i;
 i = au_find_group(name);
 if (i == AUGROUP_ERROR)	/* the group doesn't exist yet, add it */
 return i;
 }
 static void
-au_del_group(name)
+au_del_group(char_u *name)
-char_u	*name;
 {
 int	    i;
 i = au_find_group(name);
 if (i == AUGROUP_ERROR)	/* the group doesn't exist */
 /*
 * Find the ID of an autocmd group name.
 * Return it's ID.  Returns AUGROUP_ERROR (< 0) for error.
 */
 static int
-au_find_group(name)
+au_find_group(char_u *name)
-char_u	*name;
 {
 int	    i;
 for (i = 0; i < augroups.ga_len; ++i)
 	if (AUGROUP_NAME(i) != NULL && STRCMP(AUGROUP_NAME(i), name) == 0)
 /*
 * Return TRUE if augroup "name" exists.
 */
 int
-au_has_group(name)
+au_has_group(char_u *name)
-char_u	*name;
 {
 return au_find_group(name) != AUGROUP_ERROR;
 }
 /*
 * ":augroup {name}".
 */
 void
-do_augroup(arg, del_group)
+do_augroup(char_u *arg, int del_group)
-char_u	*arg;
-int		del_group;
 {
 int	    i;
 if (del_group)
 {
 }
 }
 #if defined(EXITFREE) || defined(PROTO)
 void
-free_all_autocmds()
+free_all_autocmds(void)
 {
 for (current_augroup = -1; current_augroup < augroups.ga_len;
 							    ++current_augroup)
 	do_autocmd((char_u *)"", TRUE);
 ga_clear_strings(&augroups);
 * Return the event number for event name "start".
 * Return NUM_EVENTS if the event name was not found.
 * Return a pointer to the next event name in "end".
 */
 static event_T
-event_name2nr(start, end)
+event_name2nr(char_u *start, char_u **end)
-char_u  *start;
-char_u  **end;
 {
 char_u	*p;
 int		i;
 int		len;
 /*
 * Return the name for event "event".
 */
 static char_u *
-event_nr2name(event)
+event_nr2name(event_T event)
-event_T	event;
 {
 int	    i;
 for (i = 0; event_names[i].name != NULL; ++i)
 	if (event_names[i].event == event)
 /*
 * Scan over the events.  "*" stands for all events.
 */
 static char_u *
-find_end_event(arg, have_group)
+find_end_event(
-char_u  *arg;
+char_u  *arg,
-int	    have_group;	    /* TRUE when group name was found */
+int	    have_group)	    /* TRUE when group name was found */
 {
 char_u  *pat;
 char_u  *p;
 if (*arg == '*')
 /*
 * Return TRUE if "event" is included in 'eventignore'.
 */
 static int
-event_ignored(event)
+event_ignored(event_T event)
-event_T	event;
 {
 char_u	*p = p_ei;
 while (*p != NUL)
 {
 /*
 * Return OK when the contents of p_ei is valid, FAIL otherwise.
 */
 int
-check_ei()
+check_ei(void)
 {
 char_u	*p = p_ei;
 while (*p)
 {
 * Add "what" to 'eventignore' to skip loading syntax highlighting for every
 * buffer loaded into the window.  "what" must start with a comma.
 * Returns the old value of 'eventignore' in allocated memory.
 */
 char_u *
-au_event_disable(what)
+au_event_disable(char *what)
-char	*what;
 {
 char_u	*new_ei;
 char_u	*save_ei;
 save_ei = vim_strsave(p_ei);
 }
 return save_ei;
 }
 void
-au_event_restore(old_ei)
+au_event_restore(char_u *old_ei)
-char_u	*old_ei;
 {
 if (old_ei != NULL)
 {
 	set_string_option_direct((char_u *)"ei", -1, old_ei,
 							  OPT_FREE, SID_NONE);
 * :autocmd * *.c		show all autocommands for *.c files.
 *
 * Mostly a {group} argument can optionally appear before <event>.
 */
 void
-do_autocmd(arg, forceit)
+do_autocmd(char_u *arg, int forceit)
-char_u  *arg;
-int	    forceit;
 {
 char_u	*pat;
 char_u	*envpat = NULL;
 char_u	*cmd;
 event_T	event;
 * The "argp" argument is advanced to the following argument.
 *
 * Returns the group ID, AUGROUP_ERROR for error (out of memory).
 */
 static int
-au_get_grouparg(argp)
+au_get_grouparg(char_u **argp)
-char_u	**argp;
 {
 char_u	*group_name;
 char_u	*p;
 char_u	*arg = *argp;
 int		group = AUGROUP_ALL;
 * If *cmd == NUL show entries.
 * If forceit == TRUE delete entries.
 * If group is not AUGROUP_ALL, only use this group.
 */
 static int
-do_autocmd_event(event, pat, nested, cmd, forceit, group)
+do_autocmd_event(
-event_T	event;
+event_T	event,
-char_u	*pat;
+char_u	*pat,
-int		nested;
+int		nested,
-char_u	*cmd;
+char_u	*cmd,
-int		forceit;
+int		forceit,
-int		group;
+int		group)
 {
 AutoPat	*ap;
 AutoPat	**prev_ap;
 AutoCmd	*ac;
 AutoCmd	**prev_ac;
 /*
 * Implementation of ":doautocmd [group] event [fname]".
 * Return OK for success, FAIL for failure;
 */
 int
-do_doautocmd(arg, do_msg)
+do_doautocmd(
-char_u	*arg;
+char_u	*arg,
-int		do_msg;	    /* give message for no matching autocmds? */
+int		do_msg)	    /* give message for no matching autocmds? */
 {
 char_u	*fname;
 int		nothing_done = TRUE;
 int		group;
 /*
 * ":doautoall": execute autocommands for each loaded buffer.
 */
 void
-ex_doautoall(eap)
+ex_doautoall(exarg_T *eap)
-exarg_T	*eap;
 {
 int		retval;
 aco_save_T	aco;
 buf_T	*buf;
 char_u	*arg = eap->arg;
 * Check *argp for <nomodeline>.  When it is present return FALSE, otherwise
 * return TRUE and advance *argp to after it.
 * Thus return TRUE when do_modelines() should be called.
 */
 int
-check_nomodeline(argp)
+check_nomodeline(char_u **argp)
-char_u **argp;
 {
 if (STRNCMP(*argp, "<nomodeline>", 12) == 0)
 {
 	*argp = skipwhite(*argp + 12);
 	return FALSE;
 * one then use "aucmd_win".
 * Set "curbuf" and "curwin" to match "buf".
 * When FEAT_AUTOCMD is not defined another version is used, see below.
 */
 void
-aucmd_prepbuf(aco, buf)
+aucmd_prepbuf(
-aco_save_T	*aco;		/* structure to save values in */
+aco_save_T	*aco,		/* structure to save values in */
-buf_T	*buf;		/* new curbuf */
+buf_T	*buf)		/* new curbuf */
 {
 win_T	*win;
 #ifdef FEAT_WINDOWS
 int		save_ea;
 #endif
 * Cleanup after executing autocommands for a (hidden) buffer.
 * Restore the window as it was (if possible).
 * When FEAT_AUTOCMD is not defined another version is used, see below.
 */
 void
-aucmd_restbuf(aco)
+aucmd_restbuf(
-aco_save_T	*aco;		/* structure holding saved values */
+aco_save_T	*aco)		/* structure holding saved values */
 {
 #ifdef FEAT_WINDOWS
 int dummy;
 #endif
 /*
 * Execute autocommands for "event" and file name "fname".
 * Return TRUE if some commands were executed.
 */
 int
-apply_autocmds(event, fname, fname_io, force, buf)
+apply_autocmds(
-event_T	event;
+event_T	event,
-char_u	*fname;	    /* NULL or empty means use actual file name */
+char_u	*fname,	    /* NULL or empty means use actual file name */
-char_u	*fname_io;  /* fname to use for <afile> on cmdline */
+char_u	*fname_io,  /* fname to use for <afile> on cmdline */
-int		force;	    /* when TRUE, ignore autocmd_busy */
+int		force,	    /* when TRUE, ignore autocmd_busy */
-buf_T	*buf;	    /* buffer for <abuf> */
+buf_T	*buf)	    /* buffer for <abuf> */
 {
 return apply_autocmds_group(event, fname, fname_io, force,
 						      AUGROUP_ALL, buf, NULL);
 }
 /*
 * Like apply_autocmds(), but with extra "eap" argument.  This takes care of
 * setting v:filearg.
 */
 static int
-apply_autocmds_exarg(event, fname, fname_io, force, buf, eap)
+apply_autocmds_exarg(
-event_T	event;
+event_T	event,
-char_u	*fname;
+char_u	*fname,
-char_u	*fname_io;
+char_u	*fname_io,
-int		force;
+int		force,
-buf_T	*buf;
+buf_T	*buf,
-exarg_T	*eap;
+exarg_T	*eap)
 {
 return apply_autocmds_group(event, fname, fname_io, force,
 						       AUGROUP_ALL, buf, eap);
 }
 * processing is being aborted or if retval is FAIL when inside a try
 * conditional, no autocommands are executed.  If otherwise the autocommands
 * cause the script to be aborted, retval is set to FAIL.
 */
 int
-apply_autocmds_retval(event, fname, fname_io, force, buf, retval)
+apply_autocmds_retval(
-event_T	event;
+event_T	event,
-char_u	*fname;	    /* NULL or empty means use actual file name */
+char_u	*fname,	    /* NULL or empty means use actual file name */
-char_u	*fname_io;  /* fname to use for <afile> on cmdline */
+char_u	*fname_io,  /* fname to use for <afile> on cmdline */
-int		force;	    /* when TRUE, ignore autocmd_busy */
+int		force,	    /* when TRUE, ignore autocmd_busy */
-buf_T	*buf;	    /* buffer for <abuf> */
+buf_T	*buf,	    /* buffer for <abuf> */
-int		*retval;    /* pointer to caller's retval */
+int		*retval)    /* pointer to caller's retval */
 {
 int		did_cmd;
 #ifdef FEAT_EVAL
 if (should_abort(*retval))
 /*
 * Return TRUE when there is a CursorHold autocommand defined.
 */
 int
-has_cursorhold()
+has_cursorhold(void)
 {
 return (first_autopat[(int)(get_real_state() == NORMAL_BUSY
 			    ? EVENT_CURSORHOLD : EVENT_CURSORHOLDI)] != NULL);
 }
 /*
 * Return TRUE if the CursorHold event can be triggered.
 */
 int
-trigger_cursorhold()
+trigger_cursorhold(void)
 {
 int		state;
 if (!did_cursorhold
 	    && has_cursorhold()
 /*
 * Return TRUE when there is a CursorMoved autocommand defined.
 */
 int
-has_cursormoved()
+has_cursormoved(void)
 {
 return (first_autopat[(int)EVENT_CURSORMOVED] != NULL);
 }
 /*
 * Return TRUE when there is a CursorMovedI autocommand defined.
 */
 int
-has_cursormovedI()
+has_cursormovedI(void)
 {
 return (first_autopat[(int)EVENT_CURSORMOVEDI] != NULL);
 }
 /*
 * Return TRUE when there is a TextChanged autocommand defined.
 */
 int
-has_textchanged()
+has_textchanged(void)
 {
 return (first_autopat[(int)EVENT_TEXTCHANGED] != NULL);
 }
 /*
 * Return TRUE when there is a TextChangedI autocommand defined.
 */
 int
-has_textchangedI()
+has_textchangedI(void)
 {
 return (first_autopat[(int)EVENT_TEXTCHANGEDI] != NULL);
 }
 /*
 * Return TRUE when there is an InsertCharPre autocommand defined.
 */
 int
-has_insertcharpre()
+has_insertcharpre(void)
 {
 return (first_autopat[(int)EVENT_INSERTCHARPRE] != NULL);
 }
 /*
 * Return TRUE when there is an CmdUndefined autocommand defined.
 */
 int
-has_cmdundefined()
+has_cmdundefined(void)
 {
 return (first_autopat[(int)EVENT_CMDUNDEFINED] != NULL);
 }
 /*
 * Return TRUE when there is an FuncUndefined autocommand defined.
 */
 int
-has_funcundefined()
+has_funcundefined(void)
 {
 return (first_autopat[(int)EVENT_FUNCUNDEFINED] != NULL);
 }
 static int
-apply_autocmds_group(event, fname, fname_io, force, group, buf, eap)
+apply_autocmds_group(
-event_T	event;
+event_T	event,
-char_u	*fname;	    /* NULL or empty means use actual file name */
+char_u	*fname,	    /* NULL or empty means use actual file name */
-char_u	*fname_io;  /* fname to use for <afile> on cmdline, NULL means
+char_u	*fname_io,  /* fname to use for <afile> on cmdline, NULL means
 			       use fname */
-int		force;	    /* when TRUE, ignore autocmd_busy */
+int		force,	    /* when TRUE, ignore autocmd_busy */
-int		group;	    /* group ID, or AUGROUP_ALL */
+int		group,	    /* group ID, or AUGROUP_ALL */
-buf_T	*buf;	    /* buffer for <abuf> */
+buf_T	*buf,	    /* buffer for <abuf> */
-exarg_T	*eap;	    /* command arguments */
+exarg_T	*eap)	    /* command arguments */
 {
 char_u	*sfname = NULL;	/* short file name */
 char_u	*tail;
 int		save_changed;
 buf_T	*old_curbuf;
 /*
 * Block triggering autocommands until unblock_autocmd() is called.
 * Can be used recursively, so long as it's symmetric.
 */
 void
-block_autocmds()
+block_autocmds(void)
 {
 # ifdef FEAT_EVAL
 /* Remember the value of v:termresponse. */
 if (autocmd_blocked == 0)
 	old_termresponse = get_vim_var_str(VV_TERMRESPONSE);
 # endif
 ++autocmd_blocked;
 }
 void
-unblock_autocmds()
+unblock_autocmds(void)
 {
 --autocmd_blocked;
 # ifdef FEAT_EVAL
 /* When v:termresponse was set while autocommands were blocked, trigger
 	apply_autocmds(EVENT_TERMRESPONSE, NULL, NULL, FALSE, curbuf);
 # endif
 }
 int
-is_autocmd_blocked()
+is_autocmd_blocked(void)
 {
 return autocmd_blocked != 0;
 }
 /*
 * Find next autocommand pattern that matches.
 */
 static void
-auto_next_pat(apc, stop_at_last)
+auto_next_pat(
-AutoPatCmd	*apc;
+AutoPatCmd	*apc,
-int		stop_at_last;	    /* stop when 'last' flag is set */
+int		stop_at_last)	    /* stop when 'last' flag is set */
 {
 AutoPat	*ap;
 AutoCmd	*cp;
 char_u	*name;
 char	*s;
 * Get next autocommand command.
 * Called by do_cmdline() to get the next line for ":if".
 * Returns allocated string, or NULL for end of autocommands.
 */
 char_u *
-getnextac(c, cookie, indent)
+getnextac(int c UNUSED, void *cookie, int indent UNUSED)
-int	    c UNUSED;
-void    *cookie;
-int	    indent UNUSED;
 {
 AutoPatCmd	    *acp = (AutoPatCmd *)cookie;
 char_u	    *retval;
 AutoCmd	    *ac;
 * Return TRUE if there is a matching autocommand for "fname".
 * To account for buffer-local autocommands, function needs to know
 * in which buffer the file will be opened.
 */
 int
-has_autocmd(event, sfname, buf)
+has_autocmd(event_T event, char_u *sfname, buf_T *buf)
-event_T	event;
-char_u	*sfname;
-buf_T       *buf;
 {
 AutoPat	*ap;
 char_u	*fname;
 char_u	*tail = gettail(sfname);
 int		retval = FALSE;
 /*
 * Function given to ExpandGeneric() to obtain the list of autocommand group
 * names.
 */
 char_u *
-get_augroup_name(xp, idx)
+get_augroup_name(expand_T *xp UNUSED, int idx)
-expand_T	*xp UNUSED;
-int		idx;
 {
 if (idx == augroups.ga_len)		/* add "END" add the end */
 	return (char_u *)"END";
 if (idx >= augroups.ga_len)		/* end of list */
 	return NULL;
 }
 static int include_groups = FALSE;
 char_u  *
-set_context_in_autocmd(xp, arg, doautocmd)
+set_context_in_autocmd(
-expand_T	*xp;
+expand_T	*xp,
-char_u	*arg;
+char_u	*arg,
-int		doautocmd;	/* TRUE for :doauto*, FALSE for :autocmd */
+int		doautocmd)	/* TRUE for :doauto*, FALSE for :autocmd */
 {
 char_u	*p;
 int		group;
 /* check for a group name, skip it if present */
 /*
 * Function given to ExpandGeneric() to obtain the list of event names.
 */
 char_u *
-get_event_name(xp, idx)
+get_event_name(expand_T *xp UNUSED, int idx)
-expand_T	*xp UNUSED;
-int		idx;
 {
 if (idx < augroups.ga_len)		/* First list group names, if wanted */
 {
 	if (!include_groups || AUGROUP_NAME(idx) == NULL)
 	    return (char_u *)"";	/* skip deleted entries */
 /*
 * Return TRUE if autocmd is supported.
 */
 int
-autocmd_supported(name)
+autocmd_supported(char_u *name)
-char_u	*name;
 {
 char_u *p;
 return (event_name2nr(name, &p) != NUM_EVENTS);
 }
 *	exists("#Group#Event#pat") or
 *	exists("#Event") or
 *	exists("#Event#pat")
 */
 int
-au_exists(arg)
+au_exists(char_u *arg)
-char_u	*arg;
 {
 char_u	*arg_save;
 char_u	*pattern = NULL;
 char_u	*event_name;
 char_u	*p;
 * vim_regcomp() often.
 * Used for autocommands and 'wildignore'.
 * Returns TRUE if there is a match, FALSE otherwise.
 */
 static int
-match_file_pat(pattern, prog, fname, sfname, tail, allow_dirs)
+match_file_pat(
-char_u	*pattern;		/* pattern to match with */
+char_u	*pattern,		/* pattern to match with */
-regprog_T	**prog;			/* pre-compiled regprog or NULL */
+regprog_T	**prog,			/* pre-compiled regprog or NULL */
-char_u	*fname;			/* full path of file name */
+char_u	*fname,			/* full path of file name */
-char_u	*sfname;		/* short file name or NULL */
+char_u	*sfname,		/* short file name or NULL */
-char_u	*tail;			/* tail of path */
+char_u	*tail,			/* tail of path */
-int		allow_dirs;		/* allow matching with dir */
+int		allow_dirs)		/* allow matching with dir */
 {
 regmatch_T	regmatch;
 int		result = FALSE;
 regmatch.rm_ic = p_fic; /* ignore case if 'fileignorecase' is set */
 * Return TRUE if a file matches with a pattern in "list".
 * "list" is a comma-separated list of patterns, like 'wildignore'.
 * "sfname" is the short file name or NULL, "ffname" the long file name.
 */
 int
-match_file_list(list, sfname, ffname)
+match_file_list(char_u *list, char_u *sfname, char_u *ffname)
-char_u	*list;
-char_u	*sfname;
-char_u	*ffname;
 {
 char_u	buf[100];
 char_u	*tail;
 char_u	*regpat;
 char	allow_dirs;
 * Handle backslashes before special characters, like "\*" and "\ ".
 *
 * Returns NULL when out of memory.
 */
 char_u *
-file_pat_to_reg_pat(pat, pat_end, allow_dirs, no_bslash)
+file_pat_to_reg_pat(
-char_u	*pat;
+char_u	*pat,
-char_u	*pat_end;	/* first char after pattern or NULL */
+char_u	*pat_end,	/* first char after pattern or NULL */
-char	*allow_dirs;	/* Result passed back out in here */
+char	*allow_dirs,	/* Result passed back out in here */
-int		no_bslash UNUSED; /* Don't use a backward slash as pathsep */
+int		no_bslash UNUSED) /* Don't use a backward slash as pathsep */
 {
 int		size = 2; /* '^' at start, '$' at end */
 char_u	*endp;
 char_u	*reg_pat;
 char_u	*p;
 /*
 * Version of read() that retries when interrupted by EINTR (possibly
 * by a SIGWINCH).
 */
 long
-read_eintr(fd, buf, bufsize)
+read_eintr(int fd, void *buf, size_t bufsize)
-int	    fd;
-void    *buf;
-size_t  bufsize;
 {
 long ret;
 for (;;)
 {
 /*
 * Version of write() that retries when interrupted by EINTR (possibly
 * by a SIGWINCH).
 */
 long
-write_eintr(fd, buf, bufsize)
+write_eintr(int fd, void *buf, size_t bufsize)
-int	    fd;
-void    *buf;
-size_t  bufsize;
 {
 long    ret = 0;
 long    wlen;
 /* Repeat the write() so long it didn't fail, other than being interrupted

Mercurial > vim

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