diff --git a/src/memline.c b/src/memline.c
new file mode 100644
index 0000000..7c18663
--- /dev/null
+++ b/src/memline.c
@@ -0,0 +1,4378 @@
+/* vi:set ts=8 sts=4 sw=4:
+ *
+ * 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.
+ */
+
+/* for debugging */
+/* #define CHECK(c, s)	if (c) EMSG(s) */
+#define CHECK(c, s)
+
+/*
+ * memline.c: Contains the functions for appending, deleting and changing the
+ * text lines. The memfile functions are used to store the information in blocks
+ * of memory, backed up by a file. The structure of the information is a tree.
+ * The root of the tree is a pointer block. The leaves of the tree are data
+ * blocks. In between may be several layers of pointer blocks, forming branches.
+ *
+ * Three types of blocks are used:
+ * - Block nr 0 contains information for recovery
+ * - Pointer blocks contain list of pointers to other blocks.
+ * - Data blocks contain the actual text.
+ *
+ * Block nr 0 contains the block0 structure (see below).
+ *
+ * Block nr 1 is the first pointer block. It is the root of the tree.
+ * Other pointer blocks are branches.
+ *
+ *  If a line is too big to fit in a single page, the block containing that
+ *  line is made big enough to hold the line. It may span several pages.
+ *  Otherwise all blocks are one page.
+ *
+ *  A data block that was filled when starting to edit a file and was not
+ *  changed since then, can have a negative block number. This means that it
+ *  has not yet been assigned a place in the file. When recovering, the lines
+ *  in this data block can be read from the original file. When the block is
+ *  changed (lines appended/deleted/changed) or when it is flushed it gets a
+ *  positive number. Use mf_trans_del() to get the new number, before calling
+ *  mf_get().
+ */
+
+#if defined(MSDOS) || defined(WIN32) || defined(_WIN64)
+# include <io.h>
+#endif
+
+#include "vim.h"
+
+#ifdef HAVE_FCNTL_H
+# include <fcntl.h>
+#endif
+#ifndef UNIX		/* it's in os_unix.h for Unix */
+# include <time.h>
+#endif
+
+#ifdef SASC
+# include <proto/dos.h>	    /* for Open() and Close() */
+#endif
+
+typedef struct block0		ZERO_BL;    /* contents of the first block */
+typedef struct pointer_block	PTR_BL;	    /* contents of a pointer block */
+typedef struct data_block	DATA_BL;    /* contents of a data block */
+typedef struct pointer_entry	PTR_EN;	    /* block/line-count pair */
+
+#define DATA_ID	    (('d' << 8) + 'a')	    /* data block id */
+#define PTR_ID	    (('p' << 8) + 't')	    /* pointer block id */
+#define BLOCK0_ID0  'b'			    /* block 0 id 0 */
+#define BLOCK0_ID1  '0'			    /* block 0 id 1 */
+
+/*
+ * pointer to a block, used in a pointer block
+ */
+struct pointer_entry
+{
+    blocknr_T	pe_bnum;	/* block number */
+    linenr_T	pe_line_count;	/* number of lines in this branch */
+    linenr_T	pe_old_lnum;	/* lnum for this block (for recovery) */
+    int		pe_page_count;	/* number of pages in block pe_bnum */
+};
+
+/*
+ * A pointer block contains a list of branches in the tree.
+ */
+struct pointer_block
+{
+    short_u	pb_id;		/* ID for pointer block: PTR_ID */
+    short_u	pb_count;	/* number of pointer in this block */
+    short_u	pb_count_max;	/* maximum value for pb_count */
+    PTR_EN	pb_pointer[1];	/* list of pointers to blocks (actually longer)
+				 * followed by empty space until end of page */
+};
+
+/*
+ * A data block is a leaf in the tree.
+ *
+ * The text of the lines is at the end of the block. The text of the first line
+ * in the block is put at the end, the text of the second line in front of it,
+ * etc. Thus the order of the lines is the opposite of the line number.
+ */
+struct data_block
+{
+    short_u	db_id;		/* ID for data block: DATA_ID */
+    unsigned	db_free;	/* free space available */
+    unsigned	db_txt_start;	/* byte where text starts */
+    unsigned	db_txt_end;	/* byte just after data block */
+    linenr_T	db_line_count;	/* number of lines in this block */
+    unsigned	db_index[1];	/* index for start of line (actually bigger)
+				 * followed by empty space upto db_txt_start
+				 * followed by the text in the lines until
+				 * end of page */
+};
+
+/*
+ * The low bits of db_index hold the actual index. The topmost bit is
+ * used for the global command to be able to mark a line.
+ * This method is not clean, but otherwise there would be at least one extra
+ * byte used for each line.
+ * The mark has to be in this place to keep it with the correct line when other
+ * lines are inserted or deleted.
+ */
+#define DB_MARKED	((unsigned)1 << ((sizeof(unsigned) * 8) - 1))
+#define DB_INDEX_MASK	(~DB_MARKED)
+
+#define INDEX_SIZE  (sizeof(unsigned))	    /* size of one db_index entry */
+#define HEADER_SIZE (sizeof(DATA_BL) - INDEX_SIZE)  /* size of data block header */
+
+#define B0_FNAME_SIZE	900
+#define B0_UNAME_SIZE	40
+#define B0_HNAME_SIZE	40
+/*
+ * Restrict the numbers to 32 bits, otherwise most compilers will complain.
+ * This won't detect a 64 bit machine that only swaps a byte in the top 32
+ * bits, but that is crazy anyway.
+ */
+#define B0_MAGIC_LONG	0x30313233L
+#define B0_MAGIC_INT	0x20212223L
+#define B0_MAGIC_SHORT	0x10111213L
+#define B0_MAGIC_CHAR	0x55
+
+/*
+ * Block zero holds all info about the swap file.
+ *
+ * NOTE: DEFINITION OF BLOCK 0 SHOULD NOT CHANGE! It would make all existing
+ * swap files unusable!
+ *
+ * If size of block0 changes anyway, adjust MIN_SWAP_PAGE_SIZE in vim.h!!
+ *
+ * This block is built up of single bytes, to make it portable accros
+ * different machines. b0_magic_* is used to check the byte order and size of
+ * variables, because the rest of the swap file is not portable.
+ */
+struct block0
+{
+    char_u	b0_id[2];	/* id for block 0: BLOCK0_ID0 and BLOCK0_ID1 */
+    char_u	b0_version[10];	/* Vim version string */
+    char_u	b0_page_size[4];/* number of bytes per page */
+    char_u	b0_mtime[4];	/* last modification time of file */
+    char_u	b0_ino[4];	/* inode of b0_fname */
+    char_u	b0_pid[4];	/* process id of creator (or 0) */
+    char_u	b0_uname[B0_UNAME_SIZE]; /* name of user (uid if no name) */
+    char_u	b0_hname[B0_HNAME_SIZE]; /* host name (if it has a name) */
+    char_u	b0_fname[B0_FNAME_SIZE]; /* name of file being edited */
+    long	b0_magic_long;	/* check for byte order of long */
+    int		b0_magic_int;	/* check for byte order of int */
+    short	b0_magic_short;	/* check for byte order of short */
+    char_u	b0_magic_char;	/* check for last char */
+};
+#define   b0_dirty b0_fname[B0_FNAME_SIZE-1]
+
+#define STACK_INCR	5	/* nr of entries added to ml_stack at a time */
+
+/*
+ * The line number where the first mark may be is remembered.
+ * If it is 0 there are no marks at all.
+ * (always used for the current buffer only, no buffer change possible while
+ * executing a global command).
+ */
+static linenr_T	lowest_marked = 0;
+
+/*
+ * arguments for ml_find_line()
+ */
+#define ML_DELETE	0x11	    /* delete line */
+#define ML_INSERT	0x12	    /* insert line */
+#define ML_FIND		0x13	    /* just find the line */
+#define ML_FLUSH	0x02	    /* flush locked block */
+#define ML_SIMPLE(x)	(x & 0x10)  /* DEL, INS or FIND */
+
+static void set_b0_fname __ARGS((ZERO_BL *, buf_T *buf));
+static time_t swapfile_info __ARGS((char_u *));
+static int recov_file_names __ARGS((char_u **, char_u *, int prepend_dot));
+static int ml_append_int __ARGS((buf_T *, linenr_T, char_u *, colnr_T, int, int));
+static int ml_delete_int __ARGS((buf_T *, linenr_T, int));
+static char_u *findswapname __ARGS((buf_T *, char_u **, char_u *));
+static void ml_flush_line __ARGS((buf_T *));
+static bhdr_T *ml_new_data __ARGS((memfile_T *, int, int));
+static bhdr_T *ml_new_ptr __ARGS((memfile_T *));
+static bhdr_T *ml_find_line __ARGS((buf_T *, linenr_T, int));
+static int ml_add_stack __ARGS((buf_T *));
+static char_u *makeswapname __ARGS((buf_T *, char_u *));
+static void ml_lineadd __ARGS((buf_T *, int));
+static int b0_magic_wrong __ARGS((ZERO_BL *));
+#ifdef CHECK_INODE
+static int fnamecmp_ino __ARGS((char_u *, char_u *, long));
+#endif
+static void long_to_char __ARGS((long, char_u *));
+static long char_to_long __ARGS((char_u *));
+#if defined(UNIX) || defined(WIN3264)
+static char_u *make_percent_swname __ARGS((char_u *dir, char_u *name));
+#endif
+#ifdef FEAT_BYTEOFF
+static void ml_updatechunk __ARGS((buf_T *buf, long line, long len, int updtype));
+#endif
+
+/*
+ * open a new memline for 'curbuf'
+ *
+ * return FAIL for failure, OK otherwise
+ */
+    int
+ml_open()
+{
+    memfile_T	*mfp;
+    bhdr_T	*hp = NULL;
+    ZERO_BL	*b0p;
+    PTR_BL	*pp;
+    DATA_BL	*dp;
+
+/*
+ * init fields in memline struct
+ */
+    curbuf->b_ml.ml_stack_size = 0;	/* no stack yet */
+    curbuf->b_ml.ml_stack = NULL;	/* no stack yet */
+    curbuf->b_ml.ml_stack_top = 0;	/* nothing in the stack */
+    curbuf->b_ml.ml_locked = NULL;	/* no cached block */
+    curbuf->b_ml.ml_line_lnum = 0;	/* no cached line */
+#ifdef FEAT_BYTEOFF
+    curbuf->b_ml.ml_chunksize = NULL;
+#endif
+
+/*
+ * When 'updatecount' is non-zero, flag that a swap file may be opened later.
+ */
+    if (p_uc && curbuf->b_p_swf)
+	curbuf->b_may_swap = TRUE;
+    else
+	curbuf->b_may_swap = FALSE;
+
+/*
+ * Open the memfile.  No swap file is created yet.
+ */
+    mfp = mf_open(NULL, 0);
+    if (mfp == NULL)
+	goto error;
+
+    curbuf->b_ml.ml_mfp = mfp;
+    curbuf->b_ml.ml_flags = ML_EMPTY;
+    curbuf->b_ml.ml_line_count = 1;
+
+#if defined(MSDOS) && !defined(DJGPP)
+    /* for 16 bit MS-DOS create a swapfile now, because we run out of
+     * memory very quickly */
+    if (p_uc != 0)
+	ml_open_file(curbuf);
+#endif
+
+/*
+ * fill block0 struct and write page 0
+ */
+    if ((hp = mf_new(mfp, FALSE, 1)) == NULL)
+	goto error;
+    if (hp->bh_bnum != 0)
+    {
+	EMSG(_("E298: Didn't get block nr 0?"));
+	goto error;
+    }
+    b0p = (ZERO_BL *)(hp->bh_data);
+
+    b0p->b0_id[0] = BLOCK0_ID0;
+    b0p->b0_id[1] = BLOCK0_ID1;
+    b0p->b0_dirty = curbuf->b_changed ? 0x55 : 0;
+    b0p->b0_magic_long = (long)B0_MAGIC_LONG;
+    b0p->b0_magic_int = (int)B0_MAGIC_INT;
+    b0p->b0_magic_short = (short)B0_MAGIC_SHORT;
+    b0p->b0_magic_char = B0_MAGIC_CHAR;
+
+    STRNCPY(b0p->b0_version, "VIM ", 4);
+    STRNCPY(b0p->b0_version + 4, Version, 6);
+    set_b0_fname(b0p, curbuf);
+    long_to_char((long)mfp->mf_page_size, b0p->b0_page_size);
+    (void)get_user_name(b0p->b0_uname, B0_UNAME_SIZE);
+    b0p->b0_uname[B0_UNAME_SIZE - 1] = NUL;
+    mch_get_host_name(b0p->b0_hname, B0_HNAME_SIZE);
+    b0p->b0_hname[B0_HNAME_SIZE - 1] = NUL;
+    long_to_char(mch_get_pid(), b0p->b0_pid);
+
+    /*
+     * Always sync block number 0 to disk, so we can check the file name in
+     * the swap file in findswapname(). Don't do this for help files though.
+     * Only works when there's a swapfile, otherwise it's done when the file
+     * is created.
+     */
+    mf_put(mfp, hp, TRUE, FALSE);
+    if (!curbuf->b_help)
+	(void)mf_sync(mfp, 0);
+
+/*
+ * fill in root pointer block and write page 1
+ */
+    if ((hp = ml_new_ptr(mfp)) == NULL)
+	goto error;
+    if (hp->bh_bnum != 1)
+    {
+	EMSG(_("E298: Didn't get block nr 1?"));
+	goto error;
+    }
+    pp = (PTR_BL *)(hp->bh_data);
+    pp->pb_count = 1;
+    pp->pb_pointer[0].pe_bnum = 2;
+    pp->pb_pointer[0].pe_page_count = 1;
+    pp->pb_pointer[0].pe_old_lnum = 1;
+    pp->pb_pointer[0].pe_line_count = 1;    /* line count after insertion */
+    mf_put(mfp, hp, TRUE, FALSE);
+
+/*
+ * allocate first data block and create an empty line 1.
+ */
+    if ((hp = ml_new_data(mfp, FALSE, 1)) == NULL)
+	goto error;
+    if (hp->bh_bnum != 2)
+    {
+	EMSG(_("E298: Didn't get block nr 2?"));
+	goto error;
+    }
+
+    dp = (DATA_BL *)(hp->bh_data);
+    dp->db_index[0] = --dp->db_txt_start;	/* at end of block */
+    dp->db_free -= 1 + INDEX_SIZE;
+    dp->db_line_count = 1;
+    *((char_u *)dp + dp->db_txt_start) = NUL;	/* emtpy line */
+
+    return OK;
+
+error:
+    if (mfp != NULL)
+    {
+	if (hp)
+	    mf_put(mfp, hp, FALSE, FALSE);
+	mf_close(mfp, TRUE);	    /* will also free(mfp->mf_fname) */
+    }
+    curbuf->b_ml.ml_mfp = NULL;
+    return FAIL;
+}
+
+/*
+ * ml_setname() is called when the file name of "buf" has been changed.
+ * It may rename the swap file.
+ */
+    void
+ml_setname(buf)
+    buf_T	*buf;
+{
+    int		success = FALSE;
+    memfile_T	*mfp;
+    char_u	*fname;
+    char_u	*dirp;
+#if defined(MSDOS) || defined(MSWIN)
+    char_u	*p;
+#endif
+
+    mfp = buf->b_ml.ml_mfp;
+    if (mfp->mf_fd < 0)		    /* there is no swap file yet */
+    {
+	/*
+	 * When 'updatecount' is 0 and 'noswapfile' there is no swap file.
+	 * For help files we will make a swap file now.
+	 */
+	if (p_uc != 0)
+	    ml_open_file(buf);	    /* create a swap file */
+	return;
+    }
+
+    /*
+     * Try all directories in the 'directory' option.
+     */
+    dirp = p_dir;
+    for (;;)
+    {
+	if (*dirp == NUL)	    /* tried all directories, fail */
+	    break;
+	fname = findswapname(buf, &dirp, mfp->mf_fname); /* alloc's fname */
+	if (fname == NULL)	    /* no file name found for this dir */
+	    continue;
+
+#if defined(MSDOS) || defined(MSWIN)
+	/*
+	 * Set full pathname for swap file now, because a ":!cd dir" may
+	 * change directory without us knowing it.
+	 */
+	p = FullName_save(fname, FALSE);
+	vim_free(fname);
+	fname = p;
+	if (fname == NULL)
+	    continue;
+#endif
+	/* if the file name is the same we don't have to do anything */
+	if (fnamecmp(fname, mfp->mf_fname) == 0)
+	{
+	    vim_free(fname);
+	    success = TRUE;
+	    break;
+	}
+	/* need to close the swap file before renaming */
+	if (mfp->mf_fd >= 0)
+	{
+	    close(mfp->mf_fd);
+	    mfp->mf_fd = -1;
+	}
+
+	/* try to rename the swap file */
+	if (vim_rename(mfp->mf_fname, fname) == 0)
+	{
+	    success = TRUE;
+	    vim_free(mfp->mf_fname);
+	    mfp->mf_fname = fname;
+	    vim_free(mfp->mf_ffname);
+#if defined(MSDOS) || defined(MSWIN)
+	    mfp->mf_ffname = NULL;  /* mf_fname is full pathname already */
+#else
+	    mf_set_ffname(mfp);
+#endif
+	    break;
+	}
+	vim_free(fname);	    /* this fname didn't work, try another */
+    }
+
+    if (mfp->mf_fd == -1)	    /* need to (re)open the swap file */
+    {
+	mfp->mf_fd = mch_open((char *)mfp->mf_fname, O_RDWR | O_EXTRA, 0);
+	if (mfp->mf_fd < 0)
+	{
+	    /* could not (re)open the swap file, what can we do???? */
+	    EMSG(_("E301: Oops, lost the swap file!!!"));
+	    return;
+	}
+    }
+    if (!success)
+	EMSG(_("E302: Could not rename swap file"));
+}
+
+/*
+ * Open a file for the memfile for all buffers that are not readonly or have
+ * been modified.
+ * Used when 'updatecount' changes from zero to non-zero.
+ */
+    void
+ml_open_files()
+{
+    buf_T	*buf;
+
+    for (buf = firstbuf; buf != NULL; buf = buf->b_next)
+	if (!buf->b_p_ro || buf->b_changed)
+	    ml_open_file(buf);
+}
+
+/*
+ * Open a swap file for an existing memfile, if there is no swap file yet.
+ * If we are unable to find a file name, mf_fname will be NULL
+ * and the memfile will be in memory only (no recovery possible).
+ */
+    void
+ml_open_file(buf)
+    buf_T	*buf;
+{
+    memfile_T	*mfp;
+    char_u	*fname;
+    char_u	*dirp;
+
+    mfp = buf->b_ml.ml_mfp;
+    if (mfp == NULL || mfp->mf_fd >= 0 || !buf->b_p_swf)
+	return;		/* nothing to do */
+
+    /*
+     * Try all directories in 'directory' option.
+     */
+    dirp = p_dir;
+    for (;;)
+    {
+	if (*dirp == NUL)
+	    break;
+	/* There is a small chance that between chosing the swap file name and
+	 * creating it, another Vim creates the file.  In that case the
+	 * creation will fail and we will use another directory. */
+	fname = findswapname(buf, &dirp, NULL);	/* allocates fname */
+	if (fname == NULL)
+	    continue;
+	if (mf_open_file(mfp, fname) == OK)	/* consumes fname! */
+	{
+#if defined(MSDOS) || defined(MSWIN) || defined(RISCOS)
+	    /*
+	     * set full pathname for swap file now, because a ":!cd dir" may
+	     * change directory without us knowing it.
+	     */
+	    mf_fullname(mfp);
+#endif
+	    /* Flush block zero, so others can read it */
+	    if (mf_sync(mfp, MFS_ZERO) == OK)
+		break;
+	    /* Writing block 0 failed: close the file and try another dir */
+	    mf_close_file(buf, FALSE);
+	}
+    }
+
+    if (mfp->mf_fname == NULL)		/* Failed! */
+    {
+	need_wait_return = TRUE;	/* call wait_return later */
+	++no_wait_return;
+	(void)EMSG2(_("E303: Unable to open swap file for \"%s\", recovery impossible"),
+		    buf_spname(buf) != NULL
+			? (char_u *)buf_spname(buf)
+			: buf->b_fname);
+	--no_wait_return;
+    }
+
+    /* don't try to open a swap file again */
+    buf->b_may_swap = FALSE;
+}
+
+/*
+ * If still need to create a swap file, and starting to edit a not-readonly
+ * file, or reading into an existing buffer, create a swap file now.
+ */
+    void
+check_need_swap(newfile)
+    int	    newfile;		/* reading file into new buffer */
+{
+    if (curbuf->b_may_swap && (!curbuf->b_p_ro || !newfile))
+	ml_open_file(curbuf);
+}
+
+/*
+ * Close memline for buffer 'buf'.
+ * If 'del_file' is TRUE, delete the swap file
+ */
+    void
+ml_close(buf, del_file)
+    buf_T	*buf;
+    int		del_file;
+{
+    if (buf->b_ml.ml_mfp == NULL)		/* not open */
+	return;
+    mf_close(buf->b_ml.ml_mfp, del_file);	/* close the .swp file */
+    if (buf->b_ml.ml_line_lnum != 0 && (buf->b_ml.ml_flags & ML_LINE_DIRTY))
+	vim_free(buf->b_ml.ml_line_ptr);
+    vim_free(buf->b_ml.ml_stack);
+#ifdef FEAT_BYTEOFF
+    vim_free(buf->b_ml.ml_chunksize);
+    buf->b_ml.ml_chunksize = NULL;
+#endif
+    buf->b_ml.ml_mfp = NULL;
+
+    /* Reset the "recovered" flag, give the ATTENTION prompt the next time
+     * this buffer is loaded. */
+    buf->b_flags &= ~BF_RECOVERED;
+}
+
+/*
+ * Close all existing memlines and memfiles.
+ * Only used when exiting.
+ * When 'del_file' is TRUE, delete the memfiles.
+ */
+    void
+ml_close_all(del_file)
+    int		del_file;
+{
+    buf_T	*buf;
+
+    for (buf = firstbuf; buf != NULL; buf = buf->b_next)
+	ml_close(buf, del_file);
+#ifdef TEMPDIRNAMES
+    vim_deltempdir();	    /* delete created temp directory */
+#endif
+}
+
+/*
+ * Close all memfiles for not modified buffers.
+ * Only use just before exiting!
+ */
+    void
+ml_close_notmod()
+{
+    buf_T	*buf;
+
+    for (buf = firstbuf; buf != NULL; buf = buf->b_next)
+	if (!bufIsChanged(buf))
+	    ml_close(buf, TRUE);    /* close all not-modified buffers */
+}
+
+/*
+ * Update the timestamp in the .swp file.
+ * Used when the file has been written.
+ */
+    void
+ml_timestamp(buf)
+    buf_T	*buf;
+{
+    memfile_T	*mfp;
+    bhdr_T	*hp;
+    ZERO_BL	*b0p;
+
+    mfp = buf->b_ml.ml_mfp;
+
+    if (mfp == NULL || (hp = mf_get(mfp, (blocknr_T)0, 1)) == NULL)
+	return;
+    b0p = (ZERO_BL *)(hp->bh_data);
+    if (b0p->b0_id[0] != BLOCK0_ID0 || b0p->b0_id[1] != BLOCK0_ID1)
+	EMSG(_("E304: ml_timestamp: Didn't get block 0??"));
+    else
+	set_b0_fname(b0p, buf);
+    mf_put(mfp, hp, TRUE, FALSE);
+}
+
+/*
+ * Write file name and timestamp into block 0 of a swap file.
+ * Also set buf->b_mtime.
+ * Don't use NameBuff[]!!!
+ */
+    static void
+set_b0_fname(b0p, buf)
+    ZERO_BL	*b0p;
+    buf_T	*buf;
+{
+    struct stat	st;
+
+    if (buf->b_ffname == NULL)
+	b0p->b0_fname[0] = NUL;
+    else
+    {
+#if defined(MSDOS) || defined(MSWIN) || defined(AMIGA) || defined(RISCOS)
+	/* systems that cannot translate "~user" back into a path: copy the
+	 * file name unmodified */
+	STRNCPY(b0p->b0_fname, buf->b_ffname, B0_FNAME_SIZE);
+#else
+	size_t	flen, ulen;
+	char_u	uname[B0_UNAME_SIZE];
+
+	/*
+	 * For a file under the home directory of the current user, we try to
+	 * replace the home directory path with "~user". This helps when
+	 * editing the same file on different machines over a network.
+	 * First replace home dir path with "~/" with home_replace().
+	 * Then insert the user name to get "~user/".
+	 */
+	home_replace(NULL, buf->b_ffname, b0p->b0_fname, B0_FNAME_SIZE, TRUE);
+	if (b0p->b0_fname[0] == '~')
+	{
+	    flen = STRLEN(b0p->b0_fname);
+	    /* If there is no user name or it is too long, don't use "~/" */
+	    if (get_user_name(uname, B0_UNAME_SIZE) == FAIL
+			 || (ulen = STRLEN(uname)) + flen > B0_FNAME_SIZE - 1)
+		STRNCPY(b0p->b0_fname, buf->b_ffname, B0_FNAME_SIZE);
+	    else
+	    {
+		mch_memmove(b0p->b0_fname + ulen + 1, b0p->b0_fname + 1, flen);
+		mch_memmove(b0p->b0_fname + 1, uname, ulen);
+	    }
+	}
+#endif
+	if (mch_stat((char *)buf->b_ffname, &st) >= 0)
+	{
+	    long_to_char((long)st.st_mtime, b0p->b0_mtime);
+#ifdef CHECK_INODE
+	    long_to_char((long)st.st_ino, b0p->b0_ino);
+#endif
+	    buf_store_time(buf, &st, buf->b_ffname);
+	    buf->b_mtime_read = buf->b_mtime;
+	}
+	else
+	{
+	    long_to_char(0L, b0p->b0_mtime);
+#ifdef CHECK_INODE
+	    long_to_char(0L, b0p->b0_ino);
+#endif
+	    buf->b_mtime = 0;
+	    buf->b_mtime_read = 0;
+	    buf->b_orig_size = 0;
+	    buf->b_orig_mode = 0;
+	}
+    }
+}
+
+/*
+ * try to recover curbuf from the .swp file
+ */
+    void
+ml_recover()
+{
+    buf_T	*buf = NULL;
+    memfile_T	*mfp = NULL;
+    char_u	*fname;
+    bhdr_T	*hp = NULL;
+    ZERO_BL	*b0p;
+    PTR_BL	*pp;
+    DATA_BL	*dp;
+    infoptr_T	*ip;
+    blocknr_T	bnum;
+    int		page_count;
+    struct stat	org_stat, swp_stat;
+    int		len;
+    int		directly;
+    linenr_T	lnum;
+    char_u	*p;
+    int		i;
+    long	error;
+    int		cannot_open;
+    linenr_T	line_count;
+    int		has_error;
+    int		idx;
+    int		top;
+    int		txt_start;
+    off_t	size;
+    int		called_from_main;
+    int		serious_error = TRUE;
+    long	mtime;
+    int		attr;
+
+    recoverymode = TRUE;
+    called_from_main = (curbuf->b_ml.ml_mfp == NULL);
+    attr = hl_attr(HLF_E);
+/*
+ * If the file name ends in ".sw?" we use it directly.
+ * Otherwise a search is done to find the swap file(s).
+ */
+    fname = curbuf->b_fname;
+    if (fname == NULL)		    /* When there is no file name */
+	fname = (char_u *)"";
+    len = (int)STRLEN(fname);
+    if (len >= 4 &&
+#if defined(VMS) || defined(RISCOS)
+	    STRNICMP(fname + len - 4, "_sw" , 3)
+#else
+	    STRNICMP(fname + len - 4, ".sw" , 3)
+#endif
+		== 0)
+    {
+	directly = TRUE;
+	fname = vim_strsave(fname); /* make a copy for mf_open() */
+    }
+    else
+    {
+	directly = FALSE;
+
+	/* count the number of matching swap files */
+	len = recover_names(&fname, FALSE, 0);
+	if (len == 0)		    /* no swap files found */
+	{
+	    EMSG2(_("E305: No swap file found for %s"), fname);
+	    goto theend;
+	}
+	if (len == 1)		    /* one swap file found, use it */
+	    i = 1;
+	else			    /* several swap files found, choose */
+	{
+	    /* list the names of the swap files */
+	    (void)recover_names(&fname, TRUE, 0);
+	    msg_putchar('\n');
+	    MSG_PUTS(_("Enter number of swap file to use (0 to quit): "));
+	    i = get_number(FALSE);
+	    if (i < 1 || i > len)
+		goto theend;
+	}
+	/* get the swap file name that will be used */
+	(void)recover_names(&fname, FALSE, i);
+    }
+    if (fname == NULL)
+	goto theend;			/* out of memory */
+
+    /* When called from main() still need to initialize storage structure */
+    if (called_from_main && ml_open() == FAIL)
+	getout(1);
+
+/*
+ * allocate a buffer structure (only the memline in it is really used)
+ */
+    buf = (buf_T *)alloc((unsigned)sizeof(buf_T));
+    if (buf == NULL)
+    {
+	vim_free(fname);
+	goto theend;
+    }
+
+/*
+ * init fields in memline struct
+ */
+    buf->b_ml.ml_stack_size = 0;	/* no stack yet */
+    buf->b_ml.ml_stack = NULL;		/* no stack yet */
+    buf->b_ml.ml_stack_top = 0;		/* nothing in the stack */
+    buf->b_ml.ml_line_lnum = 0;		/* no cached line */
+    buf->b_ml.ml_locked = NULL;		/* no locked block */
+    buf->b_ml.ml_flags = 0;
+
+/*
+ * open the memfile from the old swap file
+ */
+    p = vim_strsave(fname);		/* save fname for the message
+					   (mf_open() may free fname) */
+    mfp = mf_open(fname, O_RDONLY);	/* consumes fname! */
+    if (mfp == NULL || mfp->mf_fd < 0)
+    {
+	if (p != NULL)
+	{
+	    EMSG2(_("E306: Cannot open %s"), p);
+	    vim_free(p);
+	}
+	goto theend;
+    }
+    vim_free(p);
+    buf->b_ml.ml_mfp = mfp;
+
+    /*
+     * The page size set in mf_open() might be different from the page size
+     * used in the swap file, we must get it from block 0.  But to read block
+     * 0 we need a page size.  Use the minimal size for block 0 here, it will
+     * be set to the real value below.
+     */
+    mfp->mf_page_size = MIN_SWAP_PAGE_SIZE;
+
+/*
+ * try to read block 0
+ */
+    if ((hp = mf_get(mfp, (blocknr_T)0, 1)) == NULL)
+    {
+	msg_start();
+	MSG_PUTS_ATTR(_("Unable to read block 0 from "), attr | MSG_HIST);
+	msg_outtrans_attr(mfp->mf_fname, attr | MSG_HIST);
+	MSG_PUTS_ATTR(
+	   _("\nMaybe no changes were made or Vim did not update the swap file."),
+		attr | MSG_HIST);
+	msg_end();
+	goto theend;
+    }
+    b0p = (ZERO_BL *)(hp->bh_data);
+    if (STRNCMP(b0p->b0_version, "VIM 3.0", 7) == 0)
+    {
+	msg_start();
+	msg_outtrans_attr(mfp->mf_fname, MSG_HIST);
+	MSG_PUTS_ATTR(_(" cannot be used with this version of Vim.\n"),
+								    MSG_HIST);
+	MSG_PUTS_ATTR(_("Use Vim version 3.0.\n"), MSG_HIST);
+	msg_end();
+	goto theend;
+    }
+    if (b0p->b0_id[0] != BLOCK0_ID0 || b0p->b0_id[1] != BLOCK0_ID1)
+    {
+	EMSG2(_("E307: %s does not look like a Vim swap file"), mfp->mf_fname);
+	goto theend;
+    }
+    if (b0_magic_wrong(b0p))
+    {
+	msg_start();
+	msg_outtrans_attr(mfp->mf_fname, attr | MSG_HIST);
+#if defined(MSDOS) || defined(MSWIN)
+	if (STRNCMP(b0p->b0_hname, "PC ", 3) == 0)
+	    MSG_PUTS_ATTR(_(" cannot be used with this version of Vim.\n"),
+							     attr | MSG_HIST);
+	else
+#endif
+	    MSG_PUTS_ATTR(_(" cannot be used on this computer.\n"),
+							     attr | MSG_HIST);
+	MSG_PUTS_ATTR(_("The file was created on "), attr | MSG_HIST);
+	/* avoid going past the end of a currupted hostname */
+	b0p->b0_fname[0] = NUL;
+	MSG_PUTS_ATTR(b0p->b0_hname, attr | MSG_HIST);
+	MSG_PUTS_ATTR(_(",\nor the file has been damaged."), attr | MSG_HIST);
+	msg_end();
+	goto theend;
+    }
+    /*
+     * If we guessed the wrong page size, we have to recalculate the
+     * highest block number in the file.
+     */
+    if (mfp->mf_page_size != (unsigned)char_to_long(b0p->b0_page_size))
+    {
+	mf_new_page_size(mfp, (unsigned)char_to_long(b0p->b0_page_size));
+	if ((size = lseek(mfp->mf_fd, (off_t)0L, SEEK_END)) <= 0)
+	    mfp->mf_blocknr_max = 0;	    /* no file or empty file */
+	else
+	    mfp->mf_blocknr_max = (blocknr_T)(size / mfp->mf_page_size);
+	mfp->mf_infile_count = mfp->mf_blocknr_max;
+    }
+
+/*
+ * If .swp file name given directly, use name from swap file for buffer.
+ */
+    if (directly)
+    {
+	expand_env(b0p->b0_fname, NameBuff, MAXPATHL);
+	if (setfname(curbuf, NameBuff, NULL, TRUE) == FAIL)
+	    goto theend;
+    }
+
+    home_replace(NULL, mfp->mf_fname, NameBuff, MAXPATHL, TRUE);
+    msg_str((char_u *)_("Using swap file \"%s\""), NameBuff);
+
+    if (buf_spname(curbuf) != NULL)
+	STRCPY(NameBuff, buf_spname(curbuf));
+    else
+	home_replace(NULL, curbuf->b_ffname, NameBuff, MAXPATHL, TRUE);
+    msg_str((char_u *)_("Original file \"%s\""), NameBuff);
+    msg_putchar('\n');
+
+/*
+ * check date of swap file and original file
+ */
+    mtime = char_to_long(b0p->b0_mtime);
+    if (curbuf->b_ffname != NULL
+	    && mch_stat((char *)curbuf->b_ffname, &org_stat) != -1
+	    && ((mch_stat((char *)mfp->mf_fname, &swp_stat) != -1
+		    && org_stat.st_mtime > swp_stat.st_mtime)
+		|| org_stat.st_mtime != mtime))
+    {
+	EMSG(_("E308: Warning: Original file may have been changed"));
+    }
+    out_flush();
+    mf_put(mfp, hp, FALSE, FALSE);	/* release block 0 */
+    hp = NULL;
+
+    /*
+     * Now that we are sure that the file is going to be recovered, clear the
+     * contents of the current buffer.
+     */
+    while (!(curbuf->b_ml.ml_flags & ML_EMPTY))
+	ml_delete((linenr_T)1, FALSE);
+
+    /*
+     * Try reading the original file to obtain the values of 'fileformat',
+     * 'fileencoding', etc.  Ignore errors.  The text itself is not used.
+     */
+    if (curbuf->b_ffname != NULL)
+    {
+	(void)readfile(curbuf->b_ffname, NULL, (linenr_T)0,
+			      (linenr_T)0, (linenr_T)MAXLNUM, NULL, READ_NEW);
+	while (!(curbuf->b_ml.ml_flags & ML_EMPTY))
+	    ml_delete((linenr_T)1, FALSE);
+    }
+
+    bnum = 1;		/* start with block 1 */
+    page_count = 1;	/* which is 1 page */
+    lnum = 0;		/* append after line 0 in curbuf */
+    line_count = 0;
+    idx = 0;		/* start with first index in block 1 */
+    error = 0;
+    buf->b_ml.ml_stack_top = 0;
+    buf->b_ml.ml_stack = NULL;
+    buf->b_ml.ml_stack_size = 0;	/* no stack yet */
+
+    if (curbuf->b_ffname == NULL)
+	cannot_open = TRUE;
+    else
+	cannot_open = FALSE;
+
+    serious_error = FALSE;
+    for ( ; !got_int; line_breakcheck())
+    {
+	if (hp != NULL)
+	    mf_put(mfp, hp, FALSE, FALSE);	/* release previous block */
+
+	/*
+	 * get block
+	 */
+	if ((hp = mf_get(mfp, (blocknr_T)bnum, page_count)) == NULL)
+	{
+	    if (bnum == 1)
+	    {
+		EMSG2(_("E309: Unable to read block 1 from %s"), mfp->mf_fname);
+		goto theend;
+	    }
+	    ++error;
+	    ml_append(lnum++, (char_u *)_("???MANY LINES MISSING"),
+							    (colnr_T)0, TRUE);
+	}
+	else		/* there is a block */
+	{
+	    pp = (PTR_BL *)(hp->bh_data);
+	    if (pp->pb_id == PTR_ID)		/* it is a pointer block */
+	    {
+		/* check line count when using pointer block first time */
+		if (idx == 0 && line_count != 0)
+		{
+		    for (i = 0; i < (int)pp->pb_count; ++i)
+			line_count -= pp->pb_pointer[i].pe_line_count;
+		    if (line_count != 0)
+		    {
+			++error;
+			ml_append(lnum++, (char_u *)_("???LINE COUNT WRONG"),
+							    (colnr_T)0, TRUE);
+		    }
+		}
+
+		if (pp->pb_count == 0)
+		{
+		    ml_append(lnum++, (char_u *)_("???EMPTY BLOCK"),
+							    (colnr_T)0, TRUE);
+		    ++error;
+		}
+		else if (idx < (int)pp->pb_count)	/* go a block deeper */
+		{
+		    if (pp->pb_pointer[idx].pe_bnum < 0)
+		    {
+			/*
+			 * Data block with negative block number.
+			 * Try to read lines from the original file.
+			 * This is slow, but it works.
+			 */
+			if (!cannot_open)
+			{
+			    line_count = pp->pb_pointer[idx].pe_line_count;
+			    if (readfile(curbuf->b_ffname, NULL, lnum,
+					pp->pb_pointer[idx].pe_old_lnum - 1,
+					line_count, NULL, 0) == FAIL)
+				cannot_open = TRUE;
+			    else
+				lnum += line_count;
+			}
+			if (cannot_open)
+			{
+			    ++error;
+			    ml_append(lnum++, (char_u *)_("???LINES MISSING"),
+							    (colnr_T)0, TRUE);
+			}
+			++idx;	    /* get same block again for next index */
+			continue;
+		    }
+
+		    /*
+		     * going one block deeper in the tree
+		     */
+		    if ((top = ml_add_stack(buf)) < 0)	/* new entry in stack */
+		    {
+			++error;
+			break;		    /* out of memory */
+		    }
+		    ip = &(buf->b_ml.ml_stack[top]);
+		    ip->ip_bnum = bnum;
+		    ip->ip_index = idx;
+
+		    bnum = pp->pb_pointer[idx].pe_bnum;
+		    line_count = pp->pb_pointer[idx].pe_line_count;
+		    page_count = pp->pb_pointer[idx].pe_page_count;
+		    continue;
+		}
+	    }
+	    else	    /* not a pointer block */
+	    {
+		dp = (DATA_BL *)(hp->bh_data);
+		if (dp->db_id != DATA_ID)	/* block id wrong */
+		{
+		    if (bnum == 1)
+		    {
+			EMSG2(_("E310: Block 1 ID wrong (%s not a .swp file?)"),
+							       mfp->mf_fname);
+			goto theend;
+		    }
+		    ++error;
+		    ml_append(lnum++, (char_u *)_("???BLOCK MISSING"),
+							    (colnr_T)0, TRUE);
+		}
+		else
+		{
+		    /*
+		     * it is a data block
+		     * Append all the lines in this block
+		     */
+		    has_error = FALSE;
+			/*
+			 * check length of block
+			 * if wrong, use length in pointer block
+			 */
+		    if (page_count * mfp->mf_page_size != dp->db_txt_end)
+		    {
+			ml_append(lnum++, (char_u *)_("??? from here until ???END lines may be messed up"),
+							    (colnr_T)0, TRUE);
+			++error;
+			has_error = TRUE;
+			dp->db_txt_end = page_count * mfp->mf_page_size;
+		    }
+
+			/* make sure there is a NUL at the end of the block */
+		    *((char_u *)dp + dp->db_txt_end - 1) = NUL;
+
+			/*
+			 * check number of lines in block
+			 * if wrong, use count in data block
+			 */
+		    if (line_count != dp->db_line_count)
+		    {
+			ml_append(lnum++, (char_u *)_("??? from here until ???END lines may have been inserted/deleted"),
+							    (colnr_T)0, TRUE);
+			++error;
+			has_error = TRUE;
+		    }
+
+		    for (i = 0; i < dp->db_line_count; ++i)
+		    {
+			txt_start = (dp->db_index[i] & DB_INDEX_MASK);
+			if (txt_start <= HEADER_SIZE
+					  || txt_start >= (int)dp->db_txt_end)
+			{
+			    p = (char_u *)"???";
+			    ++error;
+			}
+			else
+			    p = (char_u *)dp + txt_start;
+			ml_append(lnum++, p, (colnr_T)0, TRUE);
+		    }
+		    if (has_error)
+			ml_append(lnum++, (char_u *)_("???END"), (colnr_T)0, TRUE);
+		}
+	    }
+	}
+
+	if (buf->b_ml.ml_stack_top == 0)	/* finished */
+	    break;
+
+	/*
+	 * go one block up in the tree
+	 */
+	ip = &(buf->b_ml.ml_stack[--(buf->b_ml.ml_stack_top)]);
+	bnum = ip->ip_bnum;
+	idx = ip->ip_index + 1;	    /* go to next index */
+	page_count = 1;
+    }
+
+    /*
+     * The dummy line from the empty buffer will now be after the last line in
+     * the buffer. Delete it.
+     */
+    ml_delete(curbuf->b_ml.ml_line_count, FALSE);
+    curbuf->b_flags |= BF_RECOVERED;
+
+    recoverymode = FALSE;
+    if (got_int)
+	EMSG(_("E311: Recovery Interrupted"));
+    else if (error)
+    {
+	++no_wait_return;
+	MSG(">>>>>>>>>>>>>");
+	EMSG(_("E312: Errors detected while recovering; look for lines starting with ???"));
+	--no_wait_return;
+	MSG(_("See \":help E312\" for more information."));
+	MSG(">>>>>>>>>>>>>");
+    }
+    else
+    {
+	MSG(_("Recovery completed. You should check if everything is OK."));
+	MSG_PUTS(_("\n(You might want to write out this file under another name\n"));
+	MSG_PUTS(_("and run diff with the original file to check for changes)\n"));
+	MSG_PUTS(_("Delete the .swp file afterwards.\n\n"));
+	cmdline_row = msg_row;
+    }
+    redraw_curbuf_later(NOT_VALID);
+
+theend:
+    recoverymode = FALSE;
+    if (mfp != NULL)
+    {
+	if (hp != NULL)
+	    mf_put(mfp, hp, FALSE, FALSE);
+	mf_close(mfp, FALSE);	    /* will also vim_free(mfp->mf_fname) */
+    }
+    vim_free(buf);
+    if (serious_error && called_from_main)
+	ml_close(curbuf, TRUE);
+#ifdef FEAT_AUTOCMD
+    else
+    {
+	apply_autocmds(EVENT_BUFREADPOST, NULL, curbuf->b_fname, FALSE, curbuf);
+	apply_autocmds(EVENT_BUFWINENTER, NULL, curbuf->b_fname, FALSE, curbuf);
+    }
+#endif
+    return;
+}
+
+/*
+ * Find the names of swap files in current directory and the directory given
+ * with the 'directory' option.
+ *
+ * Used to:
+ * - list the swap files for "vim -r"
+ * - count the number of swap files when recovering
+ * - list the swap files when recovering
+ * - find the name of the n'th swap file when recovering
+ */
+    int
+recover_names(fname, list, nr)
+    char_u	**fname;    /* base for swap file name */
+    int		list;	    /* when TRUE, list the swap file names */
+    int		nr;	    /* when non-zero, return nr'th swap file name */
+{
+    int		num_names;
+    char_u	*(names[6]);
+    char_u	*tail;
+    char_u	*p;
+    int		num_files;
+    int		file_count = 0;
+    char_u	**files;
+    int		i;
+    char_u	*dirp;
+    char_u	*dir_name;
+
+    if (list)
+    {
+	    /* use msg() to start the scrolling properly */
+	msg((char_u *)_("Swap files found:"));
+	msg_putchar('\n');
+    }
+
+    /*
+     * Do the loop for every directory in 'directory'.
+     * First allocate some memory to put the directory name in.
+     */
+    dir_name = alloc((unsigned)STRLEN(p_dir) + 1);
+    dirp = p_dir;
+    while (dir_name != NULL && *dirp)
+    {
+	/*
+	 * Isolate a directory name from *dirp and put it in dir_name (we know
+	 * it is large enough, so use 31000 for length).
+	 * Advance dirp to next directory name.
+	 */
+	(void)copy_option_part(&dirp, dir_name, 31000, ",");
+
+	if (dir_name[0] == '.' && dir_name[1] == NUL)	/* check current dir */
+	{
+	    if (fname == NULL || *fname == NULL)
+	    {
+#ifdef VMS
+		names[0] = vim_strsave((char_u *)"*_sw%");
+#else
+# ifdef RISCOS
+		names[0] = vim_strsave((char_u *)"*_sw#");
+# else
+		names[0] = vim_strsave((char_u *)"*.sw?");
+# endif
+#endif
+#ifdef UNIX
+		/* for Unix names starting with a dot are special */
+		names[1] = vim_strsave((char_u *)".*.sw?");
+		names[2] = vim_strsave((char_u *)".sw?");
+		num_names = 3;
+#else
+# ifdef VMS
+		names[1] = vim_strsave((char_u *)".*_sw%");
+		num_names = 2;
+# else
+		num_names = 1;
+# endif
+#endif
+	    }
+	    else
+		num_names = recov_file_names(names, *fname, TRUE);
+	}
+	else			    /* check directory dir_name */
+	{
+	    if (fname == NULL || *fname == NULL)
+	    {
+#ifdef VMS
+		names[0] = concat_fnames(dir_name, (char_u *)"*_sw%", TRUE);
+#else
+# ifdef RISCOS
+		names[0] = concat_fnames(dir_name, (char_u *)"*_sw#", TRUE);
+# else
+		names[0] = concat_fnames(dir_name, (char_u *)"*.sw?", TRUE);
+# endif
+#endif
+#ifdef UNIX
+		/* for Unix names starting with a dot are special */
+		names[1] = concat_fnames(dir_name, (char_u *)".*.sw?", TRUE);
+		names[2] = concat_fnames(dir_name, (char_u *)".sw?", TRUE);
+		num_names = 3;
+#else
+# ifdef VMS
+		names[1] = concat_fnames(dir_name, (char_u *)".*_sw%", TRUE);
+		num_names = 2;
+# else
+		num_names = 1;
+# endif
+#endif
+	    }
+	    else
+	    {
+#if defined(UNIX) || defined(WIN3264)
+		p = dir_name + STRLEN(dir_name);
+		if (vim_ispathsep(p[-1]) && p[-1] == p[-2])
+		{
+		    /* Ends with '//', Use Full path for swap name */
+		    tail = make_percent_swname(dir_name, *fname);
+		}
+		else
+#endif
+		{
+		    tail = gettail(*fname);
+		    tail = concat_fnames(dir_name, tail, TRUE);
+		}
+		if (tail == NULL)
+		    num_names = 0;
+		else
+		{
+		    num_names = recov_file_names(names, tail, FALSE);
+		    vim_free(tail);
+		}
+	    }
+	}
+
+	    /* check for out-of-memory */
+	for (i = 0; i < num_names; ++i)
+	{
+	    if (names[i] == NULL)
+	    {
+		for (i = 0; i < num_names; ++i)
+		    vim_free(names[i]);
+		num_names = 0;
+	    }
+	}
+	if (num_names == 0)
+	    num_files = 0;
+	else if (expand_wildcards(num_names, names, &num_files, &files,
+					EW_KEEPALL|EW_FILE|EW_SILENT) == FAIL)
+	    num_files = 0;
+
+	/*
+	 * When no swap file found, wildcard expansion might have failed (e.g.
+	 * not able to execute the shell).
+	 * Try finding a swap file by simply adding ".swp" to the file name.
+	 */
+	if (*dirp == NUL && file_count + num_files == 0
+					   && fname != NULL && *fname != NULL)
+	{
+	    struct stat	    st;
+	    char_u	    *swapname;
+
+#if defined(VMS) || defined(RISCOS)
+	    swapname = modname(*fname, (char_u *)"_swp", FALSE);
+#else
+	    swapname = modname(*fname, (char_u *)".swp", TRUE);
+#endif
+	    if (swapname != NULL)
+	    {
+		if (mch_stat((char *)swapname, &st) != -1)	    /* It exists! */
+		{
+		    files = (char_u **)alloc((unsigned)sizeof(char_u *));
+		    if (files != NULL)
+		    {
+			files[0] = swapname;
+			swapname = NULL;
+			num_files = 1;
+		    }
+		}
+		vim_free(swapname);
+	    }
+	}
+
+	/*
+	 * remove swapfile name of the current buffer, it must be ignored
+	 */
+	if (curbuf->b_ml.ml_mfp != NULL
+			       && (p = curbuf->b_ml.ml_mfp->mf_fname) != NULL)
+	{
+	    for (i = 0; i < num_files; ++i)
+		if (fullpathcmp(p, files[i], TRUE) & FPC_SAME)
+		{
+		    vim_free(files[i]);
+		    --num_files;
+		    for ( ; i < num_files; ++i)
+			files[i] = files[i + 1];
+		}
+	}
+	if (nr)
+	{
+	    file_count += num_files;
+	    if (nr <= file_count)
+	    {
+		*fname = vim_strsave(files[nr - 1 + num_files - file_count]);
+		dirp = (char_u *)"";		    /* stop searching */
+	    }
+	}
+	else if (list)
+	{
+	    if (dir_name[0] == '.' && dir_name[1] == NUL)
+	    {
+		if (fname == NULL || *fname == NULL)
+		    MSG_PUTS(_("   In current directory:\n"));
+		else
+		    MSG_PUTS(_("   Using specified name:\n"));
+	    }
+	    else
+	    {
+		MSG_PUTS(_("   In directory "));
+		msg_home_replace(dir_name);
+		MSG_PUTS(":\n");
+	    }
+
+	    if (num_files)
+	    {
+		for (i = 0; i < num_files; ++i)
+		{
+		    /* print the swap file name */
+		    msg_outnum((long)++file_count);
+		    MSG_PUTS(".    ");
+		    msg_puts(gettail(files[i]));
+		    msg_putchar('\n');
+		    (void)swapfile_info(files[i]);
+		}
+	    }
+	    else
+		MSG_PUTS(_("      -- none --\n"));
+	    out_flush();
+	}
+	else
+	    file_count += num_files;
+
+	for (i = 0; i < num_names; ++i)
+	    vim_free(names[i]);
+	FreeWild(num_files, files);
+    }
+    vim_free(dir_name);
+    return file_count;
+}
+
+#if defined(UNIX) || defined(WIN3264)  /* Need _very_ long file names */
+/*
+ * Append the full path to name with path separators made into percent
+ * signs, to dir. An unnamed buffer is handled as "" (<currentdir>/"")
+ */
+    static char_u *
+make_percent_swname(dir, name)
+    char_u	*dir;
+    char_u	*name;
+{
+    char_u *d, *s, *f, *p;
+
+    f = fix_fname(name != NULL ? name : (char_u *) "");
+    d = NULL;
+    if (f != NULL)
+    {
+	s = alloc((unsigned)(STRLEN(f) + 1));
+	if (s != NULL)
+	{
+	    for (d = s, p = f; *p; p++, d++)
+		*d = vim_ispathsep(*p) ? '%' : *p;
+	    *d = 0;
+	    d = concat_fnames(dir, s, TRUE);
+	    vim_free(s);
+	}
+	vim_free(f);
+    }
+    return d;
+}
+#endif
+
+#if (defined(UNIX) || defined(__EMX__) || defined(VMS)) && (defined(FEAT_GUI_DIALOG) || defined(FEAT_CON_DIALOG))
+static int process_still_running;
+#endif
+
+/*
+ * Give information about an existing swap file
+ * Returns timestamp (0 when unknown).
+ */
+    static time_t
+swapfile_info(fname)
+    char_u	*fname;
+{
+    struct stat	    st;
+    int		    fd;
+    struct block0   b0;
+    time_t	    x = (time_t)0;
+#ifdef UNIX
+    char_u	    uname[B0_UNAME_SIZE];
+#endif
+
+    /* print the swap file date */
+    if (mch_stat((char *)fname, &st) != -1)
+    {
+#ifdef UNIX
+	/* print name of owner of the file */
+	if (mch_get_uname(st.st_uid, uname, B0_UNAME_SIZE) == OK)
+	{
+	    MSG_PUTS(_("          owned by: "));
+	    msg_outtrans(uname);
+	    MSG_PUTS(_("   dated: "));
+	}
+	else
+#endif
+	    MSG_PUTS(_("             dated: "));
+	x = st.st_mtime;		    /* Manx C can't do &st.st_mtime */
+	MSG_PUTS(ctime(&x));		    /* includes '\n' */
+
+    }
+
+    /*
+     * print the original file name
+     */
+    fd = mch_open((char *)fname, O_RDONLY | O_EXTRA, 0);
+    if (fd >= 0)
+    {
+	if (read(fd, (char *)&b0, sizeof(b0)) == sizeof(b0))
+	{
+	    if (STRNCMP(b0.b0_version, "VIM 3.0", 7) == 0)
+	    {
+		MSG_PUTS(_("         [from Vim version 3.0]"));
+	    }
+	    else if (b0.b0_id[0] != BLOCK0_ID0 || b0.b0_id[1] != BLOCK0_ID1)
+	    {
+		MSG_PUTS(_("         [does not look like a Vim swap file]"));
+	    }
+	    else
+	    {
+		MSG_PUTS(_("         file name: "));
+		if (b0.b0_fname[0] == NUL)
+		    MSG_PUTS(_("[No File]"));
+		else
+		    msg_outtrans(b0.b0_fname);
+
+		MSG_PUTS(_("\n          modified: "));
+		MSG_PUTS(b0.b0_dirty ? _("YES") : _("no"));
+
+		if (*(b0.b0_uname) != NUL)
+		{
+		    MSG_PUTS(_("\n         user name: "));
+		    msg_outtrans(b0.b0_uname);
+		}
+
+		if (*(b0.b0_hname) != NUL)
+		{
+		    if (*(b0.b0_uname) != NUL)
+			MSG_PUTS(_("   host name: "));
+		    else
+			MSG_PUTS(_("\n         host name: "));
+		    msg_outtrans(b0.b0_hname);
+		}
+
+		if (char_to_long(b0.b0_pid) != 0L)
+		{
+		    MSG_PUTS(_("\n        process ID: "));
+		    msg_outnum(char_to_long(b0.b0_pid));
+#if defined(UNIX) || defined(__EMX__)
+		    /* EMX kill() not working correctly, it seems */
+		    if (kill((pid_t)char_to_long(b0.b0_pid), 0) == 0)
+		    {
+			MSG_PUTS(_(" (still running)"));
+# if defined(FEAT_GUI_DIALOG) || defined(FEAT_CON_DIALOG)
+			process_still_running = TRUE;
+# endif
+		    }
+#endif
+		}
+
+		if (b0_magic_wrong(&b0))
+		{
+#if defined(MSDOS) || defined(MSWIN)
+		    if (STRNCMP(b0.b0_hname, "PC ", 3) == 0)
+			MSG_PUTS(_("\n         [not usable with this version of Vim]"));
+		    else
+#endif
+			MSG_PUTS(_("\n         [not usable on this computer]"));
+		}
+	    }
+	}
+	else
+	    MSG_PUTS(_("         [cannot be read]"));
+	close(fd);
+    }
+    else
+	MSG_PUTS(_("         [cannot be opened]"));
+    msg_putchar('\n');
+
+    return x;
+}
+
+    static int
+recov_file_names(names, path, prepend_dot)
+    char_u	**names;
+    char_u	*path;
+    int		prepend_dot;
+{
+    int		num_names;
+
+#ifdef SHORT_FNAME
+    /*
+     * (MS-DOS) always short names
+     */
+    names[0] = modname(path, (char_u *)".sw?", FALSE);
+    num_names = 1;
+#else /* !SHORT_FNAME */
+    /*
+     * (Win32 and Win64) never short names, but do prepend a dot.
+     * (Not MS-DOS or Win32 or Win64) maybe short name, maybe not: Try both.
+     * Only use the short name if it is different.
+     */
+    char_u	*p;
+    int		i;
+# ifndef WIN3264
+    int	    shortname = curbuf->b_shortname;
+
+    curbuf->b_shortname = FALSE;
+# endif
+
+    num_names = 0;
+
+    /*
+     * May also add the file name with a dot prepended, for swap file in same
+     * dir as original file.
+     */
+    if (prepend_dot)
+    {
+	names[num_names] = modname(path, (char_u *)".sw?", TRUE);
+	if (names[num_names] == NULL)
+	    goto end;
+	++num_names;
+    }
+
+    /*
+     * Form the normal swap file name pattern by appending ".sw?".
+     */
+#ifdef VMS
+    names[num_names] = concat_fnames(path, (char_u *)"_sw%", FALSE);
+#else
+# ifdef RISCOS
+    names[num_names] = concat_fnames(path, (char_u *)"_sw#", FALSE);
+# else
+    names[num_names] = concat_fnames(path, (char_u *)".sw?", FALSE);
+# endif
+#endif
+    if (names[num_names] == NULL)
+	goto end;
+    if (num_names >= 1)	    /* check if we have the same name twice */
+    {
+	p = names[num_names - 1];
+	i = (int)STRLEN(names[num_names - 1]) - (int)STRLEN(names[num_names]);
+	if (i > 0)
+	    p += i;	    /* file name has been expanded to full path */
+
+	if (STRCMP(p, names[num_names]) != 0)
+	    ++num_names;
+	else
+	    vim_free(names[num_names]);
+    }
+    else
+	++num_names;
+
+# ifndef WIN3264
+    /*
+     * Also try with 'shortname' set, in case the file is on a DOS filesystem.
+     */
+    curbuf->b_shortname = TRUE;
+#ifdef VMS
+    names[num_names] = modname(path, (char_u *)"_sw%", FALSE);
+#else
+# ifdef RISCOS
+    names[num_names] = modname(path, (char_u *)"_sw#", FALSE);
+# else
+    names[num_names] = modname(path, (char_u *)".sw?", FALSE);
+# endif
+#endif
+    if (names[num_names] == NULL)
+	goto end;
+
+    /*
+     * Remove the one from 'shortname', if it's the same as with 'noshortname'.
+     */
+    p = names[num_names];
+    i = STRLEN(names[num_names]) - STRLEN(names[num_names - 1]);
+    if (i > 0)
+	p += i;		/* file name has been expanded to full path */
+    if (STRCMP(names[num_names - 1], p) == 0)
+	vim_free(names[num_names]);
+    else
+	++num_names;
+# endif
+
+end:
+# ifndef WIN3264
+    curbuf->b_shortname = shortname;
+# endif
+
+#endif /* !SHORT_FNAME */
+
+    return num_names;
+}
+
+/*
+ * sync all memlines
+ *
+ * If 'check_file' is TRUE, check if original file exists and was not changed.
+ * If 'check_char' is TRUE, stop syncing when character becomes available, but
+ * always sync at least one block.
+ */
+    void
+ml_sync_all(check_file, check_char)
+    int	    check_file;
+    int	    check_char;
+{
+    buf_T		*buf;
+    struct stat		st;
+
+    for (buf = firstbuf; buf != NULL; buf = buf->b_next)
+    {
+	if (buf->b_ml.ml_mfp == NULL || buf->b_ml.ml_mfp->mf_fname == NULL)
+	    continue;			    /* no file */
+
+	ml_flush_line(buf);		    /* flush buffered line */
+					    /* flush locked block */
+	(void)ml_find_line(buf, (linenr_T)0, ML_FLUSH);
+	if (bufIsChanged(buf) && check_file && mf_need_trans(buf->b_ml.ml_mfp)
+						     && buf->b_ffname != NULL)
+	{
+	    /*
+	     * If the original file does not exist anymore or has been changed
+	     * call ml_preserve() to get rid of all negative numbered blocks.
+	     */
+	    if (mch_stat((char *)buf->b_ffname, &st) == -1
+		    || st.st_mtime != buf->b_mtime_read
+		    || (size_t)st.st_size != buf->b_orig_size)
+	    {
+		ml_preserve(buf, FALSE);
+		did_check_timestamps = FALSE;
+		need_check_timestamps = TRUE;	/* give message later */
+	    }
+	}
+	if (buf->b_ml.ml_mfp->mf_dirty)
+	{
+	    (void)mf_sync(buf->b_ml.ml_mfp, (check_char ? MFS_STOP : 0)
+					| (bufIsChanged(buf) ? MFS_FLUSH : 0));
+	    if (check_char && ui_char_avail())	/* character available now */
+		break;
+	}
+    }
+}
+
+/*
+ * sync one buffer, including negative blocks
+ *
+ * after this all the blocks are in the swap file
+ *
+ * Used for the :preserve command and when the original file has been
+ * changed or deleted.
+ *
+ * when message is TRUE the success of preserving is reported
+ */
+    void
+ml_preserve(buf, message)
+    buf_T	*buf;
+    int		message;
+{
+    bhdr_T	*hp;
+    linenr_T	lnum;
+    memfile_T	*mfp = buf->b_ml.ml_mfp;
+    int		status;
+    int		got_int_save = got_int;
+
+    if (mfp == NULL || mfp->mf_fname == NULL)
+    {
+	if (message)
+	    EMSG(_("E313: Cannot preserve, there is no swap file"));
+	return;
+    }
+
+    /* We only want to stop when interrupted here, not when interrupted
+     * before. */
+    got_int = FALSE;
+
+    ml_flush_line(buf);				    /* flush buffered line */
+    (void)ml_find_line(buf, (linenr_T)0, ML_FLUSH); /* flush locked block */
+    status = mf_sync(mfp, MFS_ALL | MFS_FLUSH);
+
+    /* stack is invalid after mf_sync(.., MFS_ALL) */
+    buf->b_ml.ml_stack_top = 0;
+
+    /*
+     * Some of the data blocks may have been changed from negative to
+     * positive block number. In that case the pointer blocks need to be
+     * updated.
+     *
+     * We don't know in which pointer block the references are, so we visit
+     * all data blocks until there are no more translations to be done (or
+     * we hit the end of the file, which can only happen in case a write fails,
+     * e.g. when file system if full).
+     * ml_find_line() does the work by translating the negative block numbers
+     * when getting the first line of each data block.
+     */
+    if (mf_need_trans(mfp) && !got_int)
+    {
+	lnum = 1;
+	while (mf_need_trans(mfp) && lnum <= buf->b_ml.ml_line_count)
+	{
+	    hp = ml_find_line(buf, lnum, ML_FIND);
+	    if (hp == NULL)
+	    {
+		status = FAIL;
+		goto theend;
+	    }
+	    CHECK(buf->b_ml.ml_locked_low != lnum, "low != lnum");
+	    lnum = buf->b_ml.ml_locked_high + 1;
+	}
+	(void)ml_find_line(buf, (linenr_T)0, ML_FLUSH);	/* flush locked block */
+	/* sync the updated pointer blocks */
+	if (mf_sync(mfp, MFS_ALL | MFS_FLUSH) == FAIL)
+	    status = FAIL;
+	buf->b_ml.ml_stack_top = 0;	    /* stack is invalid now */
+    }
+theend:
+    got_int |= got_int_save;
+
+    if (message)
+    {
+	if (status == OK)
+	    MSG(_("File preserved"));
+	else
+	    EMSG(_("E314: Preserve failed"));
+    }
+}
+
+/*
+ * NOTE: The pointer returned by the ml_get_*() functions only remains valid
+ * until the next call!
+ *  line1 = ml_get(1);
+ *  line2 = ml_get(2);	// line1 is now invalid!
+ * Make a copy of the line if necessary.
+ */
+/*
+ * get a pointer to a (read-only copy of a) line
+ *
+ * On failure an error message is given and IObuff is returned (to avoid
+ * having to check for error everywhere).
+ */
+    char_u  *
+ml_get(lnum)
+    linenr_T	lnum;
+{
+    return ml_get_buf(curbuf, lnum, FALSE);
+}
+
+/*
+ * ml_get_pos: get pointer to position 'pos'
+ */
+    char_u *
+ml_get_pos(pos)
+    pos_T	*pos;
+{
+    return (ml_get_buf(curbuf, pos->lnum, FALSE) + pos->col);
+}
+
+/*
+ * ml_get_curline: get pointer to cursor line.
+ */
+    char_u *
+ml_get_curline()
+{
+    return ml_get_buf(curbuf, curwin->w_cursor.lnum, FALSE);
+}
+
+/*
+ * ml_get_cursor: get pointer to cursor position
+ */
+    char_u *
+ml_get_cursor()
+{
+    return (ml_get_buf(curbuf, curwin->w_cursor.lnum, FALSE) +
+							curwin->w_cursor.col);
+}
+
+/*
+ * get a pointer to a line in a specific buffer
+ *
+ * "will_change": if TRUE mark the buffer dirty (chars in the line will be
+ * changed)
+ */
+    char_u  *
+ml_get_buf(buf, lnum, will_change)
+    buf_T	*buf;
+    linenr_T	lnum;
+    int		will_change;		/* line will be changed */
+{
+    bhdr_T    *hp;
+    DATA_BL *dp;
+    char_u  *ptr;
+
+    if (lnum > buf->b_ml.ml_line_count)	/* invalid line number */
+    {
+	EMSGN(_("E315: ml_get: invalid lnum: %ld"), lnum);
+errorret:
+	STRCPY(IObuff, "???");
+	return IObuff;
+    }
+    if (lnum <= 0)			/* pretend line 0 is line 1 */
+	lnum = 1;
+
+    if (buf->b_ml.ml_mfp == NULL)	/* there are no lines */
+	return (char_u *)"";
+
+/*
+ * See if it is the same line as requested last time.
+ * Otherwise may need to flush last used line.
+ */
+    if (buf->b_ml.ml_line_lnum != lnum)
+    {
+	ml_flush_line(buf);
+
+	/*
+	 * Find the data block containing the line.
+	 * This also fills the stack with the blocks from the root to the data
+	 * block and releases any locked block.
+	 */
+	if ((hp = ml_find_line(buf, lnum, ML_FIND)) == NULL)
+	{
+	    EMSGN(_("E316: ml_get: cannot find line %ld"), lnum);
+	    goto errorret;
+	}
+
+	dp = (DATA_BL *)(hp->bh_data);
+
+	ptr = (char_u *)dp + ((dp->db_index[lnum - buf->b_ml.ml_locked_low]) & DB_INDEX_MASK);
+	buf->b_ml.ml_line_ptr = ptr;
+	buf->b_ml.ml_line_lnum = lnum;
+	buf->b_ml.ml_flags &= ~ML_LINE_DIRTY;
+    }
+    if (will_change)
+	buf->b_ml.ml_flags |= (ML_LOCKED_DIRTY | ML_LOCKED_POS);
+
+    return buf->b_ml.ml_line_ptr;
+}
+
+/*
+ * Check if a line that was just obtained by a call to ml_get
+ * is in allocated memory.
+ */
+    int
+ml_line_alloced()
+{
+    return (curbuf->b_ml.ml_flags & ML_LINE_DIRTY);
+}
+
+/*
+ * Append a line after lnum (may be 0 to insert a line in front of the file).
+ * "line" does not need to be allocated, but can't be another line in a
+ * buffer, unlocking may make it invalid.
+ *
+ *   newfile: TRUE when starting to edit a new file, meaning that pe_old_lnum
+ *		will be set for recovery
+ * Check: The caller of this function should probably also call
+ * appended_lines().
+ *
+ * return FAIL for failure, OK otherwise
+ */
+    int
+ml_append(lnum, line, len, newfile)
+    linenr_T	lnum;		/* append after this line (can be 0) */
+    char_u	*line;		/* text of the new line */
+    colnr_T	len;		/* length of new line, including NUL, or 0 */
+    int		newfile;	/* flag, see above */
+{
+    /* When starting up, we might still need to create the memfile */
+    if (curbuf->b_ml.ml_mfp == NULL && open_buffer(FALSE, NULL) == FAIL)
+	return FAIL;
+
+    if (curbuf->b_ml.ml_line_lnum != 0)
+	ml_flush_line(curbuf);
+    return ml_append_int(curbuf, lnum, line, len, newfile, FALSE);
+}
+
+    static int
+ml_append_int(buf, lnum, line, len, newfile, mark)
+    buf_T	*buf;
+    linenr_T	lnum;		/* append after this line (can be 0) */
+    char_u	*line;		/* text of the new line */
+    colnr_T	len;		/* length of line, including NUL, or 0 */
+    int		newfile;	/* flag, see above */
+    int		mark;		/* mark the new line */
+{
+    int		i;
+    int		line_count;	/* number of indexes in current block */
+    int		offset;
+    int		from, to;
+    int		space_needed;	/* space needed for new line */
+    int		page_size;
+    int		page_count;
+    int		db_idx;		/* index for lnum in data block */
+    bhdr_T	*hp;
+    memfile_T	*mfp;
+    DATA_BL	*dp;
+    PTR_BL	*pp;
+    infoptr_T	*ip;
+
+					/* lnum out of range */
+    if (lnum > buf->b_ml.ml_line_count || buf->b_ml.ml_mfp == NULL)
+	return FAIL;
+
+    if (lowest_marked && lowest_marked > lnum)
+	lowest_marked = lnum + 1;
+
+    if (len == 0)
+	len = (colnr_T)STRLEN(line) + 1;	/* space needed for the text */
+    space_needed = len + INDEX_SIZE;	/* space needed for text + index */
+
+    mfp = buf->b_ml.ml_mfp;
+    page_size = mfp->mf_page_size;
+
+/*
+ * find the data block containing the previous line
+ * This also fills the stack with the blocks from the root to the data block
+ * This also releases any locked block.
+ */
+    if ((hp = ml_find_line(buf, lnum == 0 ? (linenr_T)1 : lnum,
+							  ML_INSERT)) == NULL)
+	return FAIL;
+
+    buf->b_ml.ml_flags &= ~ML_EMPTY;
+
+    if (lnum == 0)		/* got line one instead, correct db_idx */
+	db_idx = -1;		/* careful, it is negative! */
+    else
+	db_idx = lnum - buf->b_ml.ml_locked_low;
+		/* get line count before the insertion */
+    line_count = buf->b_ml.ml_locked_high - buf->b_ml.ml_locked_low;
+
+    dp = (DATA_BL *)(hp->bh_data);
+
+/*
+ * If
+ * - there is not enough room in the current block
+ * - appending to the last line in the block
+ * - not appending to the last line in the file
+ * insert in front of the next block.
+ */
+    if ((int)dp->db_free < space_needed && db_idx == line_count - 1
+					    && lnum < buf->b_ml.ml_line_count)
+    {
+	/*
+	 * Now that the line is not going to be inserted in the block that we
+	 * expected, the line count has to be adjusted in the pointer blocks
+	 * by using ml_locked_lineadd.
+	 */
+	--(buf->b_ml.ml_locked_lineadd);
+	--(buf->b_ml.ml_locked_high);
+	if ((hp = ml_find_line(buf, lnum + 1, ML_INSERT)) == NULL)
+	    return FAIL;
+
+	db_idx = -1;		    /* careful, it is negative! */
+		    /* get line count before the insertion */
+	line_count = buf->b_ml.ml_locked_high - buf->b_ml.ml_locked_low;
+	CHECK(buf->b_ml.ml_locked_low != lnum + 1, "locked_low != lnum + 1");
+
+	dp = (DATA_BL *)(hp->bh_data);
+    }
+
+    ++buf->b_ml.ml_line_count;
+
+    if ((int)dp->db_free >= space_needed)	/* enough room in data block */
+    {
+/*
+ * Insert new line in existing data block, or in data block allocated above.
+ */
+	dp->db_txt_start -= len;
+	dp->db_free -= space_needed;
+	++(dp->db_line_count);
+
+	/*
+	 * move the text of the lines that follow to the front
+	 * adjust the indexes of the lines that follow
+	 */
+	if (line_count > db_idx + 1)	    /* if there are following lines */
+	{
+	    /*
+	     * Offset is the start of the previous line.
+	     * This will become the character just after the new line.
+	     */
+	    if (db_idx < 0)
+		offset = dp->db_txt_end;
+	    else
+		offset = ((dp->db_index[db_idx]) & DB_INDEX_MASK);
+	    mch_memmove((char *)dp + dp->db_txt_start,
+					  (char *)dp + dp->db_txt_start + len,
+				 (size_t)(offset - (dp->db_txt_start + len)));
+	    for (i = line_count - 1; i > db_idx; --i)
+		dp->db_index[i + 1] = dp->db_index[i] - len;
+	    dp->db_index[db_idx + 1] = offset - len;
+	}
+	else				    /* add line at the end */
+	    dp->db_index[db_idx + 1] = dp->db_txt_start;
+
+	/*
+	 * copy the text into the block
+	 */
+	mch_memmove((char *)dp + dp->db_index[db_idx + 1], line, (size_t)len);
+	if (mark)
+	    dp->db_index[db_idx + 1] |= DB_MARKED;
+
+	/*
+	 * Mark the block dirty.
+	 */
+	buf->b_ml.ml_flags |= ML_LOCKED_DIRTY;
+	if (!newfile)
+	    buf->b_ml.ml_flags |= ML_LOCKED_POS;
+    }
+    else	    /* not enough space in data block */
+    {
+/*
+ * If there is not enough room we have to create a new data block and copy some
+ * lines into it.
+ * Then we have to insert an entry in the pointer block.
+ * If this pointer block also is full, we go up another block, and so on, up
+ * to the root if necessary.
+ * The line counts in the pointer blocks have already been adjusted by
+ * ml_find_line().
+ */
+	long	    line_count_left, line_count_right;
+	int	    page_count_left, page_count_right;
+	bhdr_T	    *hp_left;
+	bhdr_T	    *hp_right;
+	bhdr_T	    *hp_new;
+	int	    lines_moved;
+	int	    data_moved = 0;	    /* init to shut up gcc */
+	int	    total_moved = 0;	    /* init to shut up gcc */
+	DATA_BL	    *dp_right, *dp_left;
+	int	    stack_idx;
+	int	    in_left;
+	int	    lineadd;
+	blocknr_T   bnum_left, bnum_right;
+	linenr_T    lnum_left, lnum_right;
+	int	    pb_idx;
+	PTR_BL	    *pp_new;
+
+	/*
+	 * We are going to allocate a new data block. Depending on the
+	 * situation it will be put to the left or right of the existing
+	 * block.  If possible we put the new line in the left block and move
+	 * the lines after it to the right block. Otherwise the new line is
+	 * also put in the right block. This method is more efficient when
+	 * inserting a lot of lines at one place.
+	 */
+	if (db_idx < 0)		/* left block is new, right block is existing */
+	{
+	    lines_moved = 0;
+	    in_left = TRUE;
+	    /* space_needed does not change */
+	}
+	else			/* left block is existing, right block is new */
+	{
+	    lines_moved = line_count - db_idx - 1;
+	    if (lines_moved == 0)
+		in_left = FALSE;	/* put new line in right block */
+					/* space_needed does not change */
+	    else
+	    {
+		data_moved = ((dp->db_index[db_idx]) & DB_INDEX_MASK) -
+							    dp->db_txt_start;
+		total_moved = data_moved + lines_moved * INDEX_SIZE;
+		if ((int)dp->db_free + total_moved >= space_needed)
+		{
+		    in_left = TRUE;	/* put new line in left block */
+		    space_needed = total_moved;
+		}
+		else
+		{
+		    in_left = FALSE;	    /* put new line in right block */
+		    space_needed += total_moved;
+		}
+	    }
+	}
+
+	page_count = ((space_needed + HEADER_SIZE) + page_size - 1) / page_size;
+	if ((hp_new = ml_new_data(mfp, newfile, page_count)) == NULL)
+	{
+			/* correct line counts in pointer blocks */
+	    --(buf->b_ml.ml_locked_lineadd);
+	    --(buf->b_ml.ml_locked_high);
+	    return FAIL;
+	}
+	if (db_idx < 0)		/* left block is new */
+	{
+	    hp_left = hp_new;
+	    hp_right = hp;
+	    line_count_left = 0;
+	    line_count_right = line_count;
+	}
+	else			/* right block is new */
+	{
+	    hp_left = hp;
+	    hp_right = hp_new;
+	    line_count_left = line_count;
+	    line_count_right = 0;
+	}
+	dp_right = (DATA_BL *)(hp_right->bh_data);
+	dp_left = (DATA_BL *)(hp_left->bh_data);
+	bnum_left = hp_left->bh_bnum;
+	bnum_right = hp_right->bh_bnum;
+	page_count_left = hp_left->bh_page_count;
+	page_count_right = hp_right->bh_page_count;
+
+	/*
+	 * May move the new line into the right/new block.
+	 */
+	if (!in_left)
+	{
+	    dp_right->db_txt_start -= len;
+	    dp_right->db_free -= len + INDEX_SIZE;
+	    dp_right->db_index[0] = dp_right->db_txt_start;
+	    if (mark)
+		dp_right->db_index[0] |= DB_MARKED;
+
+	    mch_memmove((char *)dp_right + dp_right->db_txt_start,
+							   line, (size_t)len);
+	    ++line_count_right;
+	}
+	/*
+	 * may move lines from the left/old block to the right/new one.
+	 */
+	if (lines_moved)
+	{
+	    /*
+	     */
+	    dp_right->db_txt_start -= data_moved;
+	    dp_right->db_free -= total_moved;
+	    mch_memmove((char *)dp_right + dp_right->db_txt_start,
+			(char *)dp_left + dp_left->db_txt_start,
+			(size_t)data_moved);
+	    offset = dp_right->db_txt_start - dp_left->db_txt_start;
+	    dp_left->db_txt_start += data_moved;
+	    dp_left->db_free += total_moved;
+
+	    /*
+	     * update indexes in the new block
+	     */
+	    for (to = line_count_right, from = db_idx + 1;
+					 from < line_count_left; ++from, ++to)
+		dp_right->db_index[to] = dp->db_index[from] + offset;
+	    line_count_right += lines_moved;
+	    line_count_left -= lines_moved;
+	}
+
+	/*
+	 * May move the new line into the left (old or new) block.
+	 */
+	if (in_left)
+	{
+	    dp_left->db_txt_start -= len;
+	    dp_left->db_free -= len + INDEX_SIZE;
+	    dp_left->db_index[line_count_left] = dp_left->db_txt_start;
+	    if (mark)
+		dp_left->db_index[line_count_left] |= DB_MARKED;
+	    mch_memmove((char *)dp_left + dp_left->db_txt_start,
+							   line, (size_t)len);
+	    ++line_count_left;
+	}
+
+	if (db_idx < 0)		/* left block is new */
+	{
+	    lnum_left = lnum + 1;
+	    lnum_right = 0;
+	}
+	else			/* right block is new */
+	{
+	    lnum_left = 0;
+	    if (in_left)
+		lnum_right = lnum + 2;
+	    else
+		lnum_right = lnum + 1;
+	}
+	dp_left->db_line_count = line_count_left;
+	dp_right->db_line_count = line_count_right;
+
+	/*
+	 * release the two data blocks
+	 * The new one (hp_new) already has a correct blocknumber.
+	 * The old one (hp, in ml_locked) gets a positive blocknumber if
+	 * we changed it and we are not editing a new file.
+	 */
+	if (lines_moved || in_left)
+	    buf->b_ml.ml_flags |= ML_LOCKED_DIRTY;
+	if (!newfile && db_idx >= 0 && in_left)
+	    buf->b_ml.ml_flags |= ML_LOCKED_POS;
+	mf_put(mfp, hp_new, TRUE, FALSE);
+
+	/*
+	 * flush the old data block
+	 * set ml_locked_lineadd to 0, because the updating of the
+	 * pointer blocks is done below
+	 */
+	lineadd = buf->b_ml.ml_locked_lineadd;
+	buf->b_ml.ml_locked_lineadd = 0;
+	ml_find_line(buf, (linenr_T)0, ML_FLUSH);   /* flush data block */
+
+	/*
+	 * update pointer blocks for the new data block
+	 */
+	for (stack_idx = buf->b_ml.ml_stack_top - 1; stack_idx >= 0;
+								  --stack_idx)
+	{
+	    ip = &(buf->b_ml.ml_stack[stack_idx]);
+	    pb_idx = ip->ip_index;
+	    if ((hp = mf_get(mfp, ip->ip_bnum, 1)) == NULL)
+		return FAIL;
+	    pp = (PTR_BL *)(hp->bh_data);   /* must be pointer block */
+	    if (pp->pb_id != PTR_ID)
+	    {
+		EMSG(_("E317: pointer block id wrong 3"));
+		mf_put(mfp, hp, FALSE, FALSE);
+		return FAIL;
+	    }
+	    /*
+	     * TODO: If the pointer block is full and we are adding at the end
+	     * try to insert in front of the next block
+	     */
+	    /* block not full, add one entry */
+	    if (pp->pb_count < pp->pb_count_max)
+	    {
+		if (pb_idx + 1 < (int)pp->pb_count)
+		    mch_memmove(&pp->pb_pointer[pb_idx + 2],
+				&pp->pb_pointer[pb_idx + 1],
+			(size_t)(pp->pb_count - pb_idx - 1) * sizeof(PTR_EN));
+		++pp->pb_count;
+		pp->pb_pointer[pb_idx].pe_line_count = line_count_left;
+		pp->pb_pointer[pb_idx].pe_bnum = bnum_left;
+		pp->pb_pointer[pb_idx].pe_page_count = page_count_left;
+		pp->pb_pointer[pb_idx + 1].pe_line_count = line_count_right;
+		pp->pb_pointer[pb_idx + 1].pe_bnum = bnum_right;
+		pp->pb_pointer[pb_idx + 1].pe_page_count = page_count_right;
+
+		if (lnum_left != 0)
+		    pp->pb_pointer[pb_idx].pe_old_lnum = lnum_left;
+		if (lnum_right != 0)
+		    pp->pb_pointer[pb_idx + 1].pe_old_lnum = lnum_right;
+
+		mf_put(mfp, hp, TRUE, FALSE);
+		buf->b_ml.ml_stack_top = stack_idx + 1;	    /* truncate stack */
+
+		if (lineadd)
+		{
+		    --(buf->b_ml.ml_stack_top);
+			/* fix line count for rest of blocks in the stack */
+		    ml_lineadd(buf, lineadd);
+							/* fix stack itself */
+		    buf->b_ml.ml_stack[buf->b_ml.ml_stack_top].ip_high +=
+								      lineadd;
+		    ++(buf->b_ml.ml_stack_top);
+		}
+
+		/*
+		 * We are finished, break the loop here.
+		 */
+		break;
+	    }
+	    else			/* pointer block full */
+	    {
+		/*
+		 * split the pointer block
+		 * allocate a new pointer block
+		 * move some of the pointer into the new block
+		 * prepare for updating the parent block
+		 */
+		for (;;)	/* do this twice when splitting block 1 */
+		{
+		    hp_new = ml_new_ptr(mfp);
+		    if (hp_new == NULL)	    /* TODO: try to fix tree */
+			return FAIL;
+		    pp_new = (PTR_BL *)(hp_new->bh_data);
+
+		    if (hp->bh_bnum != 1)
+			break;
+
+		    /*
+		     * if block 1 becomes full the tree is given an extra level
+		     * The pointers from block 1 are moved into the new block.
+		     * block 1 is updated to point to the new block
+		     * then continue to split the new block
+		     */
+		    mch_memmove(pp_new, pp, (size_t)page_size);
+		    pp->pb_count = 1;
+		    pp->pb_pointer[0].pe_bnum = hp_new->bh_bnum;
+		    pp->pb_pointer[0].pe_line_count = buf->b_ml.ml_line_count;
+		    pp->pb_pointer[0].pe_old_lnum = 1;
+		    pp->pb_pointer[0].pe_page_count = 1;
+		    mf_put(mfp, hp, TRUE, FALSE);   /* release block 1 */
+		    hp = hp_new;		/* new block is to be split */
+		    pp = pp_new;
+		    CHECK(stack_idx != 0, _("stack_idx should be 0"));
+		    ip->ip_index = 0;
+		    ++stack_idx;	/* do block 1 again later */
+		}
+		/*
+		 * move the pointers after the current one to the new block
+		 * If there are none, the new entry will be in the new block.
+		 */
+		total_moved = pp->pb_count - pb_idx - 1;
+		if (total_moved)
+		{
+		    mch_memmove(&pp_new->pb_pointer[0],
+				&pp->pb_pointer[pb_idx + 1],
+				(size_t)(total_moved) * sizeof(PTR_EN));
+		    pp_new->pb_count = total_moved;
+		    pp->pb_count -= total_moved - 1;
+		    pp->pb_pointer[pb_idx + 1].pe_bnum = bnum_right;
+		    pp->pb_pointer[pb_idx + 1].pe_line_count = line_count_right;
+		    pp->pb_pointer[pb_idx + 1].pe_page_count = page_count_right;
+		    if (lnum_right)
+			pp->pb_pointer[pb_idx + 1].pe_old_lnum = lnum_right;
+		}
+		else
+		{
+		    pp_new->pb_count = 1;
+		    pp_new->pb_pointer[0].pe_bnum = bnum_right;
+		    pp_new->pb_pointer[0].pe_line_count = line_count_right;
+		    pp_new->pb_pointer[0].pe_page_count = page_count_right;
+		    pp_new->pb_pointer[0].pe_old_lnum = lnum_right;
+		}
+		pp->pb_pointer[pb_idx].pe_bnum = bnum_left;
+		pp->pb_pointer[pb_idx].pe_line_count = line_count_left;
+		pp->pb_pointer[pb_idx].pe_page_count = page_count_left;
+		if (lnum_left)
+		    pp->pb_pointer[pb_idx].pe_old_lnum = lnum_left;
+		lnum_left = 0;
+		lnum_right = 0;
+
+		/*
+		 * recompute line counts
+		 */
+		line_count_right = 0;
+		for (i = 0; i < (int)pp_new->pb_count; ++i)
+		    line_count_right += pp_new->pb_pointer[i].pe_line_count;
+		line_count_left = 0;
+		for (i = 0; i < (int)pp->pb_count; ++i)
+		    line_count_left += pp->pb_pointer[i].pe_line_count;
+
+		bnum_left = hp->bh_bnum;
+		bnum_right = hp_new->bh_bnum;
+		page_count_left = 1;
+		page_count_right = 1;
+		mf_put(mfp, hp, TRUE, FALSE);
+		mf_put(mfp, hp_new, TRUE, FALSE);
+	    }
+	}
+
+	/*
+	 * Safety check: fallen out of for loop?
+	 */
+	if (stack_idx < 0)
+	{
+	    EMSG(_("E318: Updated too many blocks?"));
+	    buf->b_ml.ml_stack_top = 0;	/* invalidate stack */
+	}
+    }
+
+#ifdef FEAT_BYTEOFF
+    /* The line was inserted below 'lnum' */
+    ml_updatechunk(buf, lnum + 1, (long)len, ML_CHNK_ADDLINE);
+#endif
+#ifdef FEAT_NETBEANS_INTG
+    if (usingNetbeans)
+    {
+	if (STRLEN(line) > 0)
+	    netbeans_inserted(buf, lnum+1, (colnr_T)0, 0, line, STRLEN(line));
+	netbeans_inserted(buf, lnum+1, (colnr_T)STRLEN(line), 0,
+							   (char_u *)"\n", 1);
+    }
+#endif
+    return OK;
+}
+
+/*
+ * replace line lnum, with buffering, in current buffer
+ *
+ * If copy is TRUE, make a copy of the line, otherwise the line has been
+ * copied to allocated memory already.
+ *
+ * Check: The caller of this function should probably also call
+ * changed_lines(), unless update_screen(NOT_VALID) is used.
+ *
+ * return FAIL for failure, OK otherwise
+ */
+    int
+ml_replace(lnum, line, copy)
+    linenr_T	lnum;
+    char_u	*line;
+    int		copy;
+{
+    if (line == NULL)		/* just checking... */
+	return FAIL;
+
+    /* When starting up, we might still need to create the memfile */
+    if (curbuf->b_ml.ml_mfp == NULL && open_buffer(FALSE, NULL) == FAIL)
+	return FAIL;
+
+    if (copy && (line = vim_strsave(line)) == NULL) /* allocate memory */
+	return FAIL;
+#ifdef FEAT_NETBEANS_INTG
+    if (usingNetbeans)
+    {
+	netbeans_removed(curbuf, lnum, 0, (long)STRLEN(ml_get(lnum)));
+	netbeans_inserted(curbuf, lnum, 0, 0, line, STRLEN(line));
+    }
+#endif
+    if (curbuf->b_ml.ml_line_lnum != lnum)	    /* other line buffered */
+	ml_flush_line(curbuf);			    /* flush it */
+    else if (curbuf->b_ml.ml_flags & ML_LINE_DIRTY) /* same line allocated */
+	vim_free(curbuf->b_ml.ml_line_ptr);	    /* free it */
+    curbuf->b_ml.ml_line_ptr = line;
+    curbuf->b_ml.ml_line_lnum = lnum;
+    curbuf->b_ml.ml_flags = (curbuf->b_ml.ml_flags | ML_LINE_DIRTY) & ~ML_EMPTY;
+
+    return OK;
+}
+
+/*
+ * delete line 'lnum'
+ *
+ * Check: The caller of this function should probably also call
+ * deleted_lines() after this.
+ *
+ * return FAIL for failure, OK otherwise
+ */
+    int
+ml_delete(lnum, message)
+    linenr_T	lnum;
+    int		message;
+{
+    ml_flush_line(curbuf);
+    return ml_delete_int(curbuf, lnum, message);
+}
+
+    static int
+ml_delete_int(buf, lnum, message)
+    buf_T	*buf;
+    linenr_T	lnum;
+    int		message;
+{
+    bhdr_T	*hp;
+    memfile_T	*mfp;
+    DATA_BL	*dp;
+    PTR_BL	*pp;
+    infoptr_T	*ip;
+    int		count;	    /* number of entries in block */
+    int		idx;
+    int		stack_idx;
+    int		text_start;
+    int		line_start;
+    long	line_size;
+    int		i;
+
+    if (lnum < 1 || lnum > buf->b_ml.ml_line_count)
+	return FAIL;
+
+    if (lowest_marked && lowest_marked > lnum)
+	lowest_marked--;
+
+/*
+ * If the file becomes empty the last line is replaced by an empty line.
+ */
+    if (buf->b_ml.ml_line_count == 1)	    /* file becomes empty */
+    {
+	if (message
+#ifdef FEAT_NETBEANS_INTG
+		&& !netbeansSuppressNoLines
+#endif
+	   )
+	{
+	    set_keep_msg((char_u *)_(no_lines_msg));
+	    keep_msg_attr = 0;
+	}
+	/* FEAT_BYTEOFF already handled in there, dont worry 'bout it below */
+	i = ml_replace((linenr_T)1, (char_u *)"", TRUE);
+	buf->b_ml.ml_flags |= ML_EMPTY;
+
+	return i;
+    }
+
+/*
+ * find the data block containing the line
+ * This also fills the stack with the blocks from the root to the data block
+ * This also releases any locked block.
+ */
+    mfp = buf->b_ml.ml_mfp;
+    if (mfp == NULL)
+	return FAIL;
+
+    if ((hp = ml_find_line(buf, lnum, ML_DELETE)) == NULL)
+	return FAIL;
+
+    dp = (DATA_BL *)(hp->bh_data);
+    /* compute line count before the delete */
+    count = (long)(buf->b_ml.ml_locked_high)
+					- (long)(buf->b_ml.ml_locked_low) + 2;
+    idx = lnum - buf->b_ml.ml_locked_low;
+
+    --buf->b_ml.ml_line_count;
+
+    line_start = ((dp->db_index[idx]) & DB_INDEX_MASK);
+    if (idx == 0)		/* first line in block, text at the end */
+	line_size = dp->db_txt_end - line_start;
+    else
+	line_size = ((dp->db_index[idx - 1]) & DB_INDEX_MASK) - line_start;
+
+#ifdef FEAT_NETBEANS_INTG
+    if (usingNetbeans)
+	netbeans_removed(buf, lnum, 0, line_size);
+#endif
+
+/*
+ * special case: If there is only one line in the data block it becomes empty.
+ * Then we have to remove the entry, pointing to this data block, from the
+ * pointer block. If this pointer block also becomes empty, we go up another
+ * block, and so on, up to the root if necessary.
+ * The line counts in the pointer blocks have already been adjusted by
+ * ml_find_line().
+ */
+    if (count == 1)
+    {
+	mf_free(mfp, hp);	/* free the data block */
+	buf->b_ml.ml_locked = NULL;
+
+	for (stack_idx = buf->b_ml.ml_stack_top - 1; stack_idx >= 0; --stack_idx)
+	{
+	    buf->b_ml.ml_stack_top = 0;	    /* stack is invalid when failing */
+	    ip = &(buf->b_ml.ml_stack[stack_idx]);
+	    idx = ip->ip_index;
+	    if ((hp = mf_get(mfp, ip->ip_bnum, 1)) == NULL)
+		return FAIL;
+	    pp = (PTR_BL *)(hp->bh_data);   /* must be pointer block */
+	    if (pp->pb_id != PTR_ID)
+	    {
+		EMSG(_("E317: pointer block id wrong 4"));
+		mf_put(mfp, hp, FALSE, FALSE);
+		return FAIL;
+	    }
+	    count = --(pp->pb_count);
+	    if (count == 0)	    /* the pointer block becomes empty! */
+		mf_free(mfp, hp);
+	    else
+	    {
+		if (count != idx)	/* move entries after the deleted one */
+		    mch_memmove(&pp->pb_pointer[idx], &pp->pb_pointer[idx + 1],
+				      (size_t)(count - idx) * sizeof(PTR_EN));
+		mf_put(mfp, hp, TRUE, FALSE);
+
+		buf->b_ml.ml_stack_top = stack_idx;	/* truncate stack */
+		    /* fix line count for rest of blocks in the stack */
+		if (buf->b_ml.ml_locked_lineadd)
+		{
+		    ml_lineadd(buf, buf->b_ml.ml_locked_lineadd);
+		    buf->b_ml.ml_stack[buf->b_ml.ml_stack_top].ip_high +=
+						buf->b_ml.ml_locked_lineadd;
+		}
+		++(buf->b_ml.ml_stack_top);
+
+		break;
+	    }
+	}
+	CHECK(stack_idx < 0, _("deleted block 1?"));
+    }
+    else
+    {
+	/*
+	 * delete the text by moving the next lines forwards
+	 */
+	text_start = dp->db_txt_start;
+	mch_memmove((char *)dp + text_start + line_size,
+		  (char *)dp + text_start, (size_t)(line_start - text_start));
+
+	/*
+	 * delete the index by moving the next indexes backwards
+	 * Adjust the indexes for the text movement.
+	 */
+	for (i = idx; i < count - 1; ++i)
+	    dp->db_index[i] = dp->db_index[i + 1] + line_size;
+
+	dp->db_free += line_size + INDEX_SIZE;
+	dp->db_txt_start += line_size;
+	--(dp->db_line_count);
+
+	/*
+	 * mark the block dirty and make sure it is in the file (for recovery)
+	 */
+	buf->b_ml.ml_flags |= (ML_LOCKED_DIRTY | ML_LOCKED_POS);
+    }
+
+#ifdef FEAT_BYTEOFF
+    ml_updatechunk(buf, lnum, line_size, ML_CHNK_DELLINE);
+#endif
+    return OK;
+}
+
+/*
+ * set the B_MARKED flag for line 'lnum'
+ */
+    void
+ml_setmarked(lnum)
+    linenr_T lnum;
+{
+    bhdr_T    *hp;
+    DATA_BL *dp;
+				    /* invalid line number */
+    if (lnum < 1 || lnum > curbuf->b_ml.ml_line_count
+					       || curbuf->b_ml.ml_mfp == NULL)
+	return;			    /* give error message? */
+
+    if (lowest_marked == 0 || lowest_marked > lnum)
+	lowest_marked = lnum;
+
+    /*
+     * find the data block containing the line
+     * This also fills the stack with the blocks from the root to the data block
+     * This also releases any locked block.
+     */
+    if ((hp = ml_find_line(curbuf, lnum, ML_FIND)) == NULL)
+	return;		    /* give error message? */
+
+    dp = (DATA_BL *)(hp->bh_data);
+    dp->db_index[lnum - curbuf->b_ml.ml_locked_low] |= DB_MARKED;
+    curbuf->b_ml.ml_flags |= ML_LOCKED_DIRTY;
+}
+
+/*
+ * find the first line with its B_MARKED flag set
+ */
+    linenr_T
+ml_firstmarked()
+{
+    bhdr_T	*hp;
+    DATA_BL	*dp;
+    linenr_T	lnum;
+    int		i;
+
+    if (curbuf->b_ml.ml_mfp == NULL)
+	return (linenr_T) 0;
+
+    /*
+     * The search starts with lowest_marked line. This is the last line where
+     * a mark was found, adjusted by inserting/deleting lines.
+     */
+    for (lnum = lowest_marked; lnum <= curbuf->b_ml.ml_line_count; )
+    {
+	/*
+	 * Find the data block containing the line.
+	 * This also fills the stack with the blocks from the root to the data
+	 * block This also releases any locked block.
+	 */
+	if ((hp = ml_find_line(curbuf, lnum, ML_FIND)) == NULL)
+	    return (linenr_T)0;		    /* give error message? */
+
+	dp = (DATA_BL *)(hp->bh_data);
+
+	for (i = lnum - curbuf->b_ml.ml_locked_low;
+			    lnum <= curbuf->b_ml.ml_locked_high; ++i, ++lnum)
+	    if ((dp->db_index[i]) & DB_MARKED)
+	    {
+		(dp->db_index[i]) &= DB_INDEX_MASK;
+		curbuf->b_ml.ml_flags |= ML_LOCKED_DIRTY;
+		lowest_marked = lnum + 1;
+		return lnum;
+	    }
+    }
+
+    return (linenr_T) 0;
+}
+
+#if 0  /* not used */
+/*
+ * return TRUE if line 'lnum' has a mark
+ */
+    int
+ml_has_mark(lnum)
+    linenr_T	lnum;
+{
+    bhdr_T	*hp;
+    DATA_BL	*dp;
+
+    if (curbuf->b_ml.ml_mfp == NULL
+			|| (hp = ml_find_line(curbuf, lnum, ML_FIND)) == NULL)
+	return FALSE;
+
+    dp = (DATA_BL *)(hp->bh_data);
+    return (int)((dp->db_index[lnum - curbuf->b_ml.ml_locked_low]) & DB_MARKED);
+}
+#endif
+
+/*
+ * clear all DB_MARKED flags
+ */
+    void
+ml_clearmarked()
+{
+    bhdr_T	*hp;
+    DATA_BL	*dp;
+    linenr_T	lnum;
+    int		i;
+
+    if (curbuf->b_ml.ml_mfp == NULL)	    /* nothing to do */
+	return;
+
+    /*
+     * The search starts with line lowest_marked.
+     */
+    for (lnum = lowest_marked; lnum <= curbuf->b_ml.ml_line_count; )
+    {
+	/*
+	 * Find the data block containing the line.
+	 * This also fills the stack with the blocks from the root to the data
+	 * block and releases any locked block.
+	 */
+	if ((hp = ml_find_line(curbuf, lnum, ML_FIND)) == NULL)
+	    return;		/* give error message? */
+
+	dp = (DATA_BL *)(hp->bh_data);
+
+	for (i = lnum - curbuf->b_ml.ml_locked_low;
+			    lnum <= curbuf->b_ml.ml_locked_high; ++i, ++lnum)
+	    if ((dp->db_index[i]) & DB_MARKED)
+	    {
+		(dp->db_index[i]) &= DB_INDEX_MASK;
+		curbuf->b_ml.ml_flags |= ML_LOCKED_DIRTY;
+	    }
+    }
+
+    lowest_marked = 0;
+    return;
+}
+
+/*
+ * flush ml_line if necessary
+ */
+    static void
+ml_flush_line(buf)
+    buf_T	*buf;
+{
+    bhdr_T	*hp;
+    DATA_BL	*dp;
+    linenr_T	lnum;
+    char_u	*new_line;
+    char_u	*old_line;
+    colnr_T	new_len;
+    int		old_len;
+    int		extra;
+    int		idx;
+    int		start;
+    int		count;
+    int		i;
+
+    if (buf->b_ml.ml_line_lnum == 0 || buf->b_ml.ml_mfp == NULL)
+	return;		/* nothing to do */
+
+    if (buf->b_ml.ml_flags & ML_LINE_DIRTY)
+    {
+	lnum = buf->b_ml.ml_line_lnum;
+	new_line = buf->b_ml.ml_line_ptr;
+
+	hp = ml_find_line(buf, lnum, ML_FIND);
+	if (hp == NULL)
+	    EMSGN(_("E320: Cannot find line %ld"), lnum);
+	else
+	{
+	    dp = (DATA_BL *)(hp->bh_data);
+	    idx = lnum - buf->b_ml.ml_locked_low;
+	    start = ((dp->db_index[idx]) & DB_INDEX_MASK);
+	    old_line = (char_u *)dp + start;
+	    if (idx == 0)	/* line is last in block */
+		old_len = dp->db_txt_end - start;
+	    else		/* text of previous line follows */
+		old_len = (dp->db_index[idx - 1] & DB_INDEX_MASK) - start;
+	    new_len = (colnr_T)STRLEN(new_line) + 1;
+	    extra = new_len - old_len;	    /* negative if lines gets smaller */
+
+	    /*
+	     * if new line fits in data block, replace directly
+	     */
+	    if ((int)dp->db_free >= extra)
+	    {
+		/* if the length changes and there are following lines */
+		count = buf->b_ml.ml_locked_high - buf->b_ml.ml_locked_low + 1;
+		if (extra != 0 && idx < count - 1)
+		{
+		    /* move text of following lines */
+		    mch_memmove((char *)dp + dp->db_txt_start - extra,
+				(char *)dp + dp->db_txt_start,
+				(size_t)(start - dp->db_txt_start));
+
+		    /* adjust pointers of this and following lines */
+		    for (i = idx + 1; i < count; ++i)
+			dp->db_index[i] -= extra;
+		}
+		dp->db_index[idx] -= extra;
+
+		/* adjust free space */
+		dp->db_free -= extra;
+		dp->db_txt_start -= extra;
+
+		/* copy new line into the data block */
+		mch_memmove(old_line - extra, new_line, (size_t)new_len);
+		buf->b_ml.ml_flags |= (ML_LOCKED_DIRTY | ML_LOCKED_POS);
+#ifdef FEAT_BYTEOFF
+		/* The else case is already covered by the insert and delete */
+		ml_updatechunk(buf, lnum, (long)extra, ML_CHNK_UPDLINE);
+#endif
+	    }
+	    else
+	    {
+		/*
+		 * Cannot do it in one data block: Delete and append.
+		 * Append first, because ml_delete_int() cannot delete the
+		 * last line in a buffer, which causes trouble for a buffer
+		 * that has only one line.
+		 * Don't forget to copy the mark!
+		 */
+		/* How about handling errors??? */
+		(void)ml_append_int(buf, lnum, new_line, new_len, FALSE,
+					     (dp->db_index[idx] & DB_MARKED));
+		(void)ml_delete_int(buf, lnum, FALSE);
+	    }
+	}
+	vim_free(new_line);
+    }
+
+    buf->b_ml.ml_line_lnum = 0;
+}
+
+/*
+ * create a new, empty, data block
+ */
+    static bhdr_T *
+ml_new_data(mfp, negative, page_count)
+    memfile_T	*mfp;
+    int		negative;
+    int		page_count;
+{
+    bhdr_T	*hp;
+    DATA_BL	*dp;
+
+    if ((hp = mf_new(mfp, negative, page_count)) == NULL)
+	return NULL;
+
+    dp = (DATA_BL *)(hp->bh_data);
+    dp->db_id = DATA_ID;
+    dp->db_txt_start = dp->db_txt_end = page_count * mfp->mf_page_size;
+    dp->db_free = dp->db_txt_start - HEADER_SIZE;
+    dp->db_line_count = 0;
+
+    return hp;
+}
+
+/*
+ * create a new, empty, pointer block
+ */
+    static bhdr_T *
+ml_new_ptr(mfp)
+    memfile_T	*mfp;
+{
+    bhdr_T	*hp;
+    PTR_BL	*pp;
+
+    if ((hp = mf_new(mfp, FALSE, 1)) == NULL)
+	return NULL;
+
+    pp = (PTR_BL *)(hp->bh_data);
+    pp->pb_id = PTR_ID;
+    pp->pb_count = 0;
+    pp->pb_count_max = (short_u)((mfp->mf_page_size - sizeof(PTR_BL)) / sizeof(PTR_EN) + 1);
+
+    return hp;
+}
+
+/*
+ * lookup line 'lnum' in a memline
+ *
+ *   action: if ML_DELETE or ML_INSERT the line count is updated while searching
+ *	     if ML_FLUSH only flush a locked block
+ *	     if ML_FIND just find the line
+ *
+ * If the block was found it is locked and put in ml_locked.
+ * The stack is updated to lead to the locked block. The ip_high field in
+ * the stack is updated to reflect the last line in the block AFTER the
+ * insert or delete, also if the pointer block has not been updated yet. But
+ * if if ml_locked != NULL ml_locked_lineadd must be added to ip_high.
+ *
+ * return: NULL for failure, pointer to block header otherwise
+ */
+    static bhdr_T *
+ml_find_line(buf, lnum, action)
+    buf_T	*buf;
+    linenr_T	lnum;
+    int		action;
+{
+    DATA_BL	*dp;
+    PTR_BL	*pp;
+    infoptr_T	*ip;
+    bhdr_T	*hp;
+    memfile_T	*mfp;
+    linenr_T	t;
+    blocknr_T	bnum, bnum2;
+    int		dirty;
+    linenr_T	low, high;
+    int		top;
+    int		page_count;
+    int		idx;
+
+    mfp = buf->b_ml.ml_mfp;
+
+    /*
+     * If there is a locked block check if the wanted line is in it.
+     * If not, flush and release the locked block.
+     * Don't do this for ML_INSERT_SAME, because the stack need to be updated.
+     * Don't do this for ML_FLUSH, because we want to flush the locked block.
+     */
+    if (buf->b_ml.ml_locked)
+    {
+	if (ML_SIMPLE(action) && buf->b_ml.ml_locked_low <= lnum
+					  && buf->b_ml.ml_locked_high >= lnum)
+	{
+		/* remember to update pointer blocks and stack later */
+	    if (action == ML_INSERT)
+	    {
+		++(buf->b_ml.ml_locked_lineadd);
+		++(buf->b_ml.ml_locked_high);
+	    }
+	    else if (action == ML_DELETE)
+	    {
+		--(buf->b_ml.ml_locked_lineadd);
+		--(buf->b_ml.ml_locked_high);
+	    }
+	    return (buf->b_ml.ml_locked);
+	}
+
+	mf_put(mfp, buf->b_ml.ml_locked, buf->b_ml.ml_flags & ML_LOCKED_DIRTY,
+					    buf->b_ml.ml_flags & ML_LOCKED_POS);
+	buf->b_ml.ml_locked = NULL;
+
+	    /*
+	     * if lines have been added or deleted in the locked block, need to
+	     * update the line count in pointer blocks
+	     */
+	if (buf->b_ml.ml_locked_lineadd)
+	    ml_lineadd(buf, buf->b_ml.ml_locked_lineadd);
+    }
+
+    if (action == ML_FLUSH)	    /* nothing else to do */
+	return NULL;
+
+    bnum = 1;			    /* start at the root of the tree */
+    page_count = 1;
+    low = 1;
+    high = buf->b_ml.ml_line_count;
+
+    if (action == ML_FIND)	/* first try stack entries */
+    {
+	for (top = buf->b_ml.ml_stack_top - 1; top >= 0; --top)
+	{
+	    ip = &(buf->b_ml.ml_stack[top]);
+	    if (ip->ip_low <= lnum && ip->ip_high >= lnum)
+	    {
+		bnum = ip->ip_bnum;
+		low = ip->ip_low;
+		high = ip->ip_high;
+		buf->b_ml.ml_stack_top = top;	/* truncate stack at prev entry */
+		break;
+	    }
+	}
+	if (top < 0)
+	    buf->b_ml.ml_stack_top = 0;		/* not found, start at the root */
+    }
+    else	/* ML_DELETE or ML_INSERT */
+	buf->b_ml.ml_stack_top = 0;	/* start at the root */
+
+/*
+ * search downwards in the tree until a data block is found
+ */
+    for (;;)
+    {
+	if ((hp = mf_get(mfp, bnum, page_count)) == NULL)
+	    goto error_noblock;
+
+	/*
+	 * update high for insert/delete
+	 */
+	if (action == ML_INSERT)
+	    ++high;
+	else if (action == ML_DELETE)
+	    --high;
+
+	dp = (DATA_BL *)(hp->bh_data);
+	if (dp->db_id == DATA_ID)	/* data block */
+	{
+	    buf->b_ml.ml_locked = hp;
+	    buf->b_ml.ml_locked_low = low;
+	    buf->b_ml.ml_locked_high = high;
+	    buf->b_ml.ml_locked_lineadd = 0;
+	    buf->b_ml.ml_flags &= ~(ML_LOCKED_DIRTY | ML_LOCKED_POS);
+	    return hp;
+	}
+
+	pp = (PTR_BL *)(dp);		/* must be pointer block */
+	if (pp->pb_id != PTR_ID)
+	{
+	    EMSG(_("E317: pointer block id wrong"));
+	    goto error_block;
+	}
+
+	if ((top = ml_add_stack(buf)) < 0)	/* add new entry to stack */
+	    goto error_block;
+	ip = &(buf->b_ml.ml_stack[top]);
+	ip->ip_bnum = bnum;
+	ip->ip_low = low;
+	ip->ip_high = high;
+	ip->ip_index = -1;		/* index not known yet */
+
+	dirty = FALSE;
+	for (idx = 0; idx < (int)pp->pb_count; ++idx)
+	{
+	    t = pp->pb_pointer[idx].pe_line_count;
+	    CHECK(t == 0, _("pe_line_count is zero"));
+	    if ((low += t) > lnum)
+	    {
+		ip->ip_index = idx;
+		bnum = pp->pb_pointer[idx].pe_bnum;
+		page_count = pp->pb_pointer[idx].pe_page_count;
+		high = low - 1;
+		low -= t;
+
+		/*
+		 * a negative block number may have been changed
+		 */
+		if (bnum < 0)
+		{
+		    bnum2 = mf_trans_del(mfp, bnum);
+		    if (bnum != bnum2)
+		    {
+			bnum = bnum2;
+			pp->pb_pointer[idx].pe_bnum = bnum;
+			dirty = TRUE;
+		    }
+		}
+
+		break;
+	    }
+	}
+	if (idx >= (int)pp->pb_count)	    /* past the end: something wrong! */
+	{
+	    if (lnum > buf->b_ml.ml_line_count)
+		EMSGN(_("E322: line number out of range: %ld past the end"),
+					      lnum - buf->b_ml.ml_line_count);
+
+	    else
+		EMSGN(_("E323: line count wrong in block %ld"), bnum);
+	    goto error_block;
+	}
+	if (action == ML_DELETE)
+	{
+	    pp->pb_pointer[idx].pe_line_count--;
+	    dirty = TRUE;
+	}
+	else if (action == ML_INSERT)
+	{
+	    pp->pb_pointer[idx].pe_line_count++;
+	    dirty = TRUE;
+	}
+	mf_put(mfp, hp, dirty, FALSE);
+    }
+
+error_block:
+    mf_put(mfp, hp, FALSE, FALSE);
+error_noblock:
+/*
+ * If action is ML_DELETE or ML_INSERT we have to correct the tree for
+ * the incremented/decremented line counts, because there won't be a line
+ * inserted/deleted after all.
+ */
+    if (action == ML_DELETE)
+	ml_lineadd(buf, 1);
+    else if (action == ML_INSERT)
+	ml_lineadd(buf, -1);
+    buf->b_ml.ml_stack_top = 0;
+    return NULL;
+}
+
+/*
+ * add an entry to the info pointer stack
+ *
+ * return -1 for failure, number of the new entry otherwise
+ */
+    static int
+ml_add_stack(buf)
+    buf_T	*buf;
+{
+    int		top;
+    infoptr_T	*newstack;
+
+    top = buf->b_ml.ml_stack_top;
+
+	/* may have to increase the stack size */
+    if (top == buf->b_ml.ml_stack_size)
+    {
+	CHECK(top > 0, _("Stack size increases"));	/* more than 5 levels??? */
+
+	newstack = (infoptr_T *)alloc((unsigned)sizeof(infoptr_T) *
+					(buf->b_ml.ml_stack_size + STACK_INCR));
+	if (newstack == NULL)
+	    return -1;
+	mch_memmove(newstack, buf->b_ml.ml_stack, (size_t)top * sizeof(infoptr_T));
+	vim_free(buf->b_ml.ml_stack);
+	buf->b_ml.ml_stack = newstack;
+	buf->b_ml.ml_stack_size += STACK_INCR;
+    }
+
+    buf->b_ml.ml_stack_top++;
+    return top;
+}
+
+/*
+ * Update the pointer blocks on the stack for inserted/deleted lines.
+ * The stack itself is also updated.
+ *
+ * When a insert/delete line action fails, the line is not inserted/deleted,
+ * but the pointer blocks have already been updated. That is fixed here by
+ * walking through the stack.
+ *
+ * Count is the number of lines added, negative if lines have been deleted.
+ */
+    static void
+ml_lineadd(buf, count)
+    buf_T	*buf;
+    int		count;
+{
+    int		idx;
+    infoptr_T	*ip;
+    PTR_BL	*pp;
+    memfile_T	*mfp = buf->b_ml.ml_mfp;
+    bhdr_T	*hp;
+
+    for (idx = buf->b_ml.ml_stack_top - 1; idx >= 0; --idx)
+    {
+	ip = &(buf->b_ml.ml_stack[idx]);
+	if ((hp = mf_get(mfp, ip->ip_bnum, 1)) == NULL)
+	    break;
+	pp = (PTR_BL *)(hp->bh_data);	/* must be pointer block */
+	if (pp->pb_id != PTR_ID)
+	{
+	    mf_put(mfp, hp, FALSE, FALSE);
+	    EMSG(_("E317: pointer block id wrong 2"));
+	    break;
+	}
+	pp->pb_pointer[ip->ip_index].pe_line_count += count;
+	ip->ip_high += count;
+	mf_put(mfp, hp, TRUE, FALSE);
+    }
+}
+
+/*
+ * make swap file name out of the file name and a directory name
+ */
+    static char_u *
+makeswapname(buf, dir_name)
+    buf_T	*buf;
+    char_u	*dir_name;
+{
+    char_u	*r, *s;
+
+#if defined(UNIX) || defined(WIN3264)  /* Need _very_ long file names */
+    s = dir_name + STRLEN(dir_name);
+    if (vim_ispathsep(s[-1]) && s[-1] == s[-2])
+    {			       /* Ends with '//', Use Full path */
+	r = NULL;
+	if ((s = make_percent_swname(dir_name, buf->b_fname)) != NULL)
+	{
+	    r = modname(s, (char_u *)".swp", FALSE);
+	    vim_free(s);
+	}
+	return r;
+    }
+#endif
+
+    r = buf_modname(
+#ifdef SHORT_FNAME
+	    TRUE,
+#else
+	    (buf->b_p_sn || buf->b_shortname),
+#endif
+#ifdef RISCOS
+	    /* Avoid problems if fname has special chars, eg <Wimp$Scrap> */
+	    buf->b_ffname,
+#else
+	    buf->b_fname,
+#endif
+	    (char_u *)
+#if defined(VMS) || defined(RISCOS)
+	    "_swp",
+#else
+	    ".swp",
+#endif
+#ifdef SHORT_FNAME		/* always 8.3 file name */
+	    FALSE
+#else
+	    /* Prepend a '.' to the swap file name for the current directory. */
+	    dir_name[0] == '.' && dir_name[1] == NUL
+#endif
+	       );
+    if (r == NULL)	    /* out of memory */
+	return NULL;
+
+    s = get_file_in_dir(r, dir_name);
+    vim_free(r);
+    return s;
+}
+
+/*
+ * Get file name to use for swap file or backup file.
+ * Use the name of the edited file "fname" and an entry in the 'dir' or 'bdir'
+ * option "dname".
+ * - If "dname" is ".", return "fname" (swap file in dir of file).
+ * - If "dname" starts with "./", insert "dname" in "fname" (swap file
+ *   relative to dir of file).
+ * - Otherwise, prepend "dname" to the tail of "fname" (swap file in specific
+ *   dir).
+ *
+ * The return value is an allocated string and can be NULL.
+ */
+    char_u *
+get_file_in_dir(fname, dname)
+    char_u  *fname;
+    char_u  *dname;	/* don't use "dirname", it is a global for Alpha */
+{
+    char_u	*t;
+    char_u	*tail;
+    char_u	*retval;
+    int		save_char;
+
+    tail = gettail(fname);
+
+    if (dname[0] == '.' && dname[1] == NUL)
+	retval = vim_strsave(fname);
+    else if (dname[0] == '.' && vim_ispathsep(dname[1]))
+    {
+	if (tail == fname)	    /* no path before file name */
+	    retval = concat_fnames(dname + 2, tail, TRUE);
+	else
+	{
+	    save_char = *tail;
+	    *tail = NUL;
+	    t = concat_fnames(fname, dname + 2, TRUE);
+	    *tail = save_char;
+	    if (t == NULL)	    /* out of memory */
+		retval = NULL;
+	    else
+	    {
+		retval = concat_fnames(t, tail, TRUE);
+		vim_free(t);
+	    }
+	}
+    }
+    else
+	retval = concat_fnames(dname, tail, TRUE);
+
+    return retval;
+}
+
+/*
+ * Find out what name to use for the swap file for buffer 'buf'.
+ *
+ * Several names are tried to find one that does not exist
+ *
+ * Note: If BASENAMELEN is not correct, you will get error messages for
+ *	 not being able to open the swapfile
+ */
+    static char_u *
+findswapname(buf, dirp, old_fname)
+    buf_T	*buf;
+    char_u	**dirp;		/* pointer to list of directories */
+    char_u	*old_fname;	/* don't give warning for this file name */
+{
+    char_u	*fname;
+    int		n;
+    time_t	x, sx;
+    char_u	*dir_name;
+#ifdef AMIGA
+    BPTR	fh;
+#endif
+#ifndef SHORT_FNAME
+    int		r;
+#endif
+
+#if !defined(SHORT_FNAME) \
+		     && ((!defined(UNIX) && !defined(OS2)) || defined(ARCHIE))
+# define CREATE_DUMMY_FILE
+    FILE	*dummyfd = NULL;
+
+/*
+ * If we start editing a new file, e.g. "test.doc", which resides on an MSDOS
+ * compatible filesystem, it is possible that the file "test.doc.swp" which we
+ * create will be exactly the same file. To avoid this problem we temporarily
+ * create "test.doc".
+ * Don't do this when the check below for a 8.3 file name is used.
+ */
+    if (!(buf->b_p_sn || buf->b_shortname) && buf->b_fname != NULL
+					     && mch_getperm(buf->b_fname) < 0)
+	dummyfd = mch_fopen((char *)buf->b_fname, "w");
+#endif
+
+/*
+ * Isolate a directory name from *dirp and put it in dir_name.
+ * First allocate some memory to put the directory name in.
+ */
+    dir_name = alloc((unsigned)STRLEN(*dirp) + 1);
+    if (dir_name != NULL)
+	(void)copy_option_part(dirp, dir_name, 31000, ",");
+
+/*
+ * we try different names until we find one that does not exist yet
+ */
+    if (dir_name == NULL)	    /* out of memory */
+	fname = NULL;
+    else
+	fname = makeswapname(buf, dir_name);
+
+    for (;;)
+    {
+	if (fname == NULL)	/* must be out of memory */
+	    break;
+	if ((n = (int)STRLEN(fname)) == 0)	/* safety check */
+	{
+	    vim_free(fname);
+	    fname = NULL;
+	    break;
+	}
+#if (defined(UNIX) || defined(OS2)) && !defined(ARCHIE) && !defined(SHORT_FNAME)
+/*
+ * Some systems have a MS-DOS compatible filesystem that use 8.3 character
+ * file names. If this is the first try and the swap file name does not fit in
+ * 8.3, detect if this is the case, set shortname and try again.
+ */
+	if (fname[n - 2] == 'w' && fname[n - 1] == 'p'
+					&& !(buf->b_p_sn || buf->b_shortname))
+	{
+	    char_u	    *tail;
+	    char_u	    *fname2;
+	    struct stat	    s1, s2;
+	    int		    f1, f2;
+	    int		    created1 = FALSE, created2 = FALSE;
+	    int		    same = FALSE;
+
+	    /*
+	     * Check if swapfile name does not fit in 8.3:
+	     * It either contains two dots, is longer than 8 chars, or starts
+	     * with a dot.
+	     */
+	    tail = gettail(buf->b_fname);
+	    if (       vim_strchr(tail, '.') != NULL
+		    || STRLEN(tail) > (size_t)8
+		    || *gettail(fname) == '.')
+	    {
+		fname2 = alloc(n + 2);
+		if (fname2 != NULL)
+		{
+		    STRCPY(fname2, fname);
+		    /* if fname == "xx.xx.swp",	    fname2 = "xx.xx.swx"
+		     * if fname == ".xx.swp",	    fname2 = ".xx.swpx"
+		     * if fname == "123456789.swp", fname2 = "12345678x.swp"
+		     */
+		    if (vim_strchr(tail, '.') != NULL)
+			fname2[n - 1] = 'x';
+		    else if (*gettail(fname) == '.')
+		    {
+			fname2[n] = 'x';
+			fname2[n + 1] = NUL;
+		    }
+		    else
+			fname2[n - 5] += 1;
+		    /*
+		     * may need to create the files to be able to use mch_stat()
+		     */
+		    f1 = mch_open((char *)fname, O_RDONLY | O_EXTRA, 0);
+		    if (f1 < 0)
+		    {
+			f1 = mch_open_rw((char *)fname,
+					       O_RDWR|O_CREAT|O_EXCL|O_EXTRA);
+#if defined(OS2)
+			if (f1 < 0 && errno == ENOENT)
+			    same = TRUE;
+#endif
+			created1 = TRUE;
+		    }
+		    if (f1 >= 0)
+		    {
+			f2 = mch_open((char *)fname2, O_RDONLY | O_EXTRA, 0);
+			if (f2 < 0)
+			{
+			    f2 = mch_open_rw((char *)fname2,
+					       O_RDWR|O_CREAT|O_EXCL|O_EXTRA);
+			    created2 = TRUE;
+			}
+			if (f2 >= 0)
+			{
+			    /*
+			     * Both files exist now. If mch_stat() returns the
+			     * same device and inode they are the same file.
+			     */
+			    if (mch_fstat(f1, &s1) != -1
+				    && mch_fstat(f2, &s2) != -1
+				    && s1.st_dev == s2.st_dev
+				    && s1.st_ino == s2.st_ino)
+				same = TRUE;
+			    close(f2);
+			    if (created2)
+				mch_remove(fname2);
+			}
+			close(f1);
+			if (created1)
+			    mch_remove(fname);
+		    }
+		    vim_free(fname2);
+		    if (same)
+		    {
+			buf->b_shortname = TRUE;
+			vim_free(fname);
+			fname = makeswapname(buf, dir_name);
+			continue;	/* try again with b_shortname set */
+		    }
+		}
+	    }
+	}
+#endif
+	/*
+	 * check if the swapfile already exists
+	 */
+	if (mch_getperm(fname) < 0)	/* it does not exist */
+	{
+#ifdef HAVE_LSTAT
+	    struct stat sb;
+
+	    /*
+	     * Extra security check: When a swap file is a symbolic link, this
+	     * is most likely a symlink attack.
+	     */
+	    if (mch_lstat((char *)fname, &sb) < 0)
+#else
+# ifdef AMIGA
+	    fh = Open((UBYTE *)fname, (long)MODE_NEWFILE);
+	    /*
+	     * on the Amiga mch_getperm() will return -1 when the file exists
+	     * but is being used by another program. This happens if you edit
+	     * a file twice.
+	     */
+	    if (fh != (BPTR)NULL)	/* can open file, OK */
+	    {
+		Close(fh);
+		mch_remove(fname);
+		break;
+	    }
+	    if (IoErr() != ERROR_OBJECT_IN_USE
+					    && IoErr() != ERROR_OBJECT_EXISTS)
+# endif
+#endif
+		break;
+	}
+
+	/*
+	 * A file name equal to old_fname is OK to use.
+	 */
+	if (old_fname != NULL && fnamecmp(fname, old_fname) == 0)
+	    break;
+
+	/*
+	 * get here when file already exists
+	 */
+	if (fname[n - 2] == 'w' && fname[n - 1] == 'p')	/* first try */
+	{
+#ifndef SHORT_FNAME
+	    /*
+	     * on MS-DOS compatible filesystems (e.g. messydos) file.doc.swp
+	     * and file.doc are the same file. To guess if this problem is
+	     * present try if file.doc.swx exists. If it does, we set
+	     * buf->b_shortname and try file_doc.swp (dots replaced by
+	     * underscores for this file), and try again. If it doesn't we
+	     * assume that "file.doc.swp" already exists.
+	     */
+	    if (!(buf->b_p_sn || buf->b_shortname))	/* not tried yet */
+	    {
+		fname[n - 1] = 'x';
+		r = mch_getperm(fname);		/* try "file.swx" */
+		fname[n - 1] = 'p';
+		if (r >= 0)		    /* "file.swx" seems to exist */
+		{
+		    buf->b_shortname = TRUE;
+		    vim_free(fname);
+		    fname = makeswapname(buf, dir_name);
+		    continue;	    /* try again with '.' replaced with '_' */
+		}
+	    }
+#endif
+	    /*
+	     * If we get here the ".swp" file really exists.
+	     * Give an error message, unless recovering, no file name, we are
+	     * viewing a help file or when the path of the file is different
+	     * (happens when all .swp files are in one directory).
+	     */
+	    if (!recoverymode && buf->b_fname != NULL && !buf->b_help)
+	    {
+		int		fd;
+		struct block0	b0;
+		int		differ = FALSE;
+
+		/*
+		 * Try to read block 0 from the swap file to get the original
+		 * file name (and inode number).
+		 */
+		fd = mch_open((char *)fname, O_RDONLY | O_EXTRA, 0);
+		if (fd >= 0)
+		{
+		    if (read(fd, (char *)&b0, sizeof(b0)) == sizeof(b0))
+		    {
+			/*
+			 * The name in the swap file may be "~user/path/file".
+			 * Expand it first.
+			 */
+			expand_env(b0.b0_fname, NameBuff, MAXPATHL);
+#ifdef CHECK_INODE
+			if (fnamecmp_ino(buf->b_ffname, NameBuff,
+						     char_to_long(b0.b0_ino)))
+			    differ = TRUE;
+#else
+			if (fnamecmp(NameBuff, buf->b_ffname) != 0)
+			    differ = TRUE;
+#endif
+		    }
+		    close(fd);
+		}
+#ifdef RISCOS
+		else
+		    /* Can't open swap file, though it does exist.
+		     * Assume that the user is editing two files with
+		     * the same name in different directories. No error.
+		     */
+		    differ = TRUE;
+#endif
+
+		/* give the ATTENTION message when there is an old swap file
+		 * for the current file, and the buffer was not recovered. */
+		if (differ == FALSE && !(curbuf->b_flags & BF_RECOVERED)
+			&& vim_strchr(p_shm, SHM_ATTENTION) == NULL)
+		{
+		    struct stat st;
+#ifdef CREATE_DUMMY_FILE
+		    int		did_use_dummy = FALSE;
+
+		    /* Avoid getting a warning for the file being created
+		     * outside of Vim, it was created at the start of this
+		     * function.  Delete the file now, because Vim might exit
+		     * here if the window is closed. */
+		    if (dummyfd != NULL)
+		    {
+			fclose(dummyfd);
+			dummyfd = NULL;
+			mch_remove(buf->b_fname);
+			did_use_dummy = TRUE;
+		    }
+#endif
+#ifdef FEAT_GUI
+		    /* If we are supposed to start the GUI but it wasn't
+		     * completely started yet, start it now.  This makes the
+		     * messages displayed in the Vim window when loading a
+		     * session from the .gvimrc file. */
+		    if (gui.starting && !gui.in_use)
+			gui_start();
+#endif
+
+#if (defined(UNIX) || defined(__EMX__) || defined(VMS)) && (defined(FEAT_GUI_DIALOG) || defined(FEAT_CON_DIALOG))
+		    process_still_running = FALSE;
+#endif
+		    ++no_wait_return;
+		    (void)EMSG(_("E325: ATTENTION"));
+		    MSG_PUTS(_("\nFound a swap file by the name \""));
+		    msg_home_replace(fname);
+		    MSG_PUTS("\"\n");
+		    sx = swapfile_info(fname);
+		    MSG_PUTS(_("While opening file \""));
+		    msg_outtrans(buf->b_fname);
+		    MSG_PUTS("\"\n");
+		    if (mch_stat((char *)buf->b_fname, &st) != -1)
+		    {
+			MSG_PUTS(_("             dated: "));
+			x = st.st_mtime;    /* Manx C can't do &st.st_mtime */
+			MSG_PUTS(ctime(&x));
+			if (sx != 0 && x > sx)
+			    MSG_PUTS(_("      NEWER than swap file!\n"));
+		    }
+		    /* Some of these messages are long to allow translation to
+		     * other languages. */
+		    MSG_PUTS(_("\n(1) Another program may be editing the same file.\n    If this is the case, be careful not to end up with two\n    different instances of the same file when making changes.\n"));
+		    MSG_PUTS(_("    Quit, or continue with caution.\n"));
+		    MSG_PUTS(_("\n(2) An edit session for this file crashed.\n"));
+		    MSG_PUTS(_("    If this is the case, use \":recover\" or \"vim -r "));
+		    msg_outtrans(buf->b_fname);
+		    MSG_PUTS(_("\"\n    to recover the changes (see \":help recovery\").\n"));
+		    MSG_PUTS(_("    If you did this already, delete the swap file \""));
+		    msg_outtrans(fname);
+		    MSG_PUTS(_("\"\n    to avoid this message.\n"));
+		    cmdline_row = msg_row;
+		    --no_wait_return;
+
+		    /* We don't want a 'q' typed at the more-prompt interrupt
+		     * loading a file. */
+		    got_int = FALSE;
+
+#if defined(FEAT_GUI_DIALOG) || defined(FEAT_CON_DIALOG)
+		    if (swap_exists_action)
+		    {
+			char_u	*name;
+
+			name = alloc((unsigned)(STRLEN(fname)
+				+ STRLEN(_("Swap file \""))
+				+ STRLEN(_("\" already exists!")) + 5));
+			if (name != NULL)
+			{
+			    STRCPY(name, _("Swap file \""));
+			    home_replace(NULL, fname, name + STRLEN(name),
+								  1000, TRUE);
+			    STRCAT(name, _("\" already exists!"));
+			}
+			switch (do_dialog(VIM_WARNING,
+				    (char_u *)_("VIM - ATTENTION"),
+				    name == NULL
+					?  (char_u *)_("Swap file already exists!")
+					: name,
+# if defined(UNIX) || defined(__EMX__) || defined(VMS)
+				    process_still_running
+					? (char_u *)_("&Open Read-Only\n&Edit anyway\n&Recover\n&Quit\n&Abort") :
+# endif
+					(char_u *)_("&Open Read-Only\n&Edit anyway\n&Recover\n&Quit\n&Abort\n&Delete it"), 1, NULL))
+			{
+			    case 1:
+				buf->b_p_ro = TRUE;
+				break;
+			    case 2:
+				break;
+			    case 3:
+				swap_exists_action = SEA_RECOVER;
+				break;
+			    case 4:
+				swap_exists_action = SEA_QUIT;
+				break;
+			    case 5:
+				swap_exists_action = SEA_QUIT;
+				got_int = TRUE;
+				break;
+			    case 6:
+				mch_remove(fname);
+				break;
+			}
+			vim_free(name);
+
+			/* pretend screen didn't scroll, need redraw anyway */
+			msg_scrolled = 0;
+			redraw_all_later(NOT_VALID);
+
+			/* If the file was deleted this fname can be used. */
+			if (mch_getperm(fname) < 0)
+			    break;
+		    }
+		    else
+#endif
+		    {
+			MSG_PUTS("\n");
+			need_wait_return = TRUE; /* call wait_return later */
+		    }
+
+#ifdef CREATE_DUMMY_FILE
+		    /* Going to try another name, need the dummy file again. */
+		    if (did_use_dummy)
+			dummyfd = mch_fopen((char *)buf->b_fname, "w");
+#endif
+		}
+	    }
+	}
+
+	/*
+	 * Change the ".swp" extension to find another file that can be used.
+	 * First decrement the last char: ".swo", ".swn", etc.
+	 * If that still isn't enough decrement the last but one char: ".svz"
+	 * Can happen when editing many "No File" buffers.
+	 */
+	if (fname[n - 1] == 'a')	/* ".s?a" */
+	{
+	    if (fname[n - 2] == 'a')    /* ".saa": tried enough, give up */
+	    {
+		EMSG(_("E326: Too many swap files found"));
+		vim_free(fname);
+		fname = NULL;
+		break;
+	    }
+	    --fname[n - 2];		/* ".svz", ".suz", etc. */
+	    fname[n - 1] = 'z' + 1;
+	}
+	--fname[n - 1];			/* ".swo", ".swn", etc. */
+    }
+
+    vim_free(dir_name);
+#ifdef CREATE_DUMMY_FILE
+    if (dummyfd != NULL)	/* file has been created temporarily */
+    {
+	fclose(dummyfd);
+	mch_remove(buf->b_fname);
+    }
+#endif
+    return fname;
+}
+
+    static int
+b0_magic_wrong(b0p)
+    ZERO_BL *b0p;
+{
+    return (b0p->b0_magic_long != (long)B0_MAGIC_LONG
+	    || b0p->b0_magic_int != (int)B0_MAGIC_INT
+	    || b0p->b0_magic_short != (short)B0_MAGIC_SHORT
+	    || b0p->b0_magic_char != B0_MAGIC_CHAR);
+}
+
+#ifdef CHECK_INODE
+/*
+ * Compare current file name with file name from swap file.
+ * Try to use inode numbers when possible.
+ * Return non-zero when files are different.
+ *
+ * When comparing file names a few things have to be taken into consideration:
+ * - When working over a network the full path of a file depends on the host.
+ *   We check the inode number if possible.  It is not 100% reliable though,
+ *   because the device number cannot be used over a network.
+ * - When a file does not exist yet (editing a new file) there is no inode
+ *   number.
+ * - The file name in a swap file may not be valid on the current host.  The
+ *   "~user" form is used whenever possible to avoid this.
+ *
+ * This is getting complicated, let's make a table:
+ *
+ *		ino_c  ino_s  fname_c  fname_s	differ =
+ *
+ * both files exist -> compare inode numbers:
+ *		!= 0   != 0	X	 X	ino_c != ino_s
+ *
+ * inode number(s) unknown, file names available -> compare file names
+ *		== 0	X	OK	 OK	fname_c != fname_s
+ *		 X     == 0	OK	 OK	fname_c != fname_s
+ *
+ * current file doesn't exist, file for swap file exist, file name(s) not
+ * available -> probably different
+ *		== 0   != 0    FAIL	 X	TRUE
+ *		== 0   != 0	X	FAIL	TRUE
+ *
+ * current file exists, inode for swap unknown, file name(s) not
+ * available -> probably different
+ *		!= 0   == 0    FAIL	 X	TRUE
+ *		!= 0   == 0	X	FAIL	TRUE
+ *
+ * current file doesn't exist, inode for swap unknown, one file name not
+ * available -> probably different
+ *		== 0   == 0    FAIL	 OK	TRUE
+ *		== 0   == 0	OK	FAIL	TRUE
+ *
+ * current file doesn't exist, inode for swap unknown, both file names not
+ * available -> probably same file
+ *		== 0   == 0    FAIL	FAIL	FALSE
+ *
+ * Note that when the ino_t is 64 bits, only the last 32 will be used.  This
+ * can't be changed without making the block 0 incompatible with 32 bit
+ * versions.
+ */
+
+    static int
+fnamecmp_ino(fname_c, fname_s, ino_block0)
+    char_u	*fname_c;	    /* current file name */
+    char_u	*fname_s;	    /* file name from swap file */
+    long	ino_block0;
+{
+    struct stat	st;
+    ino_t	ino_c = 0;	    /* ino of current file */
+    ino_t	ino_s;		    /* ino of file from swap file */
+    char_u	buf_c[MAXPATHL];    /* full path of fname_c */
+    char_u	buf_s[MAXPATHL];    /* full path of fname_s */
+    int		retval_c;	    /* flag: buf_c valid */
+    int		retval_s;	    /* flag: buf_s valid */
+
+    if (mch_stat((char *)fname_c, &st) == 0)
+	ino_c = (ino_t)st.st_ino;
+
+    /*
+     * First we try to get the inode from the file name, because the inode in
+     * the swap file may be outdated.  If that fails (e.g. this path is not
+     * valid on this machine), use the inode from block 0.
+     */
+    if (mch_stat((char *)fname_s, &st) == 0)
+	ino_s = (ino_t)st.st_ino;
+    else
+	ino_s = (ino_t)ino_block0;
+
+    if (ino_c && ino_s)
+	return (ino_c != ino_s);
+
+    /*
+     * One of the inode numbers is unknown, try a forced vim_FullName() and
+     * compare the file names.
+     */
+    retval_c = vim_FullName(fname_c, buf_c, MAXPATHL, TRUE);
+    retval_s = vim_FullName(fname_s, buf_s, MAXPATHL, TRUE);
+    if (retval_c == OK && retval_s == OK)
+	return (STRCMP(buf_c, buf_s) != 0);
+
+    /*
+     * Can't compare inodes or file names, guess that the files are different,
+     * unless both appear not to exist at all.
+     */
+    if (ino_s == 0 && ino_c == 0 && retval_c == FAIL && retval_s == FAIL)
+	return FALSE;
+    return TRUE;
+}
+#endif /* CHECK_INODE */
+
+/*
+ * Move a long integer into a four byte character array.
+ * Used for machine independency in block zero.
+ */
+    static void
+long_to_char(n, s)
+    long    n;
+    char_u  *s;
+{
+    s[0] = (char_u)(n & 0xff);
+    n = (unsigned)n >> 8;
+    s[1] = (char_u)(n & 0xff);
+    n = (unsigned)n >> 8;
+    s[2] = (char_u)(n & 0xff);
+    n = (unsigned)n >> 8;
+    s[3] = (char_u)(n & 0xff);
+}
+
+    static long
+char_to_long(s)
+    char_u  *s;
+{
+    long    retval;
+
+    retval = s[3];
+    retval <<= 8;
+    retval |= s[2];
+    retval <<= 8;
+    retval |= s[1];
+    retval <<= 8;
+    retval |= s[0];
+
+    return retval;
+}
+
+    void
+ml_setdirty(buf, flag)
+    buf_T	*buf;
+    int		flag;
+{
+    bhdr_T	*hp;
+    ZERO_BL	*b0p;
+
+    if (!buf->b_ml.ml_mfp)
+	return;
+    for (hp = buf->b_ml.ml_mfp->mf_used_last; hp != NULL; hp = hp->bh_prev)
+    {
+	if (hp->bh_bnum == 0)
+	{
+	    b0p = (ZERO_BL *)(hp->bh_data);
+	    b0p->b0_dirty = flag ? 0x55 : 0;
+	    hp->bh_flags |= BH_DIRTY;
+	    mf_sync(buf->b_ml.ml_mfp, MFS_ZERO);
+	    break;
+	}
+    }
+}
+
+#if defined(FEAT_BYTEOFF) || defined(PROTO)
+
+#define MLCS_MAXL 800	/* max no of lines in chunk */
+#define MLCS_MINL 400   /* should be half of MLCS_MAXL */
+
+/*
+ * Keep information for finding byte offset of a line, updtytpe may be one of:
+ * ML_CHNK_ADDLINE: Add len to parent chunk, possibly splitting it
+ *	   Careful: ML_CHNK_ADDLINE may cause ml_find_line() to be called.
+ * ML_CHNK_DELLINE: Subtract len from parent chunk, possibly deleting it
+ * ML_CHNK_UPDLINE: Add len to parent chunk, as a signed entity.
+ */
+    static void
+ml_updatechunk(buf, line, len, updtype)
+    buf_T	*buf;
+    linenr_T	line;
+    long	len;
+    int		updtype;
+{
+    static buf_T	*ml_upd_lastbuf = NULL;
+    static linenr_T	ml_upd_lastline;
+    static linenr_T	ml_upd_lastcurline;
+    static int		ml_upd_lastcurix;
+
+    linenr_T		curline = ml_upd_lastcurline;
+    int			curix = ml_upd_lastcurix;
+    long		size;
+    chunksize_T		*curchnk;
+    int			rest;
+    bhdr_T		*hp;
+    DATA_BL		*dp;
+
+    if (buf->b_ml.ml_usedchunks == -1 || len == 0)
+	return;
+    if (buf->b_ml.ml_chunksize == NULL)
+    {
+	buf->b_ml.ml_chunksize = (chunksize_T *)
+				  alloc((unsigned)sizeof(chunksize_T) * 100);
+	if (buf->b_ml.ml_chunksize == NULL)
+	{
+	    buf->b_ml.ml_usedchunks = -1;
+	    return;
+	}
+	buf->b_ml.ml_numchunks = 100;
+	buf->b_ml.ml_usedchunks = 1;
+	buf->b_ml.ml_chunksize[0].mlcs_numlines = 1;
+	buf->b_ml.ml_chunksize[0].mlcs_totalsize = 1;
+    }
+
+    if (updtype == ML_CHNK_UPDLINE && buf->b_ml.ml_line_count == 1)
+    {
+	/*
+	 * First line in empty buffer from ml_flush_line() -- reset
+	 */
+	buf->b_ml.ml_usedchunks = 1;
+	buf->b_ml.ml_chunksize[0].mlcs_numlines = 1;
+	buf->b_ml.ml_chunksize[0].mlcs_totalsize =
+				  (long)STRLEN(buf->b_ml.ml_line_ptr) + 1;
+	return;
+    }
+
+    /*
+     * Find chunk that our line belongs to, curline will be at start of the
+     * chunk.
+     */
+    if (buf != ml_upd_lastbuf || line != ml_upd_lastline + 1
+	    || updtype != ML_CHNK_ADDLINE)
+    {
+	for (curline = 1, curix = 0;
+	     curix < buf->b_ml.ml_usedchunks - 1
+	     && line >= curline + buf->b_ml.ml_chunksize[curix].mlcs_numlines;
+	     curix++)
+	{
+	    curline += buf->b_ml.ml_chunksize[curix].mlcs_numlines;
+	}
+    }
+    else if (line >= curline + buf->b_ml.ml_chunksize[curix].mlcs_numlines
+		 && curix < buf->b_ml.ml_usedchunks - 1)
+    {
+	/* Adjust cached curix & curline */
+	curline += buf->b_ml.ml_chunksize[curix].mlcs_numlines;
+	curix++;
+    }
+    curchnk = buf->b_ml.ml_chunksize + curix;
+
+    if (updtype == ML_CHNK_DELLINE)
+	len *= -1;
+    curchnk->mlcs_totalsize += len;
+    if (updtype == ML_CHNK_ADDLINE)
+    {
+	curchnk->mlcs_numlines++;
+
+	/* May resize here so we don't have to do it in both cases below */
+	if (buf->b_ml.ml_usedchunks + 1 >= buf->b_ml.ml_numchunks)
+	{
+	    buf->b_ml.ml_numchunks = buf->b_ml.ml_numchunks * 3 / 2;
+	    buf->b_ml.ml_chunksize = (chunksize_T *)
+		vim_realloc(buf->b_ml.ml_chunksize,
+			    sizeof(chunksize_T) * buf->b_ml.ml_numchunks);
+	    if (buf->b_ml.ml_chunksize == NULL)
+	    {
+		/* Hmmmm, Give up on offset for this buffer */
+		buf->b_ml.ml_usedchunks = -1;
+		return;
+	    }
+	}
+
+	if (buf->b_ml.ml_chunksize[curix].mlcs_numlines >= MLCS_MAXL)
+	{
+	    int	    count;	    /* number of entries in block */
+	    int	    idx;
+	    int	    text_end;
+	    int	    linecnt;
+
+	    mch_memmove(buf->b_ml.ml_chunksize + curix + 1,
+			buf->b_ml.ml_chunksize + curix,
+			(buf->b_ml.ml_usedchunks - curix) *
+			sizeof(chunksize_T));
+	    /* Compute length of first half of lines in the splitted chunk */
+	    size = 0;
+	    linecnt = 0;
+	    while (curline < buf->b_ml.ml_line_count
+			&& linecnt < MLCS_MINL)
+	    {
+		if ((hp = ml_find_line(buf, curline, ML_FIND)) == NULL)
+		{
+		    buf->b_ml.ml_usedchunks = -1;
+		    return;
+		}
+		dp = (DATA_BL *)(hp->bh_data);
+		count = (long)(buf->b_ml.ml_locked_high) -
+			(long)(buf->b_ml.ml_locked_low) + 1;
+		idx = curline - buf->b_ml.ml_locked_low;
+		curline = buf->b_ml.ml_locked_high + 1;
+		if (idx == 0)/* first line in block, text at the end */
+		    text_end = dp->db_txt_end;
+		else
+		    text_end = ((dp->db_index[idx - 1]) & DB_INDEX_MASK);
+		/* Compute index of last line to use in this MEMLINE */
+		rest = count - idx;
+		if (linecnt + rest > MLCS_MINL)
+		{
+		    idx += MLCS_MINL - linecnt - 1;
+		    linecnt = MLCS_MINL;
+		}
+		else
+		{
+		    idx = count - 1;
+		    linecnt += rest;
+		}
+		size += text_end - ((dp->db_index[idx]) & DB_INDEX_MASK);
+	    }
+	    buf->b_ml.ml_chunksize[curix].mlcs_numlines = linecnt;
+	    buf->b_ml.ml_chunksize[curix + 1].mlcs_numlines -= linecnt;
+	    buf->b_ml.ml_chunksize[curix].mlcs_totalsize = size;
+	    buf->b_ml.ml_chunksize[curix + 1].mlcs_totalsize -= size;
+	    buf->b_ml.ml_usedchunks++;
+	    ml_upd_lastbuf = NULL;   /* Force recalc of curix & curline */
+	    return;
+	}
+	else if (buf->b_ml.ml_chunksize[curix].mlcs_numlines >= MLCS_MINL
+		     && curix == buf->b_ml.ml_usedchunks - 1
+		     && buf->b_ml.ml_line_count - line <= 1)
+	{
+	    /*
+	     * We are in the last chunk and it is cheap to crate a new one
+	     * after this. Do it now to avoid the loop above later on
+	     */
+	    curchnk = buf->b_ml.ml_chunksize + curix + 1;
+	    buf->b_ml.ml_usedchunks++;
+	    if (line == buf->b_ml.ml_line_count)
+	    {
+		curchnk->mlcs_numlines = 0;
+		curchnk->mlcs_totalsize = 0;
+	    }
+	    else
+	    {
+		/*
+		 * Line is just prior to last, move count for last
+		 * This is the common case  when loading a new file
+		 */
+		hp = ml_find_line(buf, buf->b_ml.ml_line_count, ML_FIND);
+		if (hp == NULL)
+		{
+		    buf->b_ml.ml_usedchunks = -1;
+		    return;
+		}
+		dp = (DATA_BL *)(hp->bh_data);
+		if (dp->db_line_count == 1)
+		    rest = dp->db_txt_end - dp->db_txt_start;
+		else
+		    rest =
+			((dp->db_index[dp->db_line_count - 2]) & DB_INDEX_MASK)
+			- dp->db_txt_start;
+		curchnk->mlcs_totalsize = rest;
+		curchnk->mlcs_numlines = 1;
+		curchnk[-1].mlcs_totalsize -= rest;
+		curchnk[-1].mlcs_numlines -= 1;
+	    }
+	}
+    }
+    else if (updtype == ML_CHNK_DELLINE)
+    {
+	curchnk->mlcs_numlines--;
+	ml_upd_lastbuf = NULL;   /* Force recalc of curix & curline */
+	if (curix < (buf->b_ml.ml_usedchunks - 1)
+		&& (curchnk->mlcs_numlines + curchnk[1].mlcs_numlines)
+		   <= MLCS_MINL)
+	{
+	    curix++;
+	    curchnk = buf->b_ml.ml_chunksize + curix;
+	}
+	else if (curix == 0 && curchnk->mlcs_numlines <= 0)
+	{
+	    buf->b_ml.ml_usedchunks--;
+	    mch_memmove(buf->b_ml.ml_chunksize, buf->b_ml.ml_chunksize + 1,
+			buf->b_ml.ml_usedchunks * sizeof(chunksize_T));
+	    return;
+	}
+	else if (curix == 0 || (curchnk->mlcs_numlines > 10
+		    && (curchnk->mlcs_numlines + curchnk[-1].mlcs_numlines)
+		       > MLCS_MINL))
+	{
+	    return;
+	}
+
+	/* Collapse chunks */
+	curchnk[-1].mlcs_numlines += curchnk->mlcs_numlines;
+	curchnk[-1].mlcs_totalsize += curchnk->mlcs_totalsize;
+	buf->b_ml.ml_usedchunks--;
+	if (curix < buf->b_ml.ml_usedchunks)
+	{
+	    mch_memmove(buf->b_ml.ml_chunksize + curix,
+			buf->b_ml.ml_chunksize + curix + 1,
+			(buf->b_ml.ml_usedchunks - curix) *
+			sizeof(chunksize_T));
+	}
+	return;
+    }
+    ml_upd_lastbuf = buf;
+    ml_upd_lastline = line;
+    ml_upd_lastcurline = curline;
+    ml_upd_lastcurix = curix;
+}
+
+/*
+ * Find offset for line or line with offset.
+ * Find line with offset if line is 0; return remaining offset in offp
+ * Find offset of line if line > 0
+ * return -1 if information is not available
+ */
+    long
+ml_find_line_or_offset(buf, line, offp)
+    buf_T	*buf;
+    linenr_T	line;
+    long	*offp;
+{
+    linenr_T	curline;
+    int		curix;
+    long	size;
+    bhdr_T	*hp;
+    DATA_BL	*dp;
+    int		count;		/* number of entries in block */
+    int		idx;
+    int		start_idx;
+    int		text_end;
+    long	offset;
+    int		len;
+    int		ffdos = (get_fileformat(buf) == EOL_DOS);
+    int		extra = 0;
+
+    if (buf->b_ml.ml_usedchunks == -1
+	    || buf->b_ml.ml_chunksize == NULL
+	    || line < 0)
+	return -1;
+
+    if (offp == NULL)
+	offset = 0;
+    else
+	offset = *offp;
+    if (line == 0 && offset <= 0)
+	return 1;   /* Not a "find offset" and offset 0 _must_ be in line 1 */
+    /*
+     * Find the last chunk before the one containing our line. Last chunk is
+     * special because it will never qualify
+     */
+    curline = 1;
+    curix = size = 0;
+    while (curix < buf->b_ml.ml_usedchunks - 1
+	    && ((line != 0
+	     && line >= curline + buf->b_ml.ml_chunksize[curix].mlcs_numlines)
+		|| (offset != 0
+	       && offset > size + buf->b_ml.ml_chunksize[curix].mlcs_totalsize
+		      + ffdos * buf->b_ml.ml_chunksize[curix].mlcs_numlines)))
+    {
+	curline += buf->b_ml.ml_chunksize[curix].mlcs_numlines;
+	size += buf->b_ml.ml_chunksize[curix].mlcs_totalsize;
+	if (offset && ffdos)
+	    size += buf->b_ml.ml_chunksize[curix].mlcs_numlines;
+	curix++;
+    }
+
+    while ((line != 0 && curline < line) || (offset != 0 && size < offset))
+    {
+	if (curline > buf->b_ml.ml_line_count
+		|| (hp = ml_find_line(buf, curline, ML_FIND)) == NULL)
+	    return -1;
+	dp = (DATA_BL *)(hp->bh_data);
+	count = (long)(buf->b_ml.ml_locked_high) -
+		(long)(buf->b_ml.ml_locked_low) + 1;
+	start_idx = idx = curline - buf->b_ml.ml_locked_low;
+	if (idx == 0)/* first line in block, text at the end */
+	    text_end = dp->db_txt_end;
+	else
+	    text_end = ((dp->db_index[idx - 1]) & DB_INDEX_MASK);
+	/* Compute index of last line to use in this MEMLINE */
+	if (line != 0)
+	{
+	    if (curline + (count - idx) >= line)
+		idx += line - curline - 1;
+	    else
+		idx = count - 1;
+	}
+	else
+	{
+	    extra = 0;
+	    while (offset >= size
+		       + text_end - (int)((dp->db_index[idx]) & DB_INDEX_MASK)
+								      + ffdos)
+	    {
+		if (ffdos)
+		    size++;
+		if (idx == count - 1)
+		{
+		    extra = 1;
+		    break;
+		}
+		idx++;
+	    }
+	}
+	len = text_end - ((dp->db_index[idx]) & DB_INDEX_MASK);
+	size += len;
+	if (offset != 0 && size >= offset)
+	{
+	    if (size + ffdos == offset)
+		*offp = 0;
+	    else if (idx == start_idx)
+		*offp = offset - size + len;
+	    else
+		*offp = offset - size + len
+		     - (text_end - ((dp->db_index[idx - 1]) & DB_INDEX_MASK));
+	    curline += idx - start_idx + extra;
+	    if (curline > buf->b_ml.ml_line_count)
+		return -1;	/* exactly one byte beyond the end */
+	    return curline;
+	}
+	curline = buf->b_ml.ml_locked_high + 1;
+    }
+
+    if (ffdos)
+	size += line - 1;
+    return size;
+}
+
+/*
+ * Goto byte in buffer with offset 'cnt'.
+ */
+    void
+goto_byte(cnt)
+    long	cnt;
+{
+    long	boff = cnt;
+    linenr_T	lnum;
+
+    ml_flush_line(curbuf);	/* cached line may be dirty */
+    setpcmark();
+    if (boff)
+	--boff;
+    lnum = ml_find_line_or_offset(curbuf, (linenr_T)0, &boff);
+    if (lnum < 1)	/* past the end */
+    {
+	curwin->w_cursor.lnum = curbuf->b_ml.ml_line_count;
+	curwin->w_curswant = MAXCOL;
+	coladvance((colnr_T)MAXCOL);
+    }
+    else
+    {
+	curwin->w_cursor.lnum = lnum;
+	curwin->w_cursor.col = (colnr_T)boff;
+	curwin->w_set_curswant = TRUE;
+    }
+    check_cursor();
+
+# ifdef FEAT_MBYTE
+    /* Make sure the cursor is on the first byte of a multi-byte char. */
+    if (has_mbyte)
+	mb_adjust_cursor();
+# endif
+}
+#endif