/* vi:set ts=8 sts=4 sw=4 noet:

*

* VIM - Vi IMproved by Bram Moolenaar

*

* Do ":help uganda" in Vim to read copying and usage conditions.

* Do ":help credits" in Vim to see a list of people who contributed.

* See README.txt for an overview of the Vim source code.

*/

/*

* fileio.c: read from and write to a file

*/

#include "vim.h"

#if defined(__TANDEM) || defined(__MINT__)

# include <limits.h> /* for SSIZE_MAX */

#endif

#if defined(HAVE_UTIME) && defined(HAVE_UTIME_H)

# include <utime.h> /* for struct utimbuf */

#endif

#define BUFSIZE 8192 /* size of normal write buffer */

#define SMBUFSIZE 256 /* size of emergency write buffer */

/* Is there any system that doesn't have access()? */

#define USE_MCH_ACCESS

static char_u *next_fenc(char_u **pp);

#ifdef FEAT_EVAL

static char_u *readfile_charconvert(char_u *fname, char_u *fenc, int *fdp);

#endif

#ifdef FEAT_VIMINFO

static void check_marks_read(void);

#endif

#ifdef FEAT_CRYPT

static char_u *check_for_cryptkey(char_u *cryptkey, char_u *ptr, long *sizep, off_T *filesizep, int newfile, char_u *fname, int *did_ask);

#endif

static int set_rw_fname(char_u *fname, char_u *sfname);

static int msg_add_fileformat(int eol_type);

static void msg_add_eol(void);

static int check_mtime(buf_T *buf, stat_T *s);

static int time_differs(long t1, long t2);

#define HAS_BW_FLAGS

#define FIO_LATIN1 0x01 /* convert Latin1 */

#define FIO_UTF8 0x02 /* convert UTF-8 */

#define FIO_UCS2 0x04 /* convert UCS-2 */

#define FIO_UCS4 0x08 /* convert UCS-4 */

#define FIO_UTF16 0x10 /* convert UTF-16 */

#ifdef MSWIN

# define FIO_CODEPAGE 0x20 /* convert MS-Windows codepage */

# define FIO_PUT_CP(x) (((x) & 0xffff) << 16) /* put codepage in top word */

# define FIO_GET_CP(x) (((x)>>16) & 0xffff) /* get codepage from top word */

#endif

#ifdef MACOS_CONVERT

# define FIO_MACROMAN 0x20 /* convert MacRoman */

#endif

#define FIO_ENDIAN_L 0x80 /* little endian */

#define FIO_ENCRYPTED 0x1000 /* encrypt written bytes */

#define FIO_NOCONVERT 0x2000 /* skip encoding conversion */

#define FIO_UCSBOM 0x4000 /* check for BOM at start of file */

#define FIO_ALL -1 /* allow all formats */

/* When converting, a read() or write() may leave some bytes to be converted

* for the next call. The value is guessed... */

#define CONV_RESTLEN 30

/* We have to guess how much a sequence of bytes may expand when converting

* with iconv() to be able to allocate a buffer. */

#define ICONV_MULT 8

/*

* Structure to pass arguments from buf_write() to buf_write_bytes().

*/

struct bw_info

{

int bw_fd; /* file descriptor */

char_u *bw_buf; /* buffer with data to be written */

int bw_len; /* length of data */

#ifdef HAS_BW_FLAGS

int bw_flags; /* FIO_ flags */

#endif

#ifdef FEAT_CRYPT

buf_T *bw_buffer; /* buffer being written */

#endif

char_u bw_rest[CONV_RESTLEN]; /* not converted bytes */

int bw_restlen; /* nr of bytes in bw_rest[] */

int bw_first; /* first write call */

char_u *bw_conv_buf; /* buffer for writing converted chars */

int bw_conv_buflen; /* size of bw_conv_buf */

int bw_conv_error; /* set for conversion error */

linenr_T bw_conv_error_lnum; /* first line with error or zero */

linenr_T bw_start_lnum; /* line number at start of buffer */

#ifdef USE_ICONV

iconv_t bw_iconv_fd; /* descriptor for iconv() or -1 */

#endif

};

