Initial import of vim 4.2.

This is meant to replace nvi in the tree.  Vim, in general, works better,
provides more features, and does not suffer from the license problems
being imposed upon nvi.

On the other hand, vim lacks a non-visual ex mode, in addition to open mode.

This includes the GUI (X11) code, but doesn't try to compile it.

1 files changed, 3383 insertions, 0 deletions

diff --git a/usr.bin/vim/memline.c b/usr.bin/vim/memline.c
new file mode 100644
index 00000000000..79d045b73e7
--- /dev/null
+++ b/usr.bin/vim/memline.c
@@ -0,0 +1,3383 @@
+/*	$OpenBSD: memline.c,v 1.1 1996/09/07 21:40:25 downsj Exp $	*/
+/* vi:set ts=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.
+ */
+
+/* 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().
+ */
+
+/*
+ * The following functions are available to work with a memline:
+ * 
+ * ml_open()			open a new memline for a buffer
+ * ml_setname()			change the file name for a memline
+ * ml_close()			close the memline for a buffer
+ * ml_close_all()		close all memlines
+ * ml_recover()			read a memline for recovery
+ * ml_sync_all()		flush changed blocks to file for all files
+ * ml_preserve()		flush everything into the file for one file
+ * ml_get()				get a pointer to a line
+ * ml_get_pos()			get a pointer to a position in a line
+ * ml_get_cursor()		get a pointer to the char under the cursor
+ * ml_get_buf()			get a pointer to a line in a specific buffer
+ * ml_line_alloced()	return TRUE if line was allocated
+ * ml_append()			append a new line
+ * ml_replace()			replace a line
+ * ml_delete()			delete a line
+ * ml_setmarked()		set mark for a line (for :global command)
+ * ml_firstmarked()		get first line with a mark (for :global command)
+ * ml_clearmarked()		clear all line marks (for :global command)
+ */
+
+#if defined MSDOS  ||  defined WIN32
+# include <io.h>
+#endif
+
+#include "vim.h"
+#include "globals.h"
+#include "proto.h"
+#include "option.h"
+#ifdef HAVE_FCNTL_H
+# include <fcntl.h>
+#endif
+#ifndef UNIX			/* it's in 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	0x30313233
+#define B0_MAGIC_INT	0x20212223
+#define B0_MAGIC_SHORT	0x10111213
+#define B0_MAGIC_CHAR	0x55
+
+/*
+ * Block zero holds all info about the swap file.
+ *
+ * NOTE: DEFINITION OF BLOCK 0 SHOULD NOT CHANGE, it makes all existing swap
+ * files unusable!
+ * 
+ * If size of block0 changes anyway, adjust minimal block size
+ * in mf_open()!!
+ *
+ * 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 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 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 ml_open_file __ARGS((BUF *));
+static void set_b0_fname __ARGS((ZERO_BL *, BUF *buf));
+static void swapfile_info __ARGS((char_u *));
+static int get_names __ARGS((char_u **, char_u *));
+static int ml_append_int __ARGS((BUF *, linenr_t, char_u *, colnr_t, int));
+static int ml_delete_int __ARGS((BUF *, linenr_t, int));
+static char_u *findswapname __ARGS((BUF *, char_u **, char_u *));
+static void ml_flush_line __ARGS((BUF *));
+static BHDR *ml_new_data __ARGS((MEMFILE *, int, int));
+static BHDR *ml_new_ptr __ARGS((MEMFILE *));
+static BHDR *ml_find_line __ARGS((BUF *, linenr_t, int));
+static int ml_add_stack __ARGS((BUF *));
+static char_u *makeswapname __ARGS((BUF *, char_u *));
+static void ml_lineadd __ARGS((BUF *, 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 *));
+
+/*
+ * open a new memline for 'curbuf'
+ *
+ * return FAIL for failure, OK otherwise
+ */
+	int
+ml_open()
+{
+	MEMFILE		*mfp;
+	char_u		*fname;
+	BHDR		*hp = NULL;
+	ZERO_BL		*b0p;
+	PTR_BL		*pp;
+	DATA_BL		*dp;
+	char_u		*dirp;
+
+/*
+ * 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 */
+
+/*
+ * Make file name for swap file.
+ * 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).
+ * When 'updatecount' is 0 and for help files on Unix there is never a swap
+ * file.
+ */
+#if defined(UNIX) || defined(__EMX__)
+/* why only on Unix an exception for help files??? */
+	if (p_uc == 0 || curbuf->b_help)
+#else
+	if (p_uc == 0)
+#endif
+		dirp = (char_u *)"";
+	else
+		dirp = p_dir;
+	
+/*
+ * Open the memfile.
+ *
+ * If no swap file is wanted *dirp will be NUL, try with fname == NULL.
+ * Otherwise try all directories in 'directory' option. If that fails try
+ * with fname == NULL.
+ */
+	for (;;)
+	{
+		if (*dirp == NUL)
+			fname = NULL;
+		else
+		{
+			fname = findswapname(curbuf, &dirp, NULL);
+			if (fname == NULL)
+				continue;
+		}
+		mfp = mf_open(fname, TRUE);
+		/* stop when memfile opened or no other fname to try */
+		if (mfp != NULL || (fname == NULL && *dirp == NUL))
+			break;
+		vim_free(fname);
+	}
+
+	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 (!(p_uc == 0 || curbuf->b_help) && mfp->mf_fname == NULL)
+	{
+		need_wait_return = TRUE;		/* call wait_return later */
+		++no_wait_return;
+		(void)EMSG("Unable to open swap file, recovery impossible");
+		--no_wait_return;
+	}
+#if defined(MSDOS) || defined(WIN32)
+	/*
+	 * set full pathname for swap file now, because a ":!cd dir" may
+	 * change directory without us knowing it.
+	 */
+	mf_fullname(mfp);
+#endif
+
+/*
+ * fill block0 struct and write page 0
+ */
+	if ((hp = mf_new(mfp, FALSE, 1)) == NULL)
+		goto error;
+	if (hp->bh_bnum != 0)
+	{
+		EMSG("didn't get block nr 0?");
+		goto error;
+	}
+	b0p = (ZERO_BL *)(hp->bh_data);
+
+	(void)vim_memset(b0p, 0, sizeof(ZERO_BL));		/* init all to zero */
+
+	b0p->b0_id[0] = BLOCK0_ID0;
+	b0p->b0_id[1] = BLOCK0_ID1;
+	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, Version, 10);
+	set_b0_fname(b0p, curbuf);
+	long_to_char((long)mfp->mf_page_size, b0p->b0_page_size);
+	(void)mch_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.
+	 */
+	mf_put(mfp, hp, TRUE, FALSE);
+	if (!curbuf->b_help)
+		mf_sync(mfp, FALSE, FALSE, FALSE);
+
+/*
+ * fill in root pointer block and write page 1
+ */
+	if ((hp = ml_new_ptr(mfp)) == NULL)
+		goto error;
+	if (hp->bh_bnum != 1)
+	{
+		EMSG("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("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) */
+	}
+	else
+		vim_free(fname);
+	curbuf->b_ml.ml_mfp = NULL;
+	return FAIL;
+}
+
+/*
+ * ml_setname() is called when the file name has been changed.
+ * It may rename the swap file.
+ */
+	void
+ml_setname()
+{
+	int			success = FALSE;
+	MEMFILE		*mfp;
+	char_u		*fname;
+	char_u		*dirp;
+
+/*
+ * When 'updatecount' is 0 there is never a swap file.
+ * For help files we will make a swap file now.
+ */
+	if (p_uc == 0)
+		return;
+
+	mfp = curbuf->b_ml.ml_mfp;
+	if (mfp->mf_fd < 0)				/* there is no swap file yet */
+	{
+		ml_open_file(curbuf);		/* 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(curbuf, &dirp, mfp->mf_fname);
+		if (fname == NULL)			/* no file name found for this dir */
+			continue;
+
+#if defined(MSDOS) || defined(WIN32)
+		/*
+		 * Set full pathname for swap file now, because a ":!cd dir" may
+		 * change directory without us knowing it.
+		 */
+		if (!did_cd)
+		{
+			char_u		*p;
+
+			p = FullName_save(fname);
+			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_xfname);
+			mf_set_xfname(mfp);
+			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 = open((char *)mfp->mf_fname, O_RDWR | O_EXTRA);
+		if (mfp->mf_fd < 0)
+		{
+			/* could not (re)open the swap file, what can we do???? */
+			EMSG("Oops, lost the swap file!!!");
+			return;
+		}
+	}
+	if (!success)
+		EMSG("Could not rename swap file");
+}
+
+/*
+ * Open a file for the memfile for all buffers.
+ * Used when 'updatecount' changes from zero to non-zero.
+ */
+	void
+ml_open_files()
+{
+	BUF			*buf;
+
+	for (buf = firstbuf; buf != NULL; buf = buf->b_next)
+		ml_open_file(buf);
+}
+
+/*
+ * Open a swap file for an existing memfile, if there is non swap file yet.
+ */
+	static void
+ml_open_file(buf)
+	BUF			*buf;
+{
+	MEMFILE		*mfp;
+	char_u		*fname;
+	char_u		*dirp;
+
+	mfp = buf->b_ml.ml_mfp;
+	if (mfp == NULL || mfp->mf_fd >= 0)			/* nothing to do */
+		return;
+
+	dirp = p_dir;
+/*
+ * Try all directories in 'directory' option.
+ */
+	for (;;)
+	{
+		if (*dirp == NUL)
+			break;
+		fname = findswapname(buf, &dirp, NULL);
+		if (fname == NULL)
+			continue;
+		if (mf_open_file(mfp, fname) == OK)
+			break;
+		vim_free(fname);
+	}
+
+	if (mfp->mf_fname == NULL)			/* Failed! */
+	{
+		need_wait_return = TRUE;		/* call wait_return later */
+		++no_wait_return;
+		(void)EMSG2("Unable to open swap file for \"%s\", recovery impossible",
+				buf->b_xfilename == NULL ? (char_u *)"No File"
+										 : buf->b_xfilename);
+		--no_wait_return;
+	}
+#if defined(MSDOS) || defined(WIN32)
+	/*
+	 * set full pathname for swap file now, because a ":!cd dir" may
+	 * change directory without us knowing it.
+	 */
+	else
+		mf_fullname(mfp);
+#endif
+}
+
+/*
+ * Close memline for buffer 'buf'.
+ * If 'del_file' is TRUE, delete the swap file
+ */
+	void
+ml_close(buf, del_file)
+	BUF		*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);
+	buf->b_ml.ml_mfp = NULL;
+}
+
+/*
+ * Close all existing memlines and memfiles.
+ * Used when exiting.
+ * When 'del_file' is TRUE, delete the memfiles.
+ */
+	void
+ml_close_all(del_file)
+	int		del_file;
+{
+	BUF		*buf;
+
+	for (buf = firstbuf; buf != NULL; buf = buf->b_next)
+		ml_close(buf, del_file);
+}
+
+/*
+ * Close all memfiles for not modified buffers.
+ * Only use just before exiting!
+ */
+	void
+ml_close_notmod()
+{
+	BUF		*buf;
+
+	for (buf = firstbuf; buf != NULL; buf = buf->b_next)
+		if (!buf->b_changed)
+			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			*buf;
+{
+	MEMFILE		*mfp;
+	BHDR		*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("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			*buf;
+{
+	struct stat	st;
+	size_t		flen, ulen;
+	char_u		uname[B0_UNAME_SIZE];
+
+	if (buf->b_filename == NULL)
+		b0p->b0_fname[0] = NUL;
+	else
+	{
+		/*
+		 * 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_filename, b0p->b0_fname, B0_FNAME_SIZE);
+		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 (mch_get_user_name(uname, B0_UNAME_SIZE) == FAIL ||
+						 (ulen = STRLEN(uname)) + flen > B0_FNAME_SIZE - 1)
+				STRNCPY(b0p->b0_fname, buf->b_filename, B0_FNAME_SIZE);
+			else
+			{
+				vim_memmove(b0p->b0_fname + ulen + 1, b0p->b0_fname + 1, flen);
+				vim_memmove(b0p->b0_fname + 1, uname, ulen);
+			}
+		}
+		if (stat((char *)buf->b_filename, &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->b_mtime = st.st_mtime;
+			buf->b_mtime_read = st.st_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;
+		}
+	}
+}
+
+/*
+ * try to recover curbuf from the .swp file
+ */
+	void
+ml_recover()
+{
+	BUF			*buf = NULL;
+	MEMFILE		*mfp = NULL;
+	char_u		*fname;
+	BHDR		*hp = NULL;
+	ZERO_BL		*b0p;
+	PTR_BL		*pp;
+	DATA_BL		*dp;
+	IPTR		*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;
+	long		size;
+	int			called_from_main;
+	int			serious_error = TRUE;
+	long		mtime;
+
+	called_from_main = (curbuf->b_ml.ml_mfp == NULL);
+/*
+ * 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_xfilename;
+	if (fname == NULL)				/* When there is no file name */
+		fname = (char_u *)"";
+	len = STRLEN(fname);
+	if (len >= 4 && vim_strnicmp(fname + len - 4,
+									(char_u *)".sw", (size_t)3) == 0)
+	{
+		directly = TRUE;
+		fname = 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("No swap file found for %s", fname);
+			fname = NULL;
+			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_outchar('\n');
+			MSG_OUTSTR("Enter number of swap file to use (0 to quit): ");
+			i = get_number();
+			if (i < 1 || i > len)
+			{
+				fname = NULL;
+				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 *)alloc((unsigned)sizeof(BUF));
+	if (buf == NULL)
+		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
+ */
+	mfp = mf_open(fname, FALSE);
+	if (mfp == NULL || mfp->mf_fd < 0)
+	{
+		EMSG2("Cannot open %s", fname);
+		goto theend;
+	}
+	buf->b_ml.ml_mfp = mfp;
+#if defined(MSDOS) || defined(WIN32)
+	/*
+	 * set full pathname for swap file now, because a ":!cd dir" may
+	 * change directory without us knowing it.
+	 * Careful: May free fname!
+	 */
+	mf_fullname(mfp);
+#endif
+
+/*
+ * try to read block 0
+ */
+	if ((hp = mf_get(mfp, (blocknr_t)0, 1)) == NULL)
+	{
+		msg_start();
+		MSG_OUTSTR("Unable to read block 0 from ");
+		msg_outtrans(mfp->mf_fname);
+		MSG_OUTSTR("\nMaybe no changes were made or Vim did not update the swap file");
+		msg_end();
+		goto theend;
+	}
+	b0p = (ZERO_BL *)(hp->bh_data);
+	if (b0p->b0_id[0] != BLOCK0_ID0 || b0p->b0_id[1] != BLOCK0_ID1)
+	{
+		EMSG2("%s is not a swap file", mfp->mf_fname);
+		goto theend;
+	}
+	if (b0_magic_wrong(b0p))
+	{
+		msg_start();
+		MSG_OUTSTR("The file ");
+		msg_outtrans(mfp->mf_fname);
+#if defined(MSDOS) || defined(WIN32)
+		if (STRNCMP(b0p->b0_hname, "PC ", 3) == 0)
+			MSG_OUTSTR(" cannot be used with this version of Vim.\n");
+		else
+#endif
+			MSG_OUTSTR(" cannot be used on this computer.\n");
+		MSG_OUTSTR("The file was created on ");
+				/* avoid going past the end of currupted hostname */
+		b0p->b0_fname[0] = NUL;
+		MSG_OUTSTR(b0p->b0_hname);
+		MSG_OUTSTR(",\nor the file has been damaged.");
+		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))
+	{
+		mfp->mf_page_size = (unsigned)char_to_long(b0p->b0_page_size);
+		if ((size = lseek(mfp->mf_fd, 0L, SEEK_END)) <= 0)
+			mfp->mf_blocknr_max = 0;		/* no file or empty file */
+		else
+			mfp->mf_blocknr_max = 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(NameBuff, NULL, TRUE) == FAIL)
+			goto theend;
+	}
+
+	home_replace(NULL, mfp->mf_fname, NameBuff, MAXPATHL);
+	smsg((char_u *)"Using swap file \"%s\"", NameBuff);
+
+	if (curbuf->b_filename == NULL)
+		STRCPY(NameBuff, "No File");
+	else
+		home_replace(NULL, curbuf->b_filename, NameBuff, MAXPATHL);
+	smsg((char_u *)"Original file \"%s\"", NameBuff);
+	msg_outchar((char_u)'\n');
+
+/*
+ * check date of swap file and original file
+ */
+	mtime = char_to_long(b0p->b0_mtime);
+	if (curbuf->b_filename != NULL &&
+			stat((char *)curbuf->b_filename, &org_stat) != -1 &&
+			((stat((char *)mfp->mf_fname, &swp_stat) != -1 &&
+			org_stat.st_mtime > swp_stat.st_mtime) ||
+			org_stat.st_mtime != mtime))
+	{
+		EMSG("Warning: Original file may have been changed");
+	}
+	flushbuf();
+	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);
+
+	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_filename == 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("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_filename, NULL, lnum, FALSE,
+										pp->pb_pointer[idx].pe_old_lnum - 1,
+										line_count, FALSE) == 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("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);
+
+	recoverymode = FALSE;
+	if (got_int)
+		EMSG("Recovery Interrupted");
+	else if (error)
+		EMSG("Errors detected while recovering; look for lines starting with ???");
+	else
+	{
+		MSG("Recovery completed. You should check if everything is OK.");
+		MSG_OUTSTR("\n(You might want to write out this file under another name\n");
+		MSG_OUTSTR("and run diff with the original file to check for changes)\n");
+		MSG_OUTSTR("Delete the .swp file afterwards.\n\n");
+		cmdline_row = msg_row;
+	}
+
+theend:
+	if (mfp != NULL)
+	{
+		if (hp != NULL)
+			mf_put(mfp, hp, FALSE, FALSE);
+		mf_close(mfp, FALSE);		/* will also vim_free(mfp->mf_fname) */
+	}
+	else
+		vim_free(fname);
+	vim_free(buf);
+	if (serious_error && called_from_main)
+		ml_close(curbuf, TRUE);
+	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_outchar('\n');
+	}
+	expand_interactively = TRUE;
+	/*
+	 * Do the loop for every directory in 'directory'.
+	 */
+	dirp = p_dir;
+	while (*dirp)
+	{
+		/* find character after directory name */
+		dir_name = dirp;
+		while (*dirp && *dirp != ',')
+			++dirp;
+		dir_name = strnsave(dir_name, (int)(dirp - dir_name));
+		if (dir_name == NULL)		/* out of memory */
+			break;
+		if (*dir_name == '.')		/* check current dir */
+		{
+			if (fname == NULL || *fname == NULL)
+			{
+				names[0] = strsave((char_u *)"*.sw?");
+#ifdef UNIX
+					/* for Unix names starting with a dot are special */
+				names[1] = strsave((char_u *)".*.sw?");
+				names[2] = strsave((char_u *)".sw?");
+				num_names = 3;
+#else
+				num_names = 1;
+#endif
+			}
+			else
+				num_names = get_names(names, *fname);
+		}
+		else						/* check directory dir_name */
+		{
+			if (fname == NULL || *fname == NULL)
+			{
+				names[0] = concat_fnames(dir_name, (char_u *)"*.sw?", TRUE);
+#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
+				num_names = 1;
+#endif
+			}
+			else
+			{
+				tail = gettail(*fname);
+				tail = concat_fnames(dir_name, tail, TRUE);
+				if (tail == NULL)
+					num_names = 0;
+				else
+				{
+					num_names = get_names(names, tail);
+					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 (ExpandWildCards(num_names, names,
+									 &num_files, &files, TRUE, FALSE) == FAIL)
+		{
+			MSG_OUTSTR(files);		/* print error message */
+			num_files = 0;
+		}
+		/*
+		 * 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]) == FPC_SAME)
+				{
+					vim_free(files[i]);
+					--num_files;
+					for ( ; i < num_files; ++i)
+						files[i] = files[i + 1];
+					break;
+				}
+		}
+		if (nr)
+		{
+			file_count += num_files;
+			if (nr <= file_count)
+			{
+				*fname = strsave(files[nr - 1 + num_files - file_count]);
+				dirp = (char_u *)"";				/* stop searching */
+			}
+		}
+		else if (list)
+		{
+			if (*dir_name == '.')
+			{
+				if (fname == NULL || *fname == NULL)
+					MSG_OUTSTR("   In current directory:\n");
+				else
+					MSG_OUTSTR("   Using specified name:\n");
+			}
+			else
+			{
+				MSG_OUTSTR("   In directory ");
+				msg_home_replace(dir_name);
+				MSG_OUTSTR(":\n");
+			}
+
+			if (num_files)
+			{
+				for (i = 0; i < num_files; ++i)
+				{
+					/* print the swap file name */
+					msg_outnum((long)++file_count);
+					MSG_OUTSTR(".    ");
+					msg_outstr(gettail(files[i]));
+					msg_outchar('\n');
+					swapfile_info(files[i]);
+				}
+			}
+			else
+				MSG_OUTSTR("      -- none --\n");
+			flushbuf();
+		}
+		else
+			file_count += num_files;
+
+		for (i = 0; i < num_names; ++i)
+			vim_free(names[i]);
+		FreeWild(num_files, files);
+
+		/* advance dirp to next directory name */
+		vim_free(dir_name);
+		if (*dirp == ',')
+			++dirp;
+		dirp = skipwhite(dirp);
+	}
+	expand_interactively = FALSE;
+	return file_count;
+}
+
+/*
+ * Give information about an existing swap file
+ */
+	static void
+swapfile_info(fname)
+	char_u		*fname;
+{
+	struct stat		st;
+	int				fd;
+	struct block0	b0;
+	time_t			x;
+
+	/* print the swap file date */
+	if (stat((char *)fname, &st) != -1)
+	{
+		MSG_OUTSTR("             dated: ");
+		x = st.st_mtime;					/* Manx C can't do &st.st_mtime */
+		MSG_OUTSTR(ctime(&x));
+	}
+
+	/*
+	 * print the original file name
+	 */
+	fd = open((char *)fname, O_RDONLY | O_EXTRA);
+	if (fd >= 0)
+	{
+		if (read(fd, (char *)&b0, sizeof(b0)) == sizeof(b0))
+		{
+			if (b0.b0_id[0] != BLOCK0_ID0 ||
+								b0.b0_id[1] != BLOCK0_ID1)
+				MSG_OUTSTR("         [is not a swap file]");
+			else
+			{
+				MSG_OUTSTR("         file name: ");
+				msg_outstr(b0.b0_fname);
+
+				if (*(b0.b0_hname) != NUL)
+				{
+					MSG_OUTSTR("\n         host name: ");
+					msg_outstr(b0.b0_hname);
+				}
+
+				if (*(b0.b0_uname) != NUL)
+				{
+					MSG_OUTSTR("\n         user name: ");
+					msg_outstr(b0.b0_uname);
+				}
+
+				if (char_to_long(b0.b0_pid) != 0L)
+				{
+					MSG_OUTSTR("\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(char_to_long(b0.b0_pid), 0) == 0)
+						MSG_OUTSTR(" (still running)");
+#endif
+				}
+
+				if (b0_magic_wrong(&b0))
+				{
+#if defined(MSDOS) || defined(WIN32)
+					if (STRNCMP(b0.b0_hname, "PC ", 3) == 0)
+						MSG_OUTSTR("\n         [not usable with this version of Vim]");
+					else
+#endif
+						MSG_OUTSTR("\n         [not usable on this computer]");
+				}
+					
+			}
+		}
+		else
+			MSG_OUTSTR("         [cannot be read]");
+		close(fd);
+	}
+	else
+		MSG_OUTSTR("         [cannot be opened]");
+	msg_outchar('\n');
+}
+
+	static int
+get_names(names, fname)
+	char_u **names;
+	char_u	*fname;
+{
+	int		num_names;
+
+#ifdef SHORT_FNAME
+	/*
+	 * (MS-DOS) always short names
+	 */
+	names[0] = modname(fname, (char_u *)".sw?");
+	num_names = 1;
+#else /* !SHORT_FNAME */
+# ifdef WIN32
+	/*
+	 * (WIN32) never short names
+	 */
+	num_names = 1;
+	names[0] = concat_fnames(fname, (char_u *)".sw?", FALSE);
+# else /* !WIN32 */
+	/*
+	 * (Not MS-DOS or WIN32) maybe short name, maybe not: try both.
+	 * Only use the short name if it is different.
+	 */
+
+	int		i;
+
+	names[0] = concat_fnames(fname, (char_u *)".sw?", FALSE);
+	i = curbuf->b_shortname;
+	curbuf->b_shortname = TRUE;
+	names[1] = modname(fname, (char_u *)".sw?");
+	curbuf->b_shortname = i;
+	if (STRCMP(names[0], names[1]) == 0)
+	{
+		vim_free(names[1]);
+		num_names = 1;
+	}
+	else
+		num_names = 2;
+# endif /* !WIN32 */
+#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				*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 (buf->b_changed && check_file && mf_need_trans(buf->b_ml.ml_mfp) &&
+									buf->b_filename != NULL)
+		{
+			/*
+			 * if original file does not exist anymore or has been changed
+			 * call ml_preserve to get rid of all negative numbered blocks
+			 */
+			if (stat((char *)buf->b_filename, &st) == -1 ||
+								st.st_mtime != buf->b_mtime_read)
+			{
+				ml_preserve(buf, FALSE);
+				need_check_timestamps = TRUE;	/* give message later */
+			}
+		}
+		if (buf->b_ml.ml_mfp->mf_dirty)
+		{
+			mf_sync(buf->b_ml.ml_mfp, FALSE, check_char, buf->b_changed);
+			if (check_char && mch_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		*buf;
+	int		message;
+{
+	BHDR		*hp;
+	linenr_t	lnum;
+	MEMFILE		*mfp = buf->b_ml.ml_mfp;
+	int			status;
+
+	if (mfp == NULL || mfp->mf_fname == NULL)
+	{
+		if (message)
+			EMSG("Cannot preserve, there is no swap file");
+		return;
+	}
+
+	ml_flush_line(buf);								/* flush buffered line */
+	(void)ml_find_line(buf, (linenr_t)0, ML_FLUSH);	/* flush locked block */
+	status = mf_sync(mfp, TRUE, FALSE, TRUE);
+		
+			/* stack is invalid after mf_sync(.., TRUE, ..) */
+	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))
+	{
+		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 */
+		if (mf_sync(mfp, TRUE, FALSE, TRUE) == FAIL)	/* sync the updated pointer blocks */
+			status = FAIL;
+		buf->b_ml.ml_stack_top = 0;			/* stack is invalid now */
+	}
+theend:
+	if (message)
+	{
+		if (status == OK)
+			MSG("File preserved");
+		else
+			EMSG("Preserve failed");
+	}
+}
+
+/*
+ * 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)
+    FPOS	*pos;
+{
+	return (ml_get_buf(curbuf, pos->lnum, FALSE) + pos->col);
+}
+
+/*
+ * ml_get_pos: get pointer to cursor line.
+ */
+	char_u *
+ml_get_curline()
+{
+	return ml_get_buf(curbuf, curwin->w_cursor.lnum, FALSE);
+}
+
+/*
+ * ml_get_pos: 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			*buf;
+	linenr_t	lnum;
+	int			will_change;			/* line will be changed */
+{
+	BHDR	*hp;
+	DATA_BL	*dp;
+	char_u	*ptr;
+
+	if (lnum > buf->b_ml.ml_line_count)	/* invalid line number */
+	{
+		EMSGN("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
+		 * This also releases any locked block.
+		 */
+		if ((hp = ml_find_line(buf, lnum, ML_FIND)) == NULL)
+		{
+			EMSGN("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)
+ *
+ *   newfile: TRUE when starting to edit a new file, meaning that pe_old_lnum
+ *				will be set for recovery
+ *
+ * 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 */
+{
+ 	if (curbuf->b_ml.ml_line_lnum != 0)
+		ml_flush_line(curbuf);
+	return ml_append_int(curbuf, lnum, line, len, newfile);
+}
+
+	static int
+ml_append_int(buf, lnum, line, len, newfile)
+	BUF			*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			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		*hp;
+	MEMFILE		*mfp;
+	DATA_BL		*dp;
+	PTR_BL		*pp;
+	IPTR		*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 = 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);
+			vim_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
+		 */
+		vim_memmove((char *)dp + dp->db_index[db_idx + 1], line, (size_t)len);
+
+		/*
+		 * 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		*hp_left;
+		BHDR		*hp_right;
+		BHDR		*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;
+			vim_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;
+			vim_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;
+			vim_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("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
+			 */
+			if (pp->pb_count < pp->pb_count_max)	/* block not full, add one entry */
+			{
+				if (pb_idx + 1 < (int)pp->pb_count)
+					vim_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);
+				}
+
+				return OK;
+			}
+			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
+					 */
+					vim_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)
+				{
+					vim_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);
+			}
+		}
+		EMSG("Updated too many blocks?");
+		buf->b_ml.ml_stack_top = 0;		/* invalidate stack */
+	}
+	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.
+ *
+ * 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;
+
+	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 */
+	if (copy && (line = strsave(line)) == NULL)		/* allocate memory */
+		return FAIL;
+	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'
+ *
+ * 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			*buf;
+	linenr_t	lnum;
+	int			message;
+{
+	BHDR	*hp;
+	MEMFILE	*mfp;
+	DATA_BL	*dp;
+	PTR_BL	*pp;
+	IPTR	*ip;
+	int		count;			/* number of entries in block */
+	int		idx;
+	int		stack_idx;
+	int		text_start;
+	int		line_start;
+	int		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)
+			keep_msg = no_lines_msg;
+		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;
+
+/*
+ * 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("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 */
+					vim_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);
+
+				return OK;
+			}
+		}
+		CHECK(1, "deleted block 1?");
+
+		return OK;
+	}
+
+	/*
+	 * delete the text by moving the next lines forwards
+	 */
+	text_start = dp->db_txt_start;
+	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;
+	vim_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);
+
+	return OK;
+}
+
+/*
+ * set the B_MARKED flag for line 'lnum'
+ */
+	void
+ml_setmarked(lnum)
+	linenr_t lnum;
+{
+	BHDR	*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		*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;
+}
+
+/*
+ * return TRUE if line 'lnum' has a mark
+ */
+	int
+ml_has_mark(lnum)
+	linenr_t	lnum;
+{
+	BHDR		*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);
+}
+
+/*
+ * clear all DB_MARKED flags
+ */
+	void
+ml_clearmarked()
+{
+	BHDR		*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
+		 * 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);
+
+		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		*buf;
+{
+	BHDR		*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)		/* nothing to do */
+		return;
+
+	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("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 = 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 */
+					vim_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 */
+				vim_memmove(old_line - extra, new_line, (size_t)new_len);
+				buf->b_ml.ml_flags |= (ML_LOCKED_DIRTY | ML_LOCKED_POS);
+			}
+			else
+			{
+				/*
+				 * Cannot do it in one data block: delete and append.
+				 */
+					/* How about handling errors??? */
+				(void)ml_delete_int(buf, lnum, FALSE);
+				(void)ml_append_int(buf, lnum - 1, new_line, new_len, FALSE);
+			}
+		}
+		vim_free(new_line);
+	}
+
+	buf->b_ml.ml_line_lnum = 0;
+}
+
+/*
+ * create a new, empty, data block
+ */
+	static BHDR *
+ml_new_data(mfp, negative, page_count)
+	MEMFILE		*mfp;
+	int			negative;
+	int			page_count;
+{
+	BHDR		*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 *
+ml_new_ptr(mfp)
+	MEMFILE		*mfp;
+{
+	BHDR		*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 = (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 *
+ml_find_line(buf, lnum, action)
+	BUF			*buf;
+	linenr_t	lnum;
+	int			action;
+{
+	DATA_BL		*dp;
+	PTR_BL		*pp;
+	IPTR		*ip;
+	BHDR		*hp;
+	MEMFILE		*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("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("line number out of range: %ld past the end",
+											  lnum - buf->b_ml.ml_line_count);
+
+			else
+				EMSGN("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		*buf;
+{
+	int		top;
+	IPTR	*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 = (IPTR *)alloc((unsigned)sizeof(IPTR) *
+										(buf->b_ml.ml_stack_size + STACK_INCR));
+		if (newstack == NULL)
+			return -1;
+		vim_memmove(newstack, buf->b_ml.ml_stack, (size_t)top * sizeof(IPTR));
+		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			*buf;
+	int			count;
+{
+	int			idx;
+	IPTR		*ip;
+	PTR_BL		*pp;
+	MEMFILE		*mfp = buf->b_ml.ml_mfp;
+	BHDR		*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("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 filename and a directory name
+ */
+	static char_u *
+makeswapname(buf, dir_name)
+	BUF		*buf;
+	char_u	*dir_name;
+{
+	char_u		*r, *s, *fname;
+
+#ifdef VMS
+	r = modname(buf->b_xfilename, (char_u *)"_swp");
+#else
+	r = modname(buf->b_xfilename, (char_u *)".swp");
+#endif
+	/*
+	 * do not use dir_name
+	 * - if dir_name starts with '.' (use current directory)
+	 * - if out of memory
+	 */
+	if (*dir_name == '.' || r == NULL)
+		return r;
+
+	fname = gettail(r);
+	s = concat_fnames(dir_name, fname, TRUE);
+	vim_free(r);
+	return s;
+}
+
+/*
+ * 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 MAXNAMLEN 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		*buf;
+	char_u	**dirp;			/* pointer to list of directories */
+	char_u	*old_fname;		/* don't give warning for this filename */
+{
+	char_u		*fname;
+	int			n;
+	time_t		x;
+	char_u		*dir_name;
+
+#ifdef AMIGA
+	BPTR		fh;
+#endif
+
+#ifndef SHORT_FNAME
+	int			r;
+	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".
+ */
+	if (!(buf->b_p_sn || buf->b_shortname) && buf->b_xfilename &&
+												getperm(buf->b_xfilename) < 0)
+		dummyfd = fopen((char *)buf->b_xfilename, "w");
+#endif
+
+/*
+ * Isolate a directory name from *dirp and put it in dir_name.
+ * First allocate some memore 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 = 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 - 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 swapfilename does not fit in 8.3:
+			 * It either contains two dots or it is longer than 8 chars.
+			 */
+			tail = gettail(buf->b_xfilename);
+			if (vim_strchr(tail, '.') != NULL || STRLEN(tail) > (size_t)8)
+			{
+				fname2 = alloc(n + 1);
+				if (fname2 != NULL)
+				{
+					STRCPY(fname2, fname);
+					if (vim_strchr(tail, '.') != NULL)
+						fname2[n - 1] = 'x';	/* change ".swp" to ".swx" */
+					else
+						fname2[n - 5] += 1;		/* change "x.swp" to "y.swp" */
+					/*
+					 * may need to create the files to be able to use stat()
+					 */
+					f1 = open((char *)fname, O_RDONLY | O_EXTRA);
+					if (f1 < 0)
+					{
+						f1 = open((char *)fname, O_RDWR|O_CREAT|O_EXCL|O_EXTRA
+#ifdef AMIGA				/* Amiga has no mode argument */
+																			);
+#endif
+#ifdef UNIX					/* open in rw------- mode */
+															  , (mode_t)0600);
+#endif
+#if defined(MSDOS) || defined(WIN32) || defined(OS2)  /* open read/write */
+														, S_IREAD | S_IWRITE);
+#endif
+#if defined(OS2)
+						if (f1 < 0 && errno == ENOENT)
+							same = TRUE;
+#endif
+						created1 = TRUE;
+					}
+					if (f1 >= 0)
+					{
+						f2 = open((char *)fname2, O_RDONLY | O_EXTRA);
+						if (f2 < 0)
+						{
+							f2 = open((char *)fname2,
+												 O_RDWR|O_CREAT|O_EXCL|O_EXTRA
+#ifdef AMIGA				/* Amiga has no mode argument */
+																			);
+#endif
+#ifdef UNIX					/* open in rw------- mode */
+															  , (mode_t)0600);
+#endif
+#if defined(MSDOS) || defined(WIN32) || defined(OS2)  /* open read/write */
+														, S_IREAD | S_IWRITE);
+#endif
+							created2 = TRUE;
+						}
+						if (f2 >= 0)
+						{
+							/*
+							 * Both files exist now. If stat() returns the
+							 * same device and inode they are the same file.
+							 */
+							if (fstat(f1, &s1) != -1 &&
+										fstat(f2, &s2) != -1 &&
+										s1.st_dev == s2.st_dev &&
+										s1.st_ino == s2.st_ino)
+								same = TRUE;
+							close(f2);
+							if (created2)
+								vim_remove(fname2);
+						}
+						close(f1);
+						if (created1)
+							vim_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 (getperm(fname) < 0)		/* it does not exist */
+		{
+#ifdef AMIGA
+			fh = Open((UBYTE *)fname, (long)MODE_NEWFILE);
+			/*
+			 * on the Amiga 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);
+				break;
+			}
+			if (IoErr() != ERROR_OBJECT_IN_USE &&
+											   IoErr() != ERROR_OBJECT_EXISTS)
+#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 - 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 = 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 by '_' */
+				}
+			}
+#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_xfilename != 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 = open((char *)fname, O_RDONLY | O_EXTRA);
+				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_filename, NameBuff,
+													 char_to_long(b0.b0_ino)))
+							differ = TRUE;
+#else
+						if (fnamecmp(NameBuff, buf->b_filename) != 0)
+							differ = TRUE;
+#endif
+					}
+					close(fd);
+				}
+				if (differ == FALSE)
+				{
+					struct stat st;
+
+					++no_wait_return;
+#ifdef SLEEP_IN_EMSG
+					++dont_sleep;
+#endif
+					(void)EMSG("ATTENTION");
+#ifdef SLEEP_IN_EMSG
+					--dont_sleep;
+#endif
+					MSG_OUTSTR("\nFound a swap file by the name \"");
+					msg_home_replace(fname);
+					MSG_OUTSTR("\"\n");
+					swapfile_info(fname);
+					MSG_OUTSTR("While opening file \"");
+					msg_outtrans(buf->b_xfilename);
+					MSG_OUTSTR("\"\n");
+					if (stat((char *)buf->b_xfilename, &st) != -1)
+					{
+						MSG_OUTSTR("             dated: ");
+						x = st.st_mtime;	/* Manx C can't do &st.st_mtime */
+						MSG_OUTSTR(ctime(&x));
+					}
+					MSG_OUTSTR("\n(1) Another program may be editing the same file.\n");
+					MSG_OUTSTR("    If this is the case, quit this edit session to avoid having\n");
+					MSG_OUTSTR("    two different instances of the same file when making changes.\n");
+					MSG_OUTSTR("\n(2) An edit session for this file crashed.\n");
+					MSG_OUTSTR("    If this is the case, use \":recover\" or \"vim -r ");
+					msg_outtrans(buf->b_xfilename);
+					MSG_OUTSTR("\"\n    to recover the changes (see \":help recovery)\".\n");
+					MSG_OUTSTR("    If you did this already, delete the swap file \"");
+					msg_outtrans(fname);
+					MSG_OUTSTR("\"\n    to avoid this message.\n\n");
+					cmdline_row = msg_row;
+					--no_wait_return;
+					need_wait_return = TRUE;		/* call wait_return later */
+				}
+			}
+		}
+
+		if (fname[n - 1] == 'a')	/* tried enough names, give up */
+		{
+			vim_free(fname);
+			fname = NULL;
+			break;
+		}
+		--fname[n - 1];				/* change last char of the name */
+	}
+
+	vim_free(dir_name);
+#ifndef SHORT_FNAME
+	if (dummyfd)		/* file has been created temporarily */
+	{
+		fclose(dummyfd);
+		vim_remove(buf->b_xfilename);
+	}
+#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
+ */
+
+	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;
+	long		ino_c = 0;			/* ino of current file */
+	long		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 (stat((char *)fname_c, &st) == 0)
+		ino_c = 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 (stat((char *)fname_s, &st) == 0)
+		ino_s = st.st_ino;
+	else
+		ino_s = ino_block0;
+
+	if (ino_c && ino_s)
+		return (ino_c != ino_s);
+
+	/*
+	 * One of the inode numbers is unknown, try a forced FullName() and
+	 * compare the file names.
+	 */
+	retval_c = FullName(fname_c, buf_c, MAXPATHL, TRUE);
+	retval_s = 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 filenames, 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] = (n & 0xff);
+	n >>= 8;
+	s[1] = (n & 0xff);
+	n >>= 8;
+	s[2] = (n & 0xff);
+	n >>= 8;
+	s[3] = (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;
+}