static int buf_write_bytes(struct bw_info *ip);

static linenr_T readfile_linenr(linenr_T linecnt, char_u *p, char_u *endp);

static int ucs2bytes(unsigned c, char_u **pp, int flags);

static int need_conversion(char_u *fenc);

static int get_fio_flags(char_u *ptr);

static char_u *check_for_bom(char_u *p, long size, int *lenp, int flags);

static int make_bom(char_u *buf, char_u *name);

#ifdef MSWIN

static int get_win_fio_flags(char_u *ptr);

#endif

#ifdef MACOS_CONVERT

static int get_mac_fio_flags(char_u *ptr);

#endif

static char *e_auchangedbuf = N_("E812: Autocommands changed buffer or buffer name");

void

filemess(

buf_T *buf,

char_u *name,

char_u *s,

int attr)

{

int msg_scroll_save;

if (msg_silent != 0)

return;

msg_add_fname(buf, name); /* put file name in IObuff with quotes */

/* If it's extremely long, truncate it. */

if (STRLEN(IObuff) > IOSIZE - 80)

IObuff[IOSIZE - 80] = NUL;

STRCAT(IObuff, s);

/*

* For the first message may have to start a new line.

* For further ones overwrite the previous one, reset msg_scroll before

* calling filemess().

*/

msg_scroll_save = msg_scroll;

if (shortmess(SHM_OVERALL) && !exiting && p_verbose == 0)

msg_scroll = FALSE;

if (!msg_scroll) /* wait a bit when overwriting an error msg */

check_for_delay(FALSE);

msg_start();

msg_scroll = msg_scroll_save;

msg_scrolled_ign = TRUE;

/* may truncate the message to avoid a hit-return prompt */

msg_outtrans_attr(msg_may_trunc(FALSE, IObuff), attr);

msg_clr_eos();

out_flush();

msg_scrolled_ign = FALSE;

}

/*

* Read lines from file "fname" into the buffer after line "from".

*

* 1. We allocate blocks with lalloc, as big as possible.

* 2. Each block is filled with characters from the file with a single read().

* 3. The lines are inserted in the buffer with ml_append().

*

* (caller must check that fname != NULL, unless READ_STDIN is used)

*

* "lines_to_skip" is the number of lines that must be skipped

* "lines_to_read" is the number of lines that are appended

* When not recovering lines_to_skip is 0 and lines_to_read MAXLNUM.

*

* flags:

* READ_NEW starting to edit a new buffer

* READ_FILTER reading filter output

* READ_STDIN read from stdin instead of a file

* READ_BUFFER read from curbuf instead of a file (converting after reading

* stdin)

* READ_DUMMY read into a dummy buffer (to check if file contents changed)

* READ_KEEP_UNDO don't clear undo info or read it from a file

* READ_FIFO read from fifo/socket instead of a file

*

* return FAIL for failure, NOTDONE for directory (failure), or OK

*/

int

readfile(

char_u *fname,

char_u *sfname,

linenr_T from,

linenr_T lines_to_skip,

linenr_T lines_to_read,

exarg_T *eap, /* can be NULL! */

int flags)

{

int fd = 0;

int newfile = (flags & READ_NEW);

int check_readonly;

int filtering = (flags & READ_FILTER);

int read_stdin = (flags & READ_STDIN);

int read_buffer = (flags & READ_BUFFER);

int read_fifo = (flags & READ_FIFO);

int set_options = newfile || read_buffer

|| (eap != NULL && eap->read_edit);

linenr_T read_buf_lnum = 1; /* next line to read from curbuf */

colnr_T read_buf_col = 0; /* next char to read from this line */

char_u c;

linenr_T lnum = from;

char_u *ptr = NULL; /* pointer into read buffer */

char_u *buffer = NULL; /* read buffer */

char_u *new_buffer = NULL; /* init to shut up gcc */

char_u *line_start = NULL; /* init to shut up gcc */

int wasempty; /* buffer was empty before reading */

colnr_T len;

long size = 0;

char_u *p;

off_T filesize = 0;

int skip_read = FALSE;

#ifdef FEAT_CRYPT

char_u *cryptkey = NULL;

int did_ask_for_key = FALSE;

#endif

#ifdef FEAT_PERSISTENT_UNDO

context_sha256_T sha_ctx;

int read_undo_file = FALSE;

#endif

int split = 0; /* number of split lines */

#define UNKNOWN 0x0fffffff /* file size is unknown */

linenr_T linecnt;

int error = FALSE; /* errors encountered */

int ff_error = EOL_UNKNOWN; /* file format with errors */

long linerest = 0; /* remaining chars in line */

#ifdef UNIX

int perm = 0;

int swap_mode = -1; /* protection bits for swap file */

#else

int perm;

#endif

int fileformat = 0; /* end-of-line format */

int keep_fileformat = FALSE;

stat_T st;

int file_readonly;

linenr_T skip_count = 0;

linenr_T read_count = 0;

int msg_save = msg_scroll;

linenr_T read_no_eol_lnum = 0; /* non-zero lnum when last line of

* last read was missing the eol */

int try_mac;

int try_dos;

int try_unix;

int file_rewind = FALSE;

int can_retry;

linenr_T conv_error = 0; /* line nr with conversion error */

linenr_T illegal_byte = 0; /* line nr with illegal byte */

int keep_dest_enc = FALSE; /* don't retry when char doesn't fit

in destination encoding */

int bad_char_behavior = BAD_REPLACE;

/* BAD_KEEP, BAD_DROP or character to

* replace with */

char_u *tmpname = NULL; /* name of 'charconvert' output file */

int fio_flags = 0;

char_u *fenc; /* fileencoding to use */

int fenc_alloced; /* fenc_next is in allocated memory */

char_u *fenc_next = NULL; /* next item in 'fencs' or NULL */

int advance_fenc = FALSE;

long real_size = 0;

#ifdef USE_ICONV

iconv_t iconv_fd = (iconv_t)-1; /* descriptor for iconv() or -1 */

# ifdef FEAT_EVAL

int did_iconv = FALSE; /* TRUE when iconv() failed and trying

'charconvert' next */

# endif

#endif

int converted = FALSE; /* TRUE if conversion done */

int notconverted = FALSE; /* TRUE if conversion wanted but it

wasn't possible */

char_u conv_rest[CONV_RESTLEN];

int conv_restlen = 0; /* nr of bytes in conv_rest[] */

buf_T *old_curbuf;

char_u *old_b_ffname;

char_u *old_b_fname;

int using_b_ffname;

int using_b_fname;

au_did_filetype = FALSE; /* reset before triggering any autocommands */

curbuf->b_no_eol_lnum = 0; /* in case it was set by the previous read */

/*

* If there is no file name yet, use the one for the read file.

* BF_NOTEDITED is set to reflect this.

* Don't do this for a read from a filter.

* Only do this when 'cpoptions' contains the 'f' flag.

*/

if (curbuf->b_ffname == NULL

&& !filtering

&& fname != NULL

&& vim_strchr(p_cpo, CPO_FNAMER) != NULL

&& !(flags & READ_DUMMY))

{

if (set_rw_fname(fname, sfname) == FAIL)

return FAIL;

}

/* Remember the initial values of curbuf, curbuf->b_ffname and

* curbuf->b_fname to detect whether they are altered as a result of

* executing nasty autocommands. Also check if "fname" and "sfname"

* point to one of these values. */

old_curbuf = curbuf;

old_b_ffname = curbuf->b_ffname;

old_b_fname = curbuf->b_fname;

using_b_ffname = (fname == curbuf->b_ffname)

|| (sfname == curbuf->b_ffname);

using_b_fname = (fname == curbuf->b_fname) || (sfname == curbuf->b_fname);

/* After reading a file the cursor line changes but we don't want to

* display the line. */

ex_no_reprint = TRUE;

/* don't display the file info for another buffer now */

need_fileinfo = FALSE;

/*

* For Unix: Use the short file name whenever possible.

* Avoids problems with networks and when directory names are changed.

* Don't do this for MS-DOS, a "cd" in a sub-shell may have moved us to

* another directory, which we don't detect.

*/

if (sfname == NULL)

sfname = fname;

#if defined(UNIX)

fname = sfname;

#endif

/*

* The BufReadCmd and FileReadCmd events intercept the reading process by

* executing the associated commands instead.

*/

if (!filtering && !read_stdin && !read_buffer)

{

pos_T pos;

pos = curbuf->b_op_start;

/* Set '[ mark to the line above where the lines go (line 1 if zero). */

curbuf->b_op_start.lnum = ((from == 0) ? 1 : from);

curbuf->b_op_start.col = 0;

if (newfile)

{

if (apply_autocmds_exarg(EVENT_BUFREADCMD, NULL, sfname,

FALSE, curbuf, eap))

#ifdef FEAT_EVAL

return aborting() ? FAIL : OK;

#else

return OK;

#endif

}

else if (apply_autocmds_exarg(EVENT_FILEREADCMD, sfname, sfname,

FALSE, NULL, eap))

#ifdef FEAT_EVAL

return aborting() ? FAIL : OK;

#else

return OK;

#endif

curbuf->b_op_start = pos;

}

if ((shortmess(SHM_OVER) || curbuf->b_help) && p_verbose == 0)

msg_scroll = FALSE; /* overwrite previous file message */

else

msg_scroll = TRUE; /* don't overwrite previous file message */

/*

* If the name ends in a path separator, we can't open it. Check here,

* because reading the file may actually work, but then creating the swap

* file may destroy it! Reported on MS-DOS and Win 95.

* If the name is too long we might crash further on, quit here.

*/

if (fname != NULL && *fname != NUL)

{

p = fname + STRLEN(fname);

if (after_pathsep(fname, p) || STRLEN(fname) >= MAXPATHL)

{

filemess(curbuf, fname, (char_u *)_("Illegal file name"), 0);

msg_end();

msg_scroll = msg_save;

return FAIL;

}

}

if (!read_stdin && !read_buffer && !read_fifo)

{

#ifdef UNIX

/*

* On Unix it is possible to read a directory, so we have to

* check for it before the mch_open().

*/

perm = mch_getperm(fname);

if (perm >= 0 && !S_ISREG(perm) /* not a regular file ... */

&& !S_ISFIFO(perm) /* ... or fifo */

&& !S_ISSOCK(perm) /* ... or socket */

# ifdef OPEN_CHR_FILES

&& !(S_ISCHR(perm) && is_dev_fd_file(fname))

/* ... or a character special file named /dev/fd/<n> */

# endif

)

{

int retval = FAIL;

if (S_ISDIR(perm))

{

filemess(curbuf, fname, (char_u *)_("is a directory"), 0);

retval = NOTDONE;

}

else

filemess(curbuf, fname, (char_u *)_("is not a file"), 0);

msg_end();

msg_scroll = msg_save;

return retval;

}

#endif

#if defined(MSWIN)

/*

* MS-Windows allows opening a device, but we will probably get stuck

* trying to read it.

*/

if (!p_odev && mch_nodetype(fname) == NODE_WRITABLE)

{

filemess(curbuf, fname, (char_u *)_("is a device (disabled with 'opendevice' option)"), 0);

msg_end();

msg_scroll = msg_save;

return FAIL;

}

#endif

}

/* Set default or forced 'fileformat' and 'binary'. */

set_file_options(set_options, eap);

/*

* When opening a new file we take the readonly flag from the file.

* Default is r/w, can be set to r/o below.

* Don't reset it when in readonly mode

* Only set/reset b_p_ro when BF_CHECK_RO is set.

*/

check_readonly = (newfile && (curbuf->b_flags & BF_CHECK_RO));

if (check_readonly && !readonlymode)

curbuf->b_p_ro = FALSE;

if (newfile && !read_stdin && !read_buffer && !read_fifo)

{

/* Remember time of file. */

if (mch_stat((char *)fname, &st) >= 0)

{

buf_store_time(curbuf, &st, fname);

curbuf->b_mtime_read = curbuf->b_mtime;

#ifdef UNIX

/*

* Use the protection bits of the original file for the swap file.

* This makes it possible for others to read the name of the

* edited file from the swapfile, but only if they can read the

* edited file.

* Remove the "write" and "execute" bits for group and others

* (they must not write the swapfile).

* Add the "read" and "write" bits for the user, otherwise we may

* not be able to write to the file ourselves.

* Setting the bits is done below, after creating the swap file.

*/

swap_mode = (st.st_mode & 0644) | 0600;

#endif

#ifdef FEAT_CW_EDITOR

/* Get the FSSpec on MacOS

* TODO: Update it properly when the buffer name changes

*/

(void)GetFSSpecFromPath(curbuf->b_ffname, &curbuf->b_FSSpec);

#endif

#ifdef VMS

curbuf->b_fab_rfm = st.st_fab_rfm;

curbuf->b_fab_rat = st.st_fab_rat;

curbuf->b_fab_mrs = st.st_fab_mrs;

#endif

}

else

{

curbuf->b_mtime = 0;

curbuf->b_mtime_read = 0;

curbuf->b_orig_size = 0;

curbuf->b_orig_mode = 0;

}

/* Reset the "new file" flag. It will be set again below when the

* file doesn't exist. */

curbuf->b_flags &= ~(BF_NEW | BF_NEW_W);

}

/*

* for UNIX: check readonly with perm and mch_access()

* for Amiga: check readonly by trying to open the file for writing

*/

file_readonly = FALSE;

if (read_stdin)

{

#if defined(MSWIN)

/* Force binary I/O on stdin to avoid CR-LF -> LF conversion. */

setmode(0, O_BINARY);

#endif

}

else if (!read_buffer)

{

#ifdef USE_MCH_ACCESS

if (

# ifdef UNIX

!(perm & 0222) ||

# endif

mch_access((char *)fname, W_OK))

file_readonly = TRUE;

fd = mch_open((char *)fname, O_RDONLY | O_EXTRA, 0);

#else

if (!newfile

|| readonlymode

|| (fd = mch_open((char *)fname, O_RDWR | O_EXTRA, 0)) < 0)

{

file_readonly = TRUE;

/* try to open ro */

fd = mch_open((char *)fname, O_RDONLY | O_EXTRA, 0);

}

#endif

}

if (fd < 0) /* cannot open at all */

{

#ifndef UNIX

int isdir_f;

#endif

msg_scroll = msg_save;

#ifndef UNIX

/*

* On Amiga we can't open a directory, check here.

*/

isdir_f = (mch_isdir(fname));

perm = mch_getperm(fname); /* check if the file exists */

if (isdir_f)

{

filemess(curbuf, sfname, (char_u *)_("is a directory"), 0);

curbuf->b_p_ro = TRUE; /* must use "w!" now */

}

else

#endif

if (newfile)

{

if (perm < 0

#ifdef ENOENT

&& errno == ENOENT

#endif

)

{

/*

* Set the 'new-file' flag, so that when the file has

* been created by someone else, a ":w" will complain.

*/

curbuf->b_flags |= BF_NEW;

/* Create a swap file now, so that other Vims are warned

* that we are editing this file. Don't do this for a

* "nofile" or "nowrite" buffer type. */

#ifdef FEAT_QUICKFIX

if (!bt_dontwrite(curbuf))

#endif

{

check_need_swap(newfile);

/* SwapExists autocommand may mess things up */

if (curbuf != old_curbuf

|| (using_b_ffname

&& (old_b_ffname != curbuf->b_ffname))

|| (using_b_fname

&& (old_b_fname != curbuf->b_fname)))

{

emsg(_(e_auchangedbuf));

return FAIL;

}

}

if (dir_of_file_exists(fname))

filemess(curbuf, sfname, (char_u *)_("[New File]"), 0);

else

filemess(curbuf, sfname,

(char_u *)_("[New DIRECTORY]"), 0);

#ifdef FEAT_VIMINFO

/* Even though this is a new file, it might have been

* edited before and deleted. Get the old marks. */

check_marks_read();

#endif

/* Set forced 'fileencoding'. */

if (eap != NULL)

set_forced_fenc(eap);

apply_autocmds_exarg(EVENT_BUFNEWFILE, sfname, sfname,

FALSE, curbuf, eap);

/* remember the current fileformat */

save_file_ff(curbuf);

#if defined(FEAT_EVAL)

if (aborting()) /* autocmds may abort script processing */

return FAIL;

#endif

return OK; /* a new file is not an error */

}

else

{

filemess(curbuf, sfname, (char_u *)(

# ifdef EFBIG

(errno == EFBIG) ? _("[File too big]") :

# endif

# ifdef EOVERFLOW

(errno == EOVERFLOW) ? _("[File too big]") :

# endif

_("[Permission Denied]")), 0);

curbuf->b_p_ro = TRUE; /* must use "w!" now */

}

}

return FAIL;

}

/*

* Only set the 'ro' flag for readonly files the first time they are

* loaded. Help files always get readonly mode

*/

if ((check_readonly && file_readonly) || curbuf->b_help)

curbuf->b_p_ro = TRUE;

if (set_options)

{

/* Don't change 'eol' if reading from buffer as it will already be

* correctly set when reading stdin. */

if (!read_buffer)

{

curbuf->b_p_eol = TRUE;

curbuf->b_start_eol = TRUE;

}

curbuf->b_p_bomb = FALSE;

curbuf->b_start_bomb = FALSE;

}

/* Create a swap file now, so that other Vims are warned that we are

* editing this file.

* Don't do this for a "nofile" or "nowrite" buffer type. */

#ifdef FEAT_QUICKFIX

if (!bt_dontwrite(curbuf))

#endif

{

check_need_swap(newfile);

if (!read_stdin && (curbuf != old_curbuf

|| (using_b_ffname && (old_b_ffname != curbuf->b_ffname))

|| (using_b_fname && (old_b_fname != curbuf->b_fname))))

{

emsg(_(e_auchangedbuf));

if (!read_buffer)

close(fd);

return FAIL;

}

#ifdef UNIX

/* Set swap file protection bits after creating it. */

if (swap_mode > 0 && curbuf->b_ml.ml_mfp != NULL

&& curbuf->b_ml.ml_mfp->mf_fname != NULL)

{

char_u *swap_fname = curbuf->b_ml.ml_mfp->mf_fname;

/*

* If the group-read bit is set but not the world-read bit, then

* the group must be equal to the group of the original file. If

* we can't make that happen then reset the group-read bit. This

* avoids making the swap file readable to more users when the

* primary group of the user is too permissive.

*/

if ((swap_mode & 044) == 040)

{

stat_T swap_st;

if (mch_stat((char *)swap_fname, &swap_st) >= 0

&& st.st_gid != swap_st.st_gid

# ifdef HAVE_FCHOWN

&& fchown(curbuf->b_ml.ml_mfp->mf_fd, -1, st.st_gid)

== -1

# endif

)

swap_mode &= 0600;

}

(void)mch_setperm(swap_fname, (long)swap_mode);

}

#endif

}

#if defined(HAS_SWAP_EXISTS_ACTION)

/* If "Quit" selected at ATTENTION dialog, don't load the file */

if (swap_exists_action == SEA_QUIT)

{

if (!read_buffer && !read_stdin)

close(fd);

return FAIL;

}

#endif

++no_wait_return; /* don't wait for return yet */

/*

* Set '[ mark to the line above where the lines go (line 1 if zero).

*/

curbuf->b_op_start.lnum = ((from == 0) ? 1 : from);

curbuf->b_op_start.col = 0;

try_mac = (vim_strchr(p_ffs, 'm') != NULL);

try_dos = (vim_strchr(p_ffs, 'd') != NULL);

try_unix = (vim_strchr(p_ffs, 'x') != NULL);

if (!read_buffer)

{

int m = msg_scroll;

int n = msg_scrolled;

/*

* The file must be closed again, the autocommands may want to change

* the file before reading it.

*/

if (!read_stdin)

close(fd); /* ignore errors */

/*

* The output from the autocommands should not overwrite anything and

* should not be overwritten: Set msg_scroll, restore its value if no

* output was done.

*/

msg_scroll = TRUE;

if (filtering)

apply_autocmds_exarg(EVENT_FILTERREADPRE, NULL, sfname,

FALSE, curbuf, eap);

else if (read_stdin)

apply_autocmds_exarg(EVENT_STDINREADPRE, NULL, sfname,

FALSE, curbuf, eap);

else if (newfile)

apply_autocmds_exarg(EVENT_BUFREADPRE, NULL, sfname,

FALSE, curbuf, eap);

else

apply_autocmds_exarg(EVENT_FILEREADPRE, sfname, sfname,

FALSE, NULL, eap);

/* autocommands may have changed it */

try_mac = (vim_strchr(p_ffs, 'm') != NULL);

try_dos = (vim_strchr(p_ffs, 'd') != NULL);

try_unix = (vim_strchr(p_ffs, 'x') != NULL);

if (msg_scrolled == n)

msg_scroll = m;

#ifdef FEAT_EVAL

if (aborting()) /* autocmds may abort script processing */

{

--no_wait_return;

msg_scroll = msg_save;

curbuf->b_p_ro = TRUE; /* must use "w!" now */

return FAIL;

}

#endif

/*

* Don't allow the autocommands to change the current buffer.

* Try to re-open the file.

*

* Don't allow the autocommands to change the buffer name either

* (cd for example) if it invalidates fname or sfname.

*/

if (!read_stdin && (curbuf != old_curbuf

|| (using_b_ffname && (old_b_ffname != curbuf->b_ffname))

|| (using_b_fname && (old_b_fname != curbuf->b_fname))

|| (fd = mch_open((char *)fname, O_RDONLY | O_EXTRA, 0)) < 0))

{

--no_wait_return;

msg_scroll = msg_save;

if (fd < 0)

emsg(_("E200: *ReadPre autocommands made the file unreadable"));

else

emsg(_("E201: *ReadPre autocommands must not change current buffer"));

curbuf->b_p_ro = TRUE; /* must use "w!" now */

return FAIL;

}

}

/* Autocommands may add lines to the file, need to check if it is empty */

wasempty = (curbuf->b_ml.ml_flags & ML_EMPTY);

if (!recoverymode && !filtering && !(flags & READ_DUMMY))

{

/*

* Show the user that we are busy reading the input. Sometimes this

* may take a while. When reading from stdin another program may

* still be running, don't move the cursor to the last line, unless

* always using the GUI.

*/

if (read_stdin)

{

if (!is_not_a_term())

{

#ifndef ALWAYS_USE_GUI

mch_msg(_("Vim: Reading from stdin...\n"));

#endif

#ifdef FEAT_GUI

/* Also write a message in the GUI window, if there is one. */

if (gui.in_use && !gui.dying && !gui.starting)

{

p = (char_u *)_("Reading from stdin...");

gui_write(p, (int)STRLEN(p));

}

#endif

}

}

else if (!read_buffer)

filemess(curbuf, sfname, (char_u *)"", 0);

}

msg_scroll = FALSE; /* overwrite the file message */

/*

* Set linecnt now, before the "retry" caused by a wrong guess for

* fileformat, and after the autocommands, which may change them.

*/

linecnt = curbuf->b_ml.ml_line_count;

/* "++bad=" argument. */

if (eap != NULL && eap->bad_char != 0)

{

bad_char_behavior = eap->bad_char;

if (set_options)

curbuf->b_bad_char = eap->bad_char;

}

else

curbuf->b_bad_char = 0;

/*

* Decide which 'encoding' to use or use first.

*/

if (eap != NULL && eap->force_enc != 0)

{

fenc = enc_canonize(eap->cmd + eap->force_enc);

fenc_alloced = TRUE;

keep_dest_enc = TRUE;

}

else if (curbuf->b_p_bin)

{

fenc = (char_u *)""; /* binary: don't convert */

fenc_alloced = FALSE;

}

else if (curbuf->b_help)

{

char_u firstline[80];

int fc;

/* Help files are either utf-8 or latin1. Try utf-8 first, if this

* fails it must be latin1.

* Always do this when 'encoding' is "utf-8". Otherwise only do

* this when needed to avoid [converted] remarks all the time.

* It is needed when the first line contains non-ASCII characters.

* That is only in *.??x files. */

fenc = (char_u *)"latin1";

c = enc_utf8;

if (!c && !read_stdin)

{

fc = fname[STRLEN(fname) - 1];

if (TOLOWER_ASC(fc) == 'x')

{

/* Read the first line (and a bit more). Immediately rewind to

* the start of the file. If the read() fails "len" is -1. */

len = read_eintr(fd, firstline, 80);

vim_lseek(fd, (off_T)0L, SEEK_SET);

for (p = firstline; p < firstline + len; ++p)

if (*p >= 0x80)

{

c = TRUE;

break;

}

}

}

if (c)

{

fenc_next = fenc;

fenc = (char_u *)"utf-8";

/* When the file is utf-8 but a character doesn't fit in

* 'encoding' don't retry. In help text editing utf-8 bytes

* doesn't make sense. */

if (!enc_utf8)

keep_dest_enc = TRUE;

}

fenc_alloced = FALSE;

}

else if (*p_fencs == NUL)

{

fenc = curbuf->b_p_fenc; /* use format from buffer */

fenc_alloced = FALSE;

}

else

{

fenc_next = p_fencs; /* try items in 'fileencodings' */

fenc = next_fenc(&fenc_next);

fenc_alloced = TRUE;

}

/*

* Jump back here to retry reading the file in different ways.

* Reasons to retry:

* - encoding conversion failed: try another one from "fenc_next"

* - BOM detected and fenc was set, need to setup conversion

* - "fileformat" check failed: try another

*

* Variables set for special retry actions:

* "file_rewind" Rewind the file to start reading it again.

* "advance_fenc" Advance "fenc" using "fenc_next".

* "skip_read" Re-use already read bytes (BOM detected).

* "did_iconv" iconv() conversion failed, try 'charconvert'.

* "keep_fileformat" Don't reset "fileformat".

*

* Other status indicators:

* "tmpname" When != NULL did conversion with 'charconvert'.

* Output file has to be deleted afterwards.

* "iconv_fd" When != -1 did conversion with iconv().

*/

retry:

if (file_rewind)

{

if (read_buffer)

{

read_buf_lnum = 1;

read_buf_col = 0;

}

else if (read_stdin || vim_lseek(fd, (off_T)0L, SEEK_SET) != 0)

{

/* Can't rewind the file, give up. */

error = TRUE;

goto failed;

}

/* Delete the previously read lines. */

while (lnum > from)

ml_delete(lnum--, FALSE);

file_rewind = FALSE;

if (set_options)

{

curbuf->b_p_bomb = FALSE;

curbuf->b_start_bomb = FALSE;

}

conv_error = 0;

}

/*

* When retrying with another "fenc" and the first time "fileformat"

* will be reset.

*/

if (keep_fileformat)

keep_fileformat = FALSE;

else

{

if (eap != NULL && eap->force_ff != 0)

{

fileformat = get_fileformat_force(curbuf, eap);

try_unix = try_dos = try_mac = FALSE;

}

else if (curbuf->b_p_bin)

fileformat = EOL_UNIX; /* binary: use Unix format */

else if (*p_ffs == NUL)

fileformat = get_fileformat(curbuf);/* use format from buffer */

else

fileformat = EOL_UNKNOWN; /* detect from file */

}

#ifdef USE_ICONV

if (iconv_fd != (iconv_t)-1)

{

/* aborted conversion with iconv(), close the descriptor */

iconv_close(iconv_fd);

iconv_fd = (iconv_t)-1;

}

#endif

if (advance_fenc)

{

/*

* Try the next entry in 'fileencodings'.

*/

advance_fenc = FALSE;

if (eap != NULL && eap->force_enc != 0)

{

/* Conversion given with "++cc=" wasn't possible, read

* without conversion. */

notconverted = TRUE;

conv_error = 0;

if (fenc_alloced)

vim_free(fenc);

fenc = (char_u *)"";

fenc_alloced = FALSE;

}

else

{

if (fenc_alloced)

vim_free(fenc);

if (fenc_next != NULL)

{

fenc = next_fenc(&fenc_next);

fenc_alloced = (fenc_next != NULL);