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, 3906 insertions, 0 deletions

diff --git a/usr.bin/vim/misccmds.c b/usr.bin/vim/misccmds.c
new file mode 100644
index 00000000000..ff08529ab07
--- /dev/null
+++ b/usr.bin/vim/misccmds.c
@@ -0,0 +1,3906 @@
+/*	$OpenBSD: misccmds.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.
+ */
+
+/*
+ * misccmds.c: functions that didn't seem to fit elsewhere
+ */
+
+#include "vim.h"
+#include "globals.h"
+#include "proto.h"
+#include "option.h"
+#ifdef HAVE_FCNTL_H
+# include <fcntl.h>			/* for chdir() */
+#endif
+
+static int get_indent_str __ARGS((char_u *ptr));
+static void check_status __ARGS((BUF *));
+
+/*
+ * count the size of the indent in the current line
+ */
+	int
+get_indent()
+{
+	return get_indent_str(ml_get_curline());
+}
+
+/*
+ * count the size of the indent in line "lnum"
+ */
+	int
+get_indent_lnum(lnum)
+	linenr_t	lnum;
+{
+	return get_indent_str(ml_get(lnum));
+}
+
+/*
+ * count the size of the indent in line "ptr"
+ */
+	static int
+get_indent_str(ptr)
+	register char_u *ptr;
+{
+	register int count = 0;
+
+	for ( ; *ptr; ++ptr)
+	{
+		if (*ptr == TAB)	/* count a tab for what it is worth */
+			count += (int)curbuf->b_p_ts - (count % (int)curbuf->b_p_ts);
+		else if (*ptr == ' ')
+			++count;			/* count a space for one */
+		else
+			break;
+	}
+	return (count);
+}
+
+/*
+ * set the indent of the current line
+ * leaves the cursor on the first non-blank in the line
+ */
+	void
+set_indent(size, del_first)
+	register int	size;
+	int 			del_first;
+{
+	int				oldstate = State;
+	register int	c;
+
+	State = INSERT;					/* don't want REPLACE for State */
+	curwin->w_cursor.col = 0;
+	if (del_first)					/* delete old indent */
+	{
+									/* vim_iswhite() is a define! */
+		while ((c = gchar_cursor()), vim_iswhite(c))
+			(void)delchar(FALSE);
+	}
+	if (!curbuf->b_p_et)			/* if 'expandtab' is set, don't use TABs */
+		while (size >= (int)curbuf->b_p_ts)
+		{
+			ins_char(TAB);
+			size -= (int)curbuf->b_p_ts;
+		}
+	while (size)
+	{
+		ins_char(' ');
+		--size;
+	}
+	State = oldstate;
+}
+
+#if defined(CINDENT) || defined(SMARTINDENT)
+
+static int is_cinword __ARGS((char_u *line));
+
+/*
+ * Return TRUE if the string "line" starts with a word from 'cinwords'.
+ */
+	static int
+is_cinword(line)
+	char_u		*line;
+{
+	char_u	*cinw;
+	char_u	*cinw_buf;
+	int		cinw_len;
+	int		retval = FALSE;
+	int		len;
+
+	cinw_len = STRLEN(curbuf->b_p_cinw) + 1;
+	cinw_buf = alloc((unsigned)cinw_len);
+	if (cinw_buf != NULL)
+	{
+		line = skipwhite(line);
+		for (cinw = curbuf->b_p_cinw; *cinw; )
+		{
+			len = copy_option_part(&cinw, cinw_buf, cinw_len, ",");
+			if (STRNCMP(line, cinw_buf, len) == 0 &&
+					   (!iswordchar(line[len]) || !iswordchar(line[len - 1])))
+			{
+				retval = TRUE;
+				break;
+			}
+		}
+		vim_free(cinw_buf);
+	}
+	return retval;
+}
+#endif
+
+/*
+ * Opencmd
+ *
+ * Add a new line below or above the current line.
+ * Caller must take care of undo.
+ *
+ * Return TRUE for success, FALSE for failure
+ */
+
+	int
+Opencmd(dir, redraw, del_spaces)
+	int 		dir;			/* FORWARD or BACKWARD */
+	int			redraw;			/* redraw afterwards */
+	int			del_spaces;		/* delete spaces after cursor */
+{
+	char_u  *saved_line;		/* copy of the original line */
+	char_u	*p_extra = NULL;	/* what goes to next line */
+	int		extra_len = 0;		/* length of p_extra string */
+	FPOS	old_cursor; 		/* old cursor position */
+	int		newcol = 0;			/* new cursor column */
+	int 	newindent = 0;		/* auto-indent of the new line */
+	int		n;
+	int		trunc_line = FALSE;	/* truncate current line afterwards */
+	int		retval = FALSE;		/* return value, default is FAIL */
+	int		lead_len;			/* length of comment leader */
+	char_u	*lead_flags;		/* position in 'comments' for comment leader */
+	char_u	*leader = NULL;		/* copy of comment leader */
+	char_u	*allocated = NULL;	/* allocated memory */
+	char_u	*p;
+	int		saved_char = NUL;	/* init for GCC */
+	FPOS	*pos;
+	int		old_plines = 0;		/* init for GCC */
+	int		new_plines = 0;		/* init for GCC */
+#ifdef SMARTINDENT
+	int		no_si = FALSE;		/* reset did_si afterwards */
+	int		first_char = NUL;	/* init for GCC */
+#endif
+
+	/*
+	 * make a copy of the current line so we can mess with it
+	 */
+	saved_line = strsave(ml_get_curline());
+	if (saved_line == NULL)			/* out of memory! */
+		return FALSE;
+
+	if (State == INSERT || State == REPLACE)
+	{
+		p_extra = saved_line + curwin->w_cursor.col;
+#ifdef SMARTINDENT
+		if (curbuf->b_p_si)			/* need first char after new line break */
+		{
+			p = skipwhite(p_extra);
+			first_char = *p;
+		}
+#endif
+		extra_len = STRLEN(p_extra);
+		saved_char = *p_extra;
+		*p_extra = NUL;
+	}
+
+	u_clearline();				/* cannot do "U" command when adding lines */
+#ifdef SMARTINDENT
+	did_si = FALSE;
+#endif
+
+	/*
+	 * If 'autoindent' and/or 'smartindent' is set, try to figure out what
+	 * indent to use for the new line.
+	 */
+	if (curbuf->b_p_ai
+#ifdef SMARTINDENT
+						|| curbuf->b_p_si
+#endif
+											)
+	{
+		/*
+		 * count white space on current line
+		 */
+		newindent = get_indent();
+		if (newindent == 0)
+			newindent = old_indent;		/* for ^^D command in insert mode */
+		old_indent = 0;
+
+		/*
+		 * If we just did an auto-indent, then we didn't type anything on
+		 * the prior line, and it should be truncated.
+		 */
+		if (dir == FORWARD && did_ai)
+			trunc_line = TRUE;
+
+#ifdef SMARTINDENT
+		/*
+		 * Do smart indenting.
+		 * In insert/replace mode (only when dir == FORWARD)
+		 * we may move some text to the next line. If it starts with '{'
+		 * don't add an indent. Fixes inserting a NL before '{' in line
+		 * 		"if (condition) {"
+		 */
+		else if (curbuf->b_p_si && *saved_line != NUL &&
+									   (p_extra == NULL || first_char != '{'))
+		{
+			char_u	*ptr;
+			char_u	last_char;
+
+			old_cursor = curwin->w_cursor;
+			ptr = saved_line;
+			lead_len = get_leader_len(ptr, NULL);
+			if (dir == FORWARD)
+			{
+				/*
+				 * Skip preprocessor directives, unless they are
+				 * recognised as comments.
+				 */
+				if (lead_len == 0 && ptr[0] == '#')
+				{
+					while (ptr[0] == '#' && curwin->w_cursor.lnum > 1)
+						ptr = ml_get(--curwin->w_cursor.lnum);
+					newindent = get_indent();
+				}
+				lead_len = get_leader_len(ptr, NULL);
+				if (lead_len > 0)
+				{
+					/*
+					 * This case gets the following right:
+					 *		\*
+					 *		 * A comment (read "\" as "/").
+					 *		 *\
+					 * #define IN_THE_WAY
+					 *		This should line up here;
+					 */
+					p = skipwhite(ptr);
+					if (p[0] == '/' && p[1] == '*')
+						p++;
+					if (p[0] == '*')
+					{
+						for (p++; *p; p++)
+						{
+							if (p[0] == '/' && p[-1] == '*')
+							{
+								/*
+								 * End of C comment, indent should line up
+								 * with the line containing the start of
+								 * the comment
+								 */
+								curwin->w_cursor.col = p - ptr;
+								if ((pos = findmatch(NUL)) != NULL)
+								{
+									curwin->w_cursor.lnum = pos->lnum;
+									newindent = get_indent();
+								}
+							}
+						}
+					}
+				}
+				else	/* Not a comment line */
+				{
+					/* Find last non-blank in line */
+					p = ptr + STRLEN(ptr) - 1;
+					while (p > ptr && vim_iswhite(*p))
+						--p;
+					last_char = *p;
+
+					/*
+					 * find the character just before the '{' or ';'
+					 */
+					if (last_char == '{' || last_char == ';')
+					{
+						if (p > ptr)
+							--p;
+						while (p > ptr && vim_iswhite(*p))
+							--p;
+					}
+					/*
+					 * Try to catch lines that are split over multiple
+					 * lines.  eg:
+					 *		if (condition &&
+					 *					condition) {
+					 *			Should line up here!
+					 *		}
+					 */
+					if (*p == ')')
+					{
+						curwin->w_cursor.col = p - ptr;
+						if ((pos = findmatch('(')) != NULL)
+						{
+							curwin->w_cursor.lnum = pos->lnum;
+							newindent = get_indent();
+							ptr = ml_get_curline();
+						}
+					}
+					/*
+					 * If last character is '{' do indent, without
+					 * checking for "if" and the like.
+					 */
+					if (last_char == '{')
+					{
+						did_si = TRUE;	/* do indent */
+						no_si = TRUE;	/* don't delete it when '{' typed */
+					}
+					/*
+					 * Look for "if" and the like, use 'cinwords'.
+					 * Don't do this if the previous line ended in ';' or
+					 * '}'.
+					 */
+					else if (last_char != ';' && last_char != '}' &&
+															is_cinword(ptr))
+						did_si = TRUE;
+				}
+			}
+			else /* dir == BACKWARD */
+			{
+				/*
+				 * Skip preprocessor directives, unless they are
+				 * recognised as comments.
+				 */
+				if (lead_len == 0 && ptr[0] == '#')
+				{
+					int was_backslashed = FALSE;
+
+					while ((ptr[0] == '#' || was_backslashed) &&
+						 curwin->w_cursor.lnum < curbuf->b_ml.ml_line_count)
+					{
+						if (*ptr && ptr[STRLEN(ptr) - 1] == '\\')
+							was_backslashed = TRUE;
+						else
+							was_backslashed = FALSE;
+						ptr = ml_get(++curwin->w_cursor.lnum);
+					}
+					if (was_backslashed)
+						newindent = 0;		/* Got to end of file */
+					else
+						newindent = get_indent();
+				}
+				p = skipwhite(ptr);
+				if (*p == '}')		/* if line starts with '}': do indent */
+					did_si = TRUE;
+				else				/* can delete indent when '{' typed */
+					can_si_back = TRUE;
+			}
+			curwin->w_cursor = old_cursor;
+		}
+		if (curbuf->b_p_si)
+			can_si = TRUE;
+#endif /* SMARTINDENT */
+
+		did_ai = TRUE;
+	}
+	
+	/*
+	 * Find out if the current line starts with a comment leader.
+	 * This may then be inserted in front of the new line.
+	 */
+	lead_len = get_leader_len(saved_line, &lead_flags);
+	if (lead_len > 0)
+	{
+		char_u	*lead_repl = NULL;			/* replaces comment leader */
+		int		lead_repl_len = 0;			/* length of *lead_repl */
+		char_u	lead_middle[COM_MAX_LEN];	/* middle-comment string */
+		char_u	lead_end[COM_MAX_LEN];		/* end-comment string */
+		char_u	*comment_end = NULL;		/* where lead_end has been found */
+		int		extra_space = FALSE;		/* append extra space */
+		int		current_flag;
+
+		/*
+		 * If the comment leader has the start, middle or end flag, it may not
+		 * be used or may be replaced with the middle leader.
+		 */
+		for (p = lead_flags; *p && *p != ':'; ++p)
+		{
+			if (*p == COM_START || *p == COM_MIDDLE)
+			{
+				current_flag = *p;
+				if (*p == COM_START)
+				{
+					/*
+					 * Doing "O" on a start of comment does not insert leader.
+					 */
+					if (dir == BACKWARD)
+					{
+						lead_len = 0;
+						break;
+					}
+
+				   /* find start of middle part */
+					(void)copy_option_part(&p, lead_middle, COM_MAX_LEN, ",");
+				}
+
+				/*
+				 * Isolate the strings of the middle and end leader.
+				 */
+				while (*p && p[-1] != ':')		/* find end of middle flags */
+					++p;
+				(void)copy_option_part(&p, lead_middle, COM_MAX_LEN, ",");
+				while (*p && p[-1] != ':')		/* find end of end flags */
+					++p;
+				(void)copy_option_part(&p, lead_end, COM_MAX_LEN, ",");
+
+				/*
+				 * If the end of the comment is in the same line, don't use
+				 * the comment leader.
+				 */
+				if (dir == FORWARD)
+				{
+					n = STRLEN(lead_end);
+					for (p = saved_line + lead_len; *p; ++p)
+						if (STRNCMP(p, lead_end, n) == 0)
+						{
+							comment_end = p;
+							lead_len = 0;
+							break;
+						}
+				}
+
+				/*
+				 * Doing "o" on a start of comment inserts the middle leader.
+				 */
+				if (lead_len)
+				{
+					if (current_flag == COM_START)
+					{
+						lead_repl = lead_middle;
+						lead_repl_len = STRLEN(lead_middle);
+					}
+
+					/*
+					 * If we have hit RETURN immediately after the start
+					 * comment leader, then put a space after the middle
+					 * comment leader on the next line.
+					 */
+					if (!vim_iswhite(saved_line[lead_len - 1]) &&
+							((p_extra != NULL &&
+									 (int)curwin->w_cursor.col == lead_len) ||
+							 (p_extra == NULL && saved_line[lead_len] == NUL)))
+						extra_space = TRUE;
+				}
+				break;
+			}
+			if (*p == COM_END)
+			{
+				/*
+				 * Doing "o" on the end of a comment does not insert leader.
+				 * Remember where the end is, might want to use it to find the
+				 * start (for C-comments).
+				 */
+				if (dir == FORWARD)
+				{
+					comment_end = skipwhite(saved_line);
+					lead_len = 0;
+					break;
+				}
+
+				/*
+				 * Doing "O" on the end of a comment inserts the middle leader.
+				 * Find the string for the middle leader, searching backwards.
+				 */
+				while (p > curbuf->b_p_com && *p != ',')
+					--p;
+				for (lead_repl = p; lead_repl > curbuf->b_p_com &&
+											lead_repl[-1] != ':'; --lead_repl)
+					;
+				lead_repl_len = p - lead_repl;
+				break;
+			}
+			if (*p == COM_FIRST)
+			{
+				/*
+				 * Comment leader for first line only:  Don't repeat leader
+				 * when using "O", blank out leader when using "o".
+				 */
+				if (dir == BACKWARD)
+					lead_len = 0;
+				else
+				{
+					lead_repl = (char_u *)"";
+					lead_repl_len = 0;
+				}
+				break;
+			}
+		}
+		if (lead_len)
+		{
+			/* allocate buffer (may concatenate p_exta later) */
+			leader = alloc(lead_len + lead_repl_len + extra_space +
+															  extra_len + 1);
+			allocated = leader;				/* remember to free it later */
+
+			if (leader == NULL)
+				lead_len = 0;
+			else
+			{
+				STRNCPY(leader, saved_line, lead_len);
+				leader[lead_len] = NUL;
+
+				/*
+				 * Replace leader with lead_repl, right or left adjusted
+				 */
+				if (lead_repl != NULL)
+				{
+					for (p = lead_flags; *p && *p != ':'; ++p)
+						if (*p == COM_RIGHT || *p == COM_LEFT)
+							break;
+					if (*p == COM_RIGHT)	/* right adjusted leader */
+					{
+						/* find last non-white in the leader to line up with */
+						for (p = leader + lead_len - 1; p > leader &&
+														 vim_iswhite(*p); --p)
+							;
+
+						++p;
+						if (p < leader + lead_repl_len)
+							p = leader;
+						else
+							p -= lead_repl_len;
+						vim_memmove(p, lead_repl, (size_t)lead_repl_len);
+						if (p + lead_repl_len > leader + lead_len)
+							p[lead_repl_len] = NUL;
+
+						/* blank-out any other chars from the old leader. */
+						while (--p >= leader)
+							if (!vim_iswhite(*p))
+								*p = ' ';
+					}
+					else 					/* left adjusted leader */
+					{
+						p = skipwhite(leader);
+						vim_memmove(p, lead_repl, (size_t)lead_repl_len);
+
+						/* blank-out any other chars from the old leader. */
+						for (p += lead_repl_len; p < leader + lead_len; ++p)
+							if (!vim_iswhite(*p))
+								*p = ' ';
+						*p = NUL;
+					}
+
+					/* Recompute the indent, it may have changed. */
+					if (curbuf->b_p_ai
+#ifdef SMARTINDENT
+										|| curbuf->b_p_si
+#endif
+														   )
+						newindent = get_indent_str(leader);
+				}
+
+				lead_len = STRLEN(leader);
+				if (extra_space)
+				{
+					leader[lead_len++] = ' ';
+					leader[lead_len] = NUL;
+				}
+
+				newcol = lead_len;
+
+				/*
+				 * if a new indent will be set below, remove the indent that
+				 * is in the comment leader
+				 */
+				if (newindent
+#ifdef SMARTINDENT
+								|| did_si
+#endif
+										   )
+				{
+					while (lead_len && vim_iswhite(*leader))
+					{
+						--lead_len;
+						--newcol;
+						++leader;
+					}
+				}
+
+			}
+#ifdef SMARTINDENT
+			did_si = can_si = FALSE;
+#endif
+		}
+		else if (comment_end != NULL)
+		{
+			/*
+			 * We have finished a comment, so we don't use the leader.
+			 * If this was a C-comment and 'ai' or 'si' is set do a normal
+			 * indent to align with the line containing the start of the
+			 * comment.
+			 */
+			if (comment_end[0] == '*' && comment_end[1] == '/' &&
+						(curbuf->b_p_ai
+#ifdef SMARTINDENT
+										|| curbuf->b_p_si
+#endif
+														   ))
+			{
+				old_cursor = curwin->w_cursor;
+				curwin->w_cursor.col = comment_end - saved_line;
+				if ((pos = findmatch(NUL)) != NULL)
+				{
+					curwin->w_cursor.lnum = pos->lnum;
+					newindent = get_indent();
+				}
+				curwin->w_cursor = old_cursor;
+			}
+		}
+	}
+
+	/* (State == INSERT || State == REPLACE), only when dir == FORWARD */
+	if (p_extra != NULL)
+	{
+		*p_extra = saved_char;			/* restore char that NUL replaced */
+
+		/*
+		 * When 'ai' set or "del_spaces" TRUE, skip to the first non-blank.
+		 *
+		 * When in REPLACE mode, put the deleted blanks on the replace
+		 * stack, followed by a NUL, so they can be put back when
+		 * a BS is entered.
+		 */
+		if (State == REPLACE)
+			replace_push(NUL);		/* end of extra blanks */
+		if (curbuf->b_p_ai || del_spaces)
+		{
+			while (*p_extra == ' ' || *p_extra == '\t')
+			{
+				if (State == REPLACE)
+					replace_push(*p_extra);
+				++p_extra;
+			}
+		}
+		if (*p_extra != NUL)
+			did_ai = FALSE; 		/* append some text, don't trucate now */
+	}
+
+	if (p_extra == NULL)
+		p_extra = (char_u *)"";				/* append empty line */
+
+	/* concatenate leader and p_extra, if there is a leader */
+	if (lead_len)
+	{
+		STRCAT(leader, p_extra);
+		p_extra = leader;
+	}
+
+	old_cursor = curwin->w_cursor;
+	if (dir == BACKWARD)
+		--curwin->w_cursor.lnum;
+	if (ml_append(curwin->w_cursor.lnum, p_extra, (colnr_t)0, FALSE) == FAIL)
+		goto theend;
+	mark_adjust(curwin->w_cursor.lnum + 1, MAXLNUM, 1L, 0L);
+	if (newindent
+#ifdef SMARTINDENT
+					|| did_si
+#endif
+								)
+	{
+		++curwin->w_cursor.lnum;
+#ifdef SMARTINDENT
+		if (did_si)
+		{
+			if (p_sr)
+				newindent -= newindent % (int)curbuf->b_p_sw;
+			newindent += (int)curbuf->b_p_sw;
+		}
+#endif
+		set_indent(newindent, FALSE);
+		/*
+		 * In REPLACE mode the new indent must be put on
+		 * the replace stack for when it is deleted with BS
+		 */
+		if (State == REPLACE)
+			for (n = 0; n < (int)curwin->w_cursor.col; ++n)
+				replace_push(NUL);
+		newcol += curwin->w_cursor.col;
+#ifdef SMARTINDENT
+		if (no_si)
+			did_si = FALSE;
+#endif
+	}
+	/*
+	 * In REPLACE mode the extra leader must be put on the replace stack for
+	 * when it is deleted with BS.
+	 */
+	if (State == REPLACE)
+		while (lead_len-- > 0)
+			replace_push(NUL);
+
+	curwin->w_cursor = old_cursor;
+
+	if (dir == FORWARD)
+	{
+		if (redraw)		/* want to know the old number of screen lines */
+		{
+			old_plines = plines(curwin->w_cursor.lnum);
+			new_plines = old_plines;
+		}
+		if (trunc_line || State == INSERT || State == REPLACE)
+		{
+			if (trunc_line)
+			{
+					/* find start of trailing white space */
+				for (n = STRLEN(saved_line); n > 0 &&
+										  vim_iswhite(saved_line[n - 1]); --n)
+					;
+				saved_line[n] = NUL;
+			}
+			else					/* truncate current line at cursor */
+				*(saved_line + curwin->w_cursor.col) = NUL;
+			ml_replace(curwin->w_cursor.lnum, saved_line, FALSE);
+			saved_line = NULL;
+			new_plines = plines(curwin->w_cursor.lnum);
+		}
+
+		/*
+		 * Get the cursor to the start of the line, so that 'curwin->w_row'
+		 * gets set to the right physical line number for the stuff that
+		 * follows...
+		 */
+		curwin->w_cursor.col = 0;
+
+		if (redraw)
+		{
+			/*
+			 * Call cursupdate() to compute w_row.
+			 * But we don't want it to update the srceen.
+			 */
+			++RedrawingDisabled;
+			cursupdate();
+			--RedrawingDisabled;
+
+			/*
+			 * If we're doing an open on the last logical line, then go ahead
+			 * and scroll the screen up. Otherwise, just insert a blank line
+			 * at the right place if the number of screen lines changed.
+			 * We use calls to plines() in case the cursor is resting on a
+			 * long line, we want to know the row below the line.
+			 */
+			n = curwin->w_row + new_plines;
+			if (n == curwin->w_winpos + curwin->w_height)
+				scrollup(1L);
+			else
+				win_ins_lines(curwin, n,
+				  plines(curwin->w_cursor.lnum + 1) + new_plines - old_plines,
+																  TRUE, TRUE);
+		}
+
+		/*
+		 * Put the cursor on the new line.  Careful: the cursupdate() and
+		 * scrollup() above may have moved w_cursor, we must use old_cursor.
+		 */
+		curwin->w_cursor.lnum = old_cursor.lnum + 1;
+	}
+	else if (redraw) 			/* insert physical line above current line */
+		win_ins_lines(curwin, curwin->w_row, 1, TRUE, TRUE);
+
+	curwin->w_cursor.col = newcol;
+
+#ifdef LISPINDENT
+	/*
+	 * May do lisp indenting.
+	 */
+	if (leader == NULL && curbuf->b_p_lisp && curbuf->b_p_ai)
+		fixthisline(get_lisp_indent);
+#endif
+#ifdef CINDENT
+	/*
+	 * May do indenting after opening a new line.
+	 */
+	if (leader == NULL && curbuf->b_p_cin &&
+			in_cinkeys(dir == FORWARD ? KEY_OPEN_FORW :
+						KEY_OPEN_BACK, ' ', linewhite(curwin->w_cursor.lnum)))
+		fixthisline(get_c_indent);
+#endif
+
+	if (redraw)
+	{
+		updateScreen(VALID_TO_CURSCHAR);
+		cursupdate();			/* update curwin->w_row */
+	}
+	CHANGED;
+
+	retval = TRUE;				/* success! */
+theend:
+	vim_free(saved_line);
+	vim_free(allocated);
+	return retval;
+}
+
+/*
+ * get_leader_len() returns the length of the prefix of the given string
+ * which introduces a comment.  If this string is not a comment then 0 is
+ * returned.
+ * When "flags" is non-zero, it is set to point to the flags of the recognized
+ * comment leader.
+ */
+	int
+get_leader_len(line, flags)
+	char_u	*line;
+	char_u	**flags;
+{
+	int		i, j;
+	int		got_com = FALSE;
+	int		found_one;
+	char_u	part_buf[COM_MAX_LEN];	/* buffer for one option part */
+	char_u	*string;				/* pointer to comment string */
+	char_u	*list;
+
+	if (!fo_do_comments)			/* don't format comments at all */
+		return 0;
+
+	i = 0;
+	while (vim_iswhite(line[i]))	/* leading white space is ignored */
+		++i;
+
+	/*
+	 * Repeat to match several nested comment strings.
+	 */
+	while (line[i])
+	{
+		/*
+		 * scan through the 'comments' option for a match
+		 */
+		found_one = FALSE;
+		for (list = curbuf->b_p_com; *list; )
+		{
+			/*
+			 * Get one option part into part_buf[].  Advance list to next one.
+			 * put string at start of string.
+			 */
+			if (!got_com && flags != NULL)	/* remember where flags started */
+				*flags = list;
+			(void)copy_option_part(&list, part_buf, COM_MAX_LEN, ",");
+			string = vim_strchr(part_buf, ':');
+			if (string == NULL)		/* missing ':', ignore this part */
+				continue;
+			*string++ = NUL;		/* isolate flags from string */
+
+			/*
+			 * When already found a nested comment, only accept further
+			 * nested comments.
+			 */
+			if (got_com && vim_strchr(part_buf, COM_NEST) == NULL)
+				continue;
+
+			/*
+			 * Line contents and string must match.
+			 */
+			for (j = 0; string[j] != NUL && string[j] == line[i + j]; ++j)
+				;
+			if (string[j] != NUL)
+				continue;
+
+			/*
+			 * When 'b' flag used, there must be white space or an
+			 * end-of-line after the string in the line.
+			 */
+			if (vim_strchr(part_buf, COM_BLANK) != NULL &&
+							  !vim_iswhite(line[i + j]) && line[i + j] != NUL)
+				continue;
+
+			/*
+			 * We have found a match, stop searching.
+			 */
+			i += j;
+			got_com = TRUE;
+			found_one = TRUE;
+			break;
+		}
+
+		/*
+		 * No match found, stop scanning.
+		 */
+		if (!found_one)
+			break;
+
+		/*
+		 * Include any trailing white space.
+		 */
+		while (vim_iswhite(line[i]))
+			++i;
+
+		/*
+		 * If this comment doesn't nest, stop here.
+		 */
+		if (vim_strchr(part_buf, COM_NEST) == NULL)
+			break;
+	}
+	return (got_com ? i : 0);
+}
+
+/*
+ * plines(p) - return the number of physical screen lines taken by line 'p'
+ */
+	int
+plines(p)
+	linenr_t	p;
+{
+	return plines_win(curwin, p);
+}
+	
+	int
+plines_win(wp, p)
+	WIN			*wp;
+	linenr_t	p;
+{
+	register long		col;
+	register char_u		*s;
+	register int		lines;
+
+	if (!wp->w_p_wrap)
+		return 1;
+
+	s = ml_get_buf(wp->w_buffer, p, FALSE);
+	if (*s == NUL)				/* empty line */
+		return 1;
+
+	col = linetabsize(s);
+
+	/*
+	 * If list mode is on, then the '$' at the end of the line takes up one
+	 * extra column.
+	 */
+	if (wp->w_p_list)
+		col += 1;
+
+	/*
+	 * If 'number' mode is on, add another 8.
+	 */
+	if (wp->w_p_nu)
+		col += 8;
+
+	lines = (col + (Columns - 1)) / Columns;
+	if (lines <= wp->w_height)
+		return lines;
+	return (int)(wp->w_height);		/* maximum length */
+}
+
+/*
+ * Count the physical lines (rows) for the lines "first" to "last" inclusive.
+ */
+	int
+plines_m(first, last)
+	linenr_t		first, last;
+{
+	return plines_m_win(curwin, first, last);
+}
+
+	int
+plines_m_win(wp, first, last)
+	WIN				*wp;
+	linenr_t		first, last;
+{
+	int count = 0;
+
+	while (first <= last)
+		count += plines_win(wp, first++);
+	return (count);
+}
+
+/*
+ * Insert or replace a single character at the cursor position.
+ * When in REPLACE mode, replace any existing character.
+ */
+	void
+ins_char(c)
+	int			c;
+{
+	register char_u  *p;
+	char_u			*newp;
+	char_u			*oldp;
+	int				oldlen;
+	int				extra;
+	colnr_t			col = curwin->w_cursor.col;
+	linenr_t		lnum = curwin->w_cursor.lnum;
+
+	oldp = ml_get(lnum);
+	oldlen = STRLEN(oldp) + 1;
+
+	if (State != REPLACE || *(oldp + col) == NUL)
+		extra = 1;
+	else
+		extra = 0;
+
+	/*
+	 * a character has to be put on the replace stack if there is a
+	 * character that is replaced, so it can be put back when BS is used.
+	 * Otherwise a 0 is put on the stack, indicating that a new character
+	 * was inserted, which can be deleted when BS is used.
+	 */
+	if (State == REPLACE)
+		replace_push(!extra ? *(oldp + col) : 0);
+	newp = alloc_check((unsigned)(oldlen + extra));
+	if (newp == NULL)
+		return;
+	vim_memmove(newp, oldp, (size_t)col);
+	p = newp + col;
+	vim_memmove(p + extra, oldp + col, (size_t)(oldlen - col));
+	*p = c;
+	ml_replace(lnum, newp, FALSE);
+
+	/*
+	 * If we're in insert or replace mode and 'showmatch' is set, then check for
+	 * right parens and braces. If there isn't a match, then beep. If there
+	 * is a match AND it's on the screen, then flash to it briefly. If it
+	 * isn't on the screen, don't do anything.
+	 */
+#ifdef RIGHTLEFT
+	if (p_sm && (State & INSERT) && 
+			((!curwin->w_p_rl && (c == ')' || c == '}' || c == ']')) ||
+			 (curwin->w_p_rl && (c == '(' || c == '{' || c == '['))))
+#else
+ 	if (p_sm && (State & INSERT) && (c == ')' || c == '}' || c == ']'))
+#endif
+		showmatch();
+
+#ifdef RIGHTLEFT
+	if (!p_ri || State == REPLACE)		/* normal insert: cursor right */
+#endif
+		++curwin->w_cursor.col;
+	CHANGED;
+}
+
+/*
+ * Insert a string at the cursor position.
+ * Note: Nothing special for replace mode.
+ */
+	void
+ins_str(s)
+	char_u  *s;
+{
+	register char_u		*oldp, *newp;
+	register int		newlen = STRLEN(s);
+	int					oldlen;
+	colnr_t				col = curwin->w_cursor.col;
+	linenr_t			lnum = curwin->w_cursor.lnum;
+
+	oldp = ml_get(lnum);
+	oldlen = STRLEN(oldp);
+
+	newp = alloc_check((unsigned)(oldlen + newlen + 1));
+	if (newp == NULL)
+		return;
+	vim_memmove(newp, oldp, (size_t)col);
+	vim_memmove(newp + col, s, (size_t)newlen);
+	vim_memmove(newp + col + newlen, oldp + col, (size_t)(oldlen - col + 1));
+	ml_replace(lnum, newp, FALSE);
+	curwin->w_cursor.col += newlen;
+	CHANGED;
+}
+
+/*
+ * delete one character under the cursor
+ *
+ * return FAIL for failure, OK otherwise
+ */
+	int
+delchar(fixpos)
+	int			fixpos; 	/* if TRUE fix the cursor position when done */
+{
+	char_u		*oldp, *newp;
+	colnr_t		oldlen;
+	linenr_t	lnum = curwin->w_cursor.lnum;
+	colnr_t		col = curwin->w_cursor.col;
+	int			was_alloced;
+
+	oldp = ml_get(lnum);
+	oldlen = STRLEN(oldp);
+
+	if (col >= oldlen)	/* can't do anything (happens with replace mode) */
+		return FAIL;
+
+/*
+ * If the old line has been allocated the deletion can be done in the
+ * existing line. Otherwise a new line has to be allocated
+ */
+	was_alloced = ml_line_alloced();		/* check if oldp was allocated */
+	if (was_alloced)
+		newp = oldp;							/* use same allocated memory */
+	else
+	{
+		newp = alloc((unsigned)oldlen);		/* need to allocated a new line */
+		if (newp == NULL)
+			return FAIL;
+		vim_memmove(newp, oldp, (size_t)col);
+	}
+	vim_memmove(newp + col, oldp + col + 1, (size_t)(oldlen - col));
+	if (!was_alloced)
+		ml_replace(lnum, newp, FALSE);
+
+	/*
+	 * If we just took off the last character of a non-blank line, we don't
+	 * want to end up positioned at the NUL.
+	 */
+	if (fixpos && curwin->w_cursor.col > 0 && col == oldlen - 1)
+		--curwin->w_cursor.col;
+
+	CHANGED;
+	return OK;
+}
+
+/*
+ * Delete from cursor to end of line.
+ *
+ * return FAIL for failure, OK otherwise
+ */
+	int
+truncate_line(fixpos)
+	int			fixpos; 	/* if TRUE fix the cursor position when done */
+{
+	char_u		*newp;
+	linenr_t	lnum = curwin->w_cursor.lnum;
+	colnr_t		col = curwin->w_cursor.col;
+
+	if (col == 0)
+		newp = strsave((char_u *)"");
+	else
+		newp = strnsave(ml_get(lnum), col);
+
+	if (newp == NULL)
+		return FAIL;
+
+	ml_replace(lnum, newp, FALSE);
+
+	/*
+	 * If "fixpos" is TRUE we don't want to end up positioned at the NUL.
+	 */
+	if (fixpos && curwin->w_cursor.col > 0)
+		--curwin->w_cursor.col;
+
+	CHANGED;
+	return OK;
+}
+
+	void
+dellines(nlines, dowindow, undo)
+	long 			nlines;			/* number of lines to delete */
+	int 			dowindow;		/* if true, update the window */
+	int				undo;			/* if true, prepare for undo */
+{
+	int 			num_plines = 0;
+
+	if (nlines <= 0)
+		return;
+	/*
+	 * There's no point in keeping the window updated if redrawing is disabled
+	 * or we're deleting more than a window's worth of lines.
+	 */
+	if (RedrawingDisabled)
+		dowindow = FALSE;
+	else if (nlines > (curwin->w_height - curwin->w_row) && dowindow)
+	{
+		dowindow = FALSE;
+		/* flaky way to clear rest of window */
+		win_del_lines(curwin, curwin->w_row, curwin->w_height, TRUE, TRUE);
+	}
+	/* save the deleted lines for undo */
+	if (undo && u_savedel(curwin->w_cursor.lnum, nlines) == FAIL)
+		return;
+
+	/* adjust marks for deleted lines and lines that follow */
+	mark_adjust(curwin->w_cursor.lnum, curwin->w_cursor.lnum + nlines - 1,
+															MAXLNUM, -nlines);
+
+	while (nlines-- > 0)
+	{
+		if (curbuf->b_ml.ml_flags & ML_EMPTY) 		/* nothing to delete */
+			break;
+
+		/*
+		 * Set up to delete the correct number of physical lines on the
+		 * window
+		 */
+		if (dowindow)
+			num_plines += plines(curwin->w_cursor.lnum);
+
+		ml_delete(curwin->w_cursor.lnum, TRUE);
+
+		CHANGED;
+
+		/* If we delete the last line in the file, stop */
+		if (curwin->w_cursor.lnum > curbuf->b_ml.ml_line_count)
+		{
+			curwin->w_cursor.lnum = curbuf->b_ml.ml_line_count;
+			break;
+		}
+	}
+	curwin->w_cursor.col = 0;
+	/*
+	 * Delete the correct number of physical lines on the window
+	 */
+	if (dowindow && num_plines > 0)
+		win_del_lines(curwin, curwin->w_row, num_plines, TRUE, TRUE);
+}
+
+	int
+gchar(pos)
+	FPOS *pos;
+{
+	return (int)(*(ml_get_pos(pos)));
+}
+
+	int
+gchar_cursor()
+{
+	return (int)(*(ml_get_cursor()));
+}
+
+/*
+ * Write a character at the current cursor position.
+ * It is directly written into the block.
+ */
+	void
+pchar_cursor(c)
+	int c;
+{
+	*(ml_get_buf(curbuf, curwin->w_cursor.lnum, TRUE) +
+													curwin->w_cursor.col) = c;
+}
+
+/*
+ * Put *pos at end of current buffer
+ */
+	void
+goto_endofbuf(pos)
+	FPOS	*pos;
+{
+	char_u	*p;
+
+	pos->lnum = curbuf->b_ml.ml_line_count;
+	pos->col = 0;
+	p = ml_get(pos->lnum);
+	while (*p++)
+		++pos->col;
+}
+
+/*
+ * When extra == 0: Return TRUE if the cursor is before or on the first
+ *					non-blank in the line.
+ * When extra == 1: Return TRUE if the cursor is before the first non-blank in
+ *					the line.
+ */
+	int
+inindent(extra)
+	int		extra;
+{
+	register char_u *ptr;
+	register colnr_t col;
+
+	for (col = 0, ptr = ml_get_curline(); vim_iswhite(*ptr); ++col)
+		++ptr;
+	if (col >= curwin->w_cursor.col + extra)
+		return TRUE;
+	else
+		return FALSE;
+}
+
+/*
+ * skipwhite: skip over ' ' and '\t'.
+ */
+	char_u *
+skipwhite(p)
+	register char_u *p;
+{
+    while (vim_iswhite(*p))	/* skip to next non-white */
+    	++p;
+	return p;
+}
+
+/*
+ * skipdigits: skip over digits;
+ */
+	char_u *
+skipdigits(p)
+	register char_u *p;
+{
+    while (isdigit(*p))	/* skip to next non-digit */
+    	++p;
+	return p;
+}
+
+/*
+ * skiptowhite: skip over text until ' ' or '\t' or NUL.
+ */
+	char_u *
+skiptowhite(p)
+	register char_u *p;
+{
+	while (*p != ' ' && *p != '\t' && *p != NUL)
+		++p;
+	return p;
+}
+
+/*
+ * skiptowhite_esc: Like skiptowhite(), but also skip escaped chars
+ */
+	char_u *
+skiptowhite_esc(p)
+	register char_u *p;
+{
+	while (*p != ' ' && *p != '\t' && *p != NUL)
+	{
+		if ((*p == '\\' || *p == Ctrl('V')) && *(p + 1) != NUL)
+			++p;
+		++p;
+	}
+	return p;
+}
+
+/*
+ * getdigits: get a number from a string and skip over it
+ *
+ * note: you must give a pointer to a char_u pointer!
+ */
+
+	long
+getdigits(pp)
+	char_u **pp;
+{
+    register char_u *p;
+	long retval;
+    
+	p = *pp;
+	retval = atol((char *)p);
+	p = skipdigits(p);		/* skip to next non-digit */
+    *pp = p;
+	return retval;
+}
+
+/*
+ * Skip to next part of an option argument: Skip space and comma.
+ */
+	char_u *
+skip_to_option_part(p)
+	char_u	*p;
+{
+	if (*p == ',')
+		++p;
+	while (*p == ' ')
+		++p;
+	return p;
+}
+
+	char *
+plural(n)
+	long n;
+{
+	static char buf[2] = "s";
+
+	if (n == 1)
+		return &(buf[1]);
+	return &(buf[0]);
+}
+
+/*
+ * set_Changed is called when something in the current buffer is changed
+ */
+	void
+set_Changed()
+{
+	if (!curbuf->b_changed)
+	{
+		change_warning();
+		curbuf->b_changed = TRUE;
+		check_status(curbuf);
+	}
+	modified = TRUE;				/* used for redrawing */
+}
+
+/*
+ * unset_Changed is called when the changed flag must be reset for buffer 'buf'
+ */
+	void
+unset_Changed(buf)
+	BUF		*buf;
+{
+	if (buf->b_changed)
+	{
+		buf->b_changed = 0;
+		check_status(buf);
+	}
+}
+
+/*
+ * check_status: called when the status bars for the buffer 'buf'
+ *				 need to be updated
+ */
+	static void
+check_status(buf)
+	BUF		*buf;
+{
+	WIN		*wp;
+	int		i;
+
+	i = 0;
+	for (wp = firstwin; wp != NULL; wp = wp->w_next)
+		if (wp->w_buffer == buf && wp->w_status_height)
+		{
+			wp->w_redr_status = TRUE;
+			++i;
+		}
+	if (i)
+		redraw_later(NOT_VALID);
+}
+
+/*
+ * If the file is readonly, give a warning message with the first change.
+ * Don't do this for autocommands.
+ * Don't use emsg(), because it flushes the macro buffer.
+ * If we have undone all changes b_changed will be FALSE, but b_did_warn
+ * will be TRUE.
+ */
+	void
+change_warning()
+{
+	if (curbuf->b_did_warn == FALSE && curbuf->b_changed == 0 &&
+#ifdef AUTOCMD
+											  !autocmd_busy &&
+#endif
+											  curbuf->b_p_ro)
+	{
+		curbuf->b_did_warn = TRUE;
+		MSG("Warning: Changing a readonly file");
+		mch_delay(1000L, TRUE);	/* give him some time to think about it */
+	}
+}
+
+/*
+ * Ask for a reply from the user, a 'y' or a 'n'.
+ * No other characters are accepted, the message is repeated until a valid
+ * reply is entered or CTRL-C is hit.
+ * If direct is TRUE, don't use vgetc but mch_inchar, don't get characters from
+ * any buffers but directly from the user.
+ *
+ * return the 'y' or 'n'
+ */
+	int
+ask_yesno(str, direct)
+	char_u	*str;
+	int		direct;
+{
+	int		r = ' ';
+	char_u	buf[20];
+	int		len = 0;
+	int		idx = 0;
+
+	if (exiting)				/* put terminal in raw mode for this question */
+		settmode(1);
+	while (r != 'y' && r != 'n')
+	{
+		(void)set_highlight('r');	/* same highlighting as for wait_return */
+		msg_highlight = TRUE;
+		smsg((char_u *)"%s (y/n)?", str);
+		if (direct)
+		{
+			flushbuf();
+			if (idx >= len)
+			{
+				len = mch_inchar(buf, 20, -1L);
+				idx = 0;
+			}
+			r = buf[idx++];
+		}
+		else
+			r = vgetc();
+		if (r == Ctrl('C') || r == ESC)
+			r = 'n';
+		msg_outchar(r);		/* show what you typed */
+		flushbuf();
+	}
+	return r;
+}
+
+/*
+ * get a number from the user
+ */
+	int
+get_number()
+{
+	int		n = 0;
+	int		c;
+
+	for (;;)
+	{
+		windgoto(msg_row, msg_col);
+		c = vgetc();
+		if (isdigit(c))
+		{
+			n = n * 10 + c - '0';
+			msg_outchar(c);
+		}
+		else if (c == K_DEL || c == K_BS || c == Ctrl('H'))
+		{
+			n /= 10;
+			MSG_OUTSTR("\b \b");
+		}
+		else if (c == CR || c == NL || c == Ctrl('C'))
+			break;
+	}
+	return n;
+}
+
+	void
+msgmore(n)
+	long n;
+{
+	long pn;
+
+	if (global_busy ||		/* no messages now, wait until global is finished */
+			keep_msg)		/* there is a message already, skip this one */
+		return;
+
+	if (n > 0)
+		pn = n;
+	else
+		pn = -n;
+
+	if (pn > p_report)
+	{
+		sprintf((char *)msg_buf, "%ld %s line%s %s",
+				pn, n > 0 ? "more" : "fewer", plural(pn),
+				got_int ? "(Interrupted)" : "");
+		if (msg(msg_buf))
+			keep_msg = msg_buf;
+	}
+}
+
+/*
+ * flush map and typeahead buffers and give a warning for an error
+ */
+	void
+beep_flush()
+{
+	flush_buffers(FALSE);
+	vim_beep();
+}
+
+/*
+ * give a warning for an error
+ */
+	void
+vim_beep()
+{
+	if (p_vb)
+	{
+#ifdef DJGPP
+		ScreenVisualBell();
+#else
+		outstr(T_VB);
+#endif
+	}
+	else
+	{
+#if defined MSDOS  ||  defined WIN32 /* ? gvr */
+		/*
+		 * The number of beeps outputted is reduced to avoid having to wait
+		 * for all the beeps to finish. This is only a problem on systems
+		 * where the beeps don't overlap.
+		 */
+		if (beep_count == 0 || beep_count == 10)
+		{
+			outchar('\007');
+			beep_count = 1;
+		}
+		else
+			++beep_count;
+#else
+		outchar('\007');
+#endif
+	}
+}
+
+/*
+ * To get the "real" home directory:
+ * - get value of $HOME
+ * For Unix:
+ *	- go to that directory
+ *	- do mch_dirname() to get the real name of that directory.
+ *	This also works with mounts and links.
+ *	Don't do this for MS-DOS, it will change the "current dir" for a drive.
+ */
+static char_u	*homedir = NULL;
+
+	void
+init_homedir()
+{
+	char_u	*var;
+
+	var = vim_getenv((char_u *)"HOME");
+#if defined(OS2) || defined(MSDOS) || defined(WIN32)
+	/*
+	 * Default home dir is C:/
+	 * Best assumption we can make in such a situation.
+	 */
+	if (var == NULL)
+		var = "C:/";
+#endif
+	if (var != NULL)
+	{
+#ifdef UNIX
+		if (mch_dirname(NameBuff, MAXPATHL) == OK)
+		{
+			if (!vim_chdir((char *)var) && mch_dirname(IObuff, IOSIZE) == OK)
+				var = IObuff;
+			vim_chdir((char *)NameBuff);
+		}
+#endif
+		homedir = strsave(var);
+	}
+}
+
+/* 
+ * Expand environment variable with path name.
+ * For Unix and OS/2 "~/" is also expanded, like $HOME.
+ * If anything fails no expansion is done and dst equals src.
+ * Note that IObuff must NOT be used as either src or dst!  This is because
+ * vim_getenv() may use IObuff to do its expansion.
+ */
+	void
+expand_env(src, dst, dstlen)
+	char_u	*src;			/* input string e.g. "$HOME/vim.hlp" */
+	char_u	*dst;			/* where to put the result */
+	int		dstlen;			/* maximum length of the result */
+{
+	char_u	*tail;
+	int		c;
+	char_u	*var;
+	int		copy_char;
+#if defined(UNIX) || defined(OS2)
+	int		mustfree;
+	int		at_start = TRUE;
+#endif
+
+	src = skipwhite(src);
+	--dstlen;				/* leave one char space for "\," */
+	while (*src && dstlen > 0)
+	{
+		copy_char = TRUE;
+		if (*src == '$'
+#if defined(UNIX) || defined(OS2)
+						|| (*src == '~' && at_start)
+#endif
+													)
+		{
+#if defined(UNIX) || defined(OS2)
+			mustfree = FALSE;
+
+			/*
+			 * The variable name is copied into dst temporarily, because it may
+			 * be a string in read-only memory and a NUL needs to be inserted.
+			 */
+			if (*src == '$')							/* environment var */
+			{
+#endif
+				tail = src + 1;
+				var = dst;
+				c = dstlen - 1;
+				while (c-- > 0 && *tail && isidchar(*tail))
+#ifdef OS2
+				{	/* env vars only in uppercase */
+					*var++ = toupper(*tail);	/* toupper() may be a macro! */
+					tail++;
+				}
+#else
+					*var++ = *tail++;
+#endif
+				*var = NUL;
+#if defined(OS2) || defined(MSDOS) || defined(WIN32)
+				/* use "C:/" when $HOME is not set */
+				if (STRCMP(dst, "HOME") == 0)
+					var = homedir;
+				else
+#endif
+					var = vim_getenv(dst);
+#if defined(UNIX) || defined(OS2)
+			}
+														/* home directory */
+			else if (src[1] == NUL ||
+							  vim_strchr((char_u *)"/ ,\t\n", src[1]) != NULL)
+			{
+				var = homedir;
+				tail = src + 1;
+			}
+			else										/* user directory */
+# ifdef OS2
+			{
+				/* cannot expand user's home directory, so don't try */
+				var = NULL;
+				tail = "";	/* shut gcc up about "may be used uninitialized" */
+			}
+# else
+			{
+				/*
+				 * Copy ~user to dst[], so we can put a NUL after it.
+				 */
+				tail = src;
+				var = dst;
+				c = dstlen - 1;
+				while (c-- > 0 && *tail &&
+									   isfilechar(*tail) && !ispathsep(*tail))
+					*var++ = *tail++;
+				*var = NUL;
+
+				/*
+				 * If the system supports getpwnam(), use it.
+				 * Otherwise, or if getpwnam() fails, the shell is used to
+				 * expand ~user.  This is slower and may fail if the shell
+				 * does not support ~user (old versions of /bin/sh).
+				 */
+#  if defined(HAVE_GETPWNAM) && defined(HAVE_PWD_H)
+				{
+					struct passwd *pw;
+
+					pw = getpwnam((char *)dst + 1);
+					if (pw != NULL)
+						var = (char_u *)pw->pw_dir;
+					else
+						var = NULL;
+				}
+				if (var == NULL)
+#  endif
+				{
+					var = ExpandOne(dst, NULL, 0, WILD_EXPAND_FREE);
+					mustfree = TRUE;
+				}
+			}
+# endif /* OS2 */
+#endif /* UNIX || OS2 */
+			if (var != NULL && *var != NUL &&
+						  (STRLEN(var) + STRLEN(tail) + 1 < (unsigned)dstlen))
+			{
+				STRCPY(dst, var);
+				dstlen -= STRLEN(var);
+				dst += STRLEN(var);
+					/* if var[] ends in a path separator and tail[] starts
+					 * with it, skip a character */
+				if (*var && ispathsep(*(dst-1)) && ispathsep(*tail))
+					++tail;
+				src = tail;
+				copy_char = FALSE;
+			}
+#if defined(UNIX) || defined(OS2)
+			if (mustfree)
+				vim_free(var);
+#endif
+		}
+
+		if (copy_char)		/* copy at least one char */
+		{
+#if defined(UNIX) || defined(OS2)
+			/*
+			 * Recogize the start of a new name, for '~'.
+			 */
+			at_start = FALSE;
+#endif
+			if (src[0] == '\\')
+			{
+				*dst++ = *src++;
+				--dstlen;
+			}
+#if defined(UNIX) || defined(OS2)
+			else if (src[0] == ' ' || src[0] == ',')
+				at_start = TRUE;
+#endif
+			*dst++ = *src++;
+			--dstlen;
+		}
+	}
+	*dst = NUL;
+}
+
+/* 
+ * Replace home directory by "~/" in each space or comma separated filename in
+ * 'src'. If anything fails (except when out of space) dst equals src.
+ */
+	void
+home_replace(buf, src, dst, dstlen)
+	BUF		*buf;			/* when not NULL, check for help files */
+	char_u	*src;			/* input file name */
+	char_u	*dst;			/* where to put the result */
+	int		dstlen;			/* maximum length of the result */
+{
+	size_t	dirlen = 0, envlen = 0;
+	size_t	len;
+	char_u	*homedir_env;
+	char_u	*p;
+
+	if (src == NULL)
+	{
+		*dst = NUL;
+		return;
+	}
+
+	/*
+	 * If the file is a help file, remove the path completely.
+	 */
+	if (buf != NULL && buf->b_help)
+	{
+		STRCPY(dst, gettail(src));
+		return;
+	}
+
+	/*
+	 * We check both the value of the $HOME environment variable and the
+	 * "real" home directory.
+	 */
+	if (homedir != NULL)
+		dirlen = STRLEN(homedir);
+	homedir_env = vim_getenv((char_u *)"HOME");
+	if (homedir_env != NULL)
+		envlen = STRLEN(homedir_env);
+
+	src = skipwhite(src);
+	while (*src && dstlen > 0)
+	{
+		/*
+		 * Here we are at the beginning of a filename.
+		 * First, check to see if the beginning of the filename matches
+		 * $HOME or the "real" home directory. Check that there is a '/'
+		 * after the match (so that if e.g. the file is "/home/pieter/bla",
+		 * and the home directory is "/home/piet", the file does not end up
+		 * as "~er/bla" (which would seem to indicate the file "bla" in user
+		 * er's home directory)).
+		 */
+		p = homedir;
+		len = dirlen;
+		for (;;)
+		{
+			if (len && fnamencmp(src, p, len) == 0 && (ispathsep(src[len]) ||
+					   src[len] == ',' || src[len] == ' ' || src[len] == NUL))
+			{
+				src += len;
+				if (--dstlen > 0)
+					*dst++ = '~';
+				/*
+				 * If it's just the home directory, make it "~/".
+				 */
+				if (!ispathsep(src[0]) && --dstlen > 0)
+					*dst++ = '/';
+			}
+			if (p == homedir_env)
+				break;
+			p = homedir_env;
+			len = envlen;
+		}
+
+		/* skip to separator: space or comma */
+		while (*src && *src != ',' && *src != ' ' && --dstlen > 0)
+			*dst++ = *src++;
+		/* skip separator */
+		while ((*src == ' ' || *src == ',') && --dstlen > 0)
+			*dst++ = *src++;
+	}
+	/* if (dstlen == 0) out of space, what to do??? */
+
+	*dst = NUL;
+}
+
+/*
+ * Like home_replace, store the replaced string in allocated memory.
+ * When something fails, NULL is returned.
+ */
+	char_u	*
+home_replace_save(buf, src)
+	BUF		*buf;			/* when not NULL, check for help files */
+	char_u	*src;			/* input file name */
+{
+	char_u		*dst;
+	unsigned	len;
+
+	if (src == NULL)		/* just in case */
+		len = 3;
+	else
+		len = STRLEN(src) + 3;		/* extra space for "~/" and trailing NUL */
+	dst = alloc(len);
+	if (dst != NULL)
+		home_replace(buf, src, dst, len);
+	return dst;
+}
+
+/*
+ * Compare two file names and return:
+ * FPC_SAME   if they both exist and are the same file.
+ * FPC_DIFF   if they both exist and are different files.
+ * FPC_NOTX   if they both don't exist.
+ * FPC_DIFFX  if one of them doesn't exist.
+ * For the first name environment variables are expanded
+ */
+	int
+fullpathcmp(s1, s2)
+	char_u *s1, *s2;
+{
+#ifdef UNIX
+	char_u			buf1[MAXPATHL];
+	struct stat		st1, st2;
+	int				r1, r2;
+
+	expand_env(s1, buf1, MAXPATHL);
+	r1 = stat((char *)buf1, &st1);
+	r2 = stat((char *)s2, &st2);
+	if (r1 != 0 && r2 != 0)
+		return FPC_NOTX;
+	if (r1 != 0 || r2 != 0)
+		return FPC_DIFFX;
+	if (st1.st_dev == st2.st_dev && st1.st_ino == st2.st_ino)
+		return FPC_SAME;
+	return FPC_DIFF;
+#else
+	char_u	*buf1 = NULL;
+	char_u	*buf2 = NULL;
+	int		retval = FPC_DIFF;
+	int		r1, r2;
+	
+	if ((buf1 = alloc(MAXPATHL)) != NULL && (buf2 = alloc(MAXPATHL)) != NULL)
+	{
+		expand_env(s1, buf2, MAXPATHL);
+		/*
+		 * If FullName() failed, the file probably doesn't exist.
+		 */
+		r1 = FullName(buf2, buf1, MAXPATHL, FALSE);
+		r2 = FullName(s2, buf2, MAXPATHL, FALSE);
+		if (r1 != OK && r2 != OK)
+			retval = FPC_NOTX;
+		else if (r1 != OK || r2 != OK)
+			retval = FPC_DIFFX;
+		else if (fnamecmp(buf1, buf2))
+			retval = FPC_DIFF;
+		else
+			retval = FPC_SAME;
+	}
+	vim_free(buf1);
+	vim_free(buf2);
+	return retval;
+#endif
+}
+
+/*
+ * get the tail of a path: the file name.
+ */
+	char_u *
+gettail(fname)
+	char_u *fname;
+{
+	register char_u *p1, *p2;
+
+	if (fname == NULL)
+		return (char_u *)"";
+	for (p1 = p2 = fname; *p2; ++p2)	/* find last part of path */
+	{
+		if (ispathsep(*p2))
+			p1 = p2 + 1;
+	}
+	return p1;
+}
+
+/*
+ * return TRUE if 'c' is a path separator.
+ */
+	int
+ispathsep(c)
+	int c;
+{
+#ifdef UNIX
+	return (c == PATHSEP);		/* UNIX has ':' inside file names */
+#else
+# ifdef BACKSLASH_IN_FILENAME
+	return (c == ':' || c == PATHSEP || c == '\\');
+# else
+	return (c == ':' || c == PATHSEP);
+# endif
+#endif
+}
+
+/*
+ * Concatenate filenames fname1 and fname2 into allocated memory.
+ * Only add a '/' when 'sep' is TRUE and it is neccesary.
+ */
+	char_u	*
+concat_fnames(fname1, fname2, sep)
+	char_u	*fname1;
+	char_u	*fname2;
+	int		sep;
+{
+	char_u	*dest;
+
+	dest = alloc((unsigned)(STRLEN(fname1) + STRLEN(fname2) + 2));
+	if (dest != NULL)
+	{
+		STRCPY(dest, fname1);
+		if (sep && *dest && !ispathsep(*(dest + STRLEN(dest) - 1)))
+			STRCAT(dest, PATHSEPSTR);
+		STRCAT(dest, fname2);
+	}
+	return dest;
+}
+
+/*
+ * FullName_save - Make an allocated copy of a full file name.
+ * Returns NULL when failed.
+ */
+	char_u 	*
+FullName_save(fname)
+	char_u		*fname;
+{
+	char_u		*buf;
+	char_u		*new_fname = NULL;
+
+	buf = alloc((unsigned)MAXPATHL);
+	if (buf != NULL)
+	{
+		if (FullName(fname, buf, MAXPATHL, FALSE) != FAIL)
+			new_fname = strsave(buf);
+		vim_free(buf);
+	}
+	return new_fname;
+}
+
+#ifdef CINDENT
+
+/*
+ * Functions for C-indenting.
+ * Most of this originally comes from Eric Fischer.
+ */
+/*
+ * Below "XXX" means that this function may unlock the current line.
+ */
+
+static int		isdefault __ARGS((char_u *));
+static char_u	*after_label __ARGS((char_u *l));
+static int		get_indent_nolabel __ARGS((linenr_t lnum));
+static int		skip_label __ARGS((linenr_t, char_u **pp, int ind_maxcomment));
+static int		ispreproc __ARGS((char_u *));
+static int		iscomment __ARGS((char_u *));
+static int		commentorempty __ARGS((char_u *));
+static int		isterminated __ARGS((char_u *));
+static int		isfuncdecl __ARGS((char_u *));
+static char_u	*skip_string __ARGS((char_u *p));
+static int		isif __ARGS((char_u *));
+static int		iselse __ARGS((char_u *));
+static int		isdo __ARGS((char_u *));
+static int		iswhileofdo __ARGS((char_u *, linenr_t, int));
+static FPOS		*find_start_comment __ARGS((int ind_maxcomment));
+static FPOS		*find_start_brace __ARGS((int));
+static FPOS		*find_match_paren __ARGS((int, int));
+static int		find_last_paren __ARGS((char_u *l));
+static int		find_match __ARGS((int lookfor, linenr_t ourscope,
+						int ind_maxparen, int ind_maxcomment));
+
+/*
+ * Recognize a label: "label:".
+ * Note: curwin->w_cursor must be where we are looking for the label.
+ */
+	int
+islabel(ind_maxcomment)			/* XXX */
+	int			ind_maxcomment;
+{
+	char_u		*s;
+
+	s = skipwhite(ml_get_curline());
+
+	/*
+	 * Exclude "default" from labels, since it should be indented
+	 * like a switch label.
+	 */
+
+	if (isdefault(s))
+		return FALSE;
+
+	if (!isidchar(*s))		/* need at least one ID character */
+		return FALSE;
+
+	while (isidchar(*s))
+		s++;
+
+	s = skipwhite(s);
+
+	/* "::" is not a label, it's C++ */
+	if (*s == ':' && s[1] != ':')
+	{
+		/*
+		 * Only accept a label if the previous line is terminated or is a case
+		 * label.
+		 */
+		FPOS	cursor_save;
+		FPOS	*trypos;
+		char_u	*line;
+
+		cursor_save = curwin->w_cursor;
+		while (curwin->w_cursor.lnum > 1)
+		{
+			--curwin->w_cursor.lnum;
+
+			/*
+			 * If we're in a comment now, skip to the start of the comment.
+			 */
+			curwin->w_cursor.col = 0;
+			if ((trypos = find_start_comment(ind_maxcomment)) != NULL) /* XXX */
+				curwin->w_cursor = *trypos;
+
+			line = ml_get_curline();
+			if (ispreproc(line))		/* ignore #defines, #if, etc. */
+				continue;
+			if (commentorempty(line))
+				continue;
+
+			curwin->w_cursor = cursor_save;
+			if (isterminated(line) || iscase(line))
+				return TRUE;
+			return FALSE;
+		}
+		curwin->w_cursor = cursor_save;
+		return TRUE;			/* label at start of file??? */
+	}
+	return FALSE;
+}
+
+/*
+ * Recognize a switch label: "case .*:" or "default:".
+ */
+	 int
+iscase(s)
+	char_u *s;
+{
+	s = skipwhite(s);
+	if (STRNCMP(s, "case", 4) == 0 && !isidchar(s[4]))
+	{
+		for (s += 4; *s; ++s)
+			if (*s == ':')
+			{
+				if (s[1] == ':')		/* skip over "::" for C++ */
+					++s;
+				else
+					return TRUE;
+			}
+		return FALSE;
+	}
+
+	if (isdefault(s))
+		return TRUE;
+	return FALSE;
+}
+
+/*
+ * Recognize a "default" switch label.
+ */
+	static int
+isdefault(s)
+	char_u	*s;
+{
+	return (STRNCMP(s, "default", 7) == 0 &&
+			*(s = skipwhite(s + 7)) == ':' &&
+			s[1] != ':');
+}
+
+/*
+ * Return a pointer to the first non-empty non-comment character after a ':'.
+ * Return NULL if not found.
+ *        case 234:    a = b;
+ *                     ^
+ */
+	static char_u *
+after_label(l)
+	char_u	*l;
+{
+	for ( ; *l; ++l)
+		if (*l == ':')
+		{
+			if (l[1] == ':')		/* skip over "::" for C++ */
+				++l;
+			else
+				break;
+		}
+	if (*l == NUL)
+		return NULL;
+	l = skipwhite(l + 1);
+	if (commentorempty(l))
+		return NULL;
+	return l;
+}
+
+/*
+ * Get indent of line "lnum", skipping a label.
+ * Return 0 if there is nothing after the label.
+ */
+	static int
+get_indent_nolabel(lnum)				/* XXX */
+	linenr_t	lnum;
+{
+	char_u		*l;
+	FPOS		fp;
+	colnr_t		col;
+	char_u		*p;
+
+	l = ml_get(lnum);
+	p = after_label(l);
+	if (p == NULL)
+		return 0;
+
+	fp.col = p - l;
+	fp.lnum = lnum;
+	getvcol(curwin, &fp, &col, NULL, NULL);
+	return (int)col;
+}
+
+/*
+ * Find indent for line "lnum", ignoring any case or jump label.
+ * Also return a pointer to the text (after the label).
+ *   label:		if (asdf && asdfasdf)
+ *              ^
+ */
+	static int
+skip_label(lnum, pp, ind_maxcomment)
+	linenr_t	lnum;
+	char_u		**pp;
+	int			ind_maxcomment;
+{
+	char_u		*l;
+	int			amount;
+	FPOS		cursor_save;
+
+	cursor_save = curwin->w_cursor;
+	curwin->w_cursor.lnum = lnum;
+	l = ml_get_curline();
+	if (iscase(l) || islabel(ind_maxcomment)) /* XXX */
+	{
+		amount = get_indent_nolabel(lnum);
+		l = after_label(ml_get_curline());
+		if (l == NULL)			/* just in case */
+			l = ml_get_curline();
+	}
+	else
+	{
+		amount = get_indent();
+		l = ml_get_curline();
+	}
+	*pp = l;
+
+	curwin->w_cursor = cursor_save;
+	return amount;
+}
+
+/*
+ * Recognize a preprocessor statement: Any line that starts with '#'.
+ */
+	static int
+ispreproc(s)
+	char_u *s;
+{
+	s = skipwhite(s);
+	if (*s == '#')
+		return TRUE;
+	return 0;
+}
+
+/*
+ * Recognize the start of a C or C++ comment.
+ */
+	static int
+iscomment(p)
+	char_u	*p;
+{
+	return (p[0] == '/' && (p[1] == '*' || p[1] == '/'));
+}
+
+/*
+ * Recognize an empty or comment line.
+ */
+	static int
+commentorempty(s)
+	char_u *s;
+{
+	s = skipwhite(s);
+	if (*s == NUL || iscomment(s))
+		return TRUE;
+	return FALSE;
+}
+
+/*
+ * Recognize a line that starts with '{' or '}', or ends with ';' or '}'.
+ * Also consider a line terminated if it ends in ','.  This is not 100%
+ * correct, but this mostly means we are in initializations and then it's OK.
+ */
+	static int
+isterminated(s)
+	char_u *s;
+{
+	s = skipwhite(s);
+
+	if (*s == '{' || *s == '}')
+		return TRUE;
+
+	while (*s)
+	{
+		if (iscomment(s))		/* at start of comment ignore rest of line */
+			return FALSE;
+		s = skip_string(s);
+		if ((*s == ';' || *s == '{' || *s == ',') && commentorempty(s + 1))
+			return TRUE;
+		s++;
+	}
+	return FALSE;
+}
+
+/*
+ * Recognize the basic picture of a function declaration -- it needs to
+ * have an open paren somewhere and a close paren at the end of the line and
+ * no semicolons anywhere.
+ */
+	static int
+isfuncdecl(s)
+	char_u *s;
+{
+	while (*s && *s != '(' && *s != ';')
+		if (iscomment(s++))
+			return FALSE;			/* comment before () ??? */
+	if (*s != '(')
+		return FALSE;				/* ';' before any () or no '(' */
+
+	while (*s && *s != ';')
+	{
+		if (*s == ')' && commentorempty(s + 1))
+			return TRUE;
+		if (iscomment(s++))
+			return FALSE;			/* comment between ( and ) ??? */
+	}
+	return FALSE;
+}
+
+/*
+ * Skip over a "string" and a 'c' character.
+ */
+	static char_u *
+skip_string(p)
+	char_u	*p;
+{
+	int		i;
+
+	/*
+	 * We loop, because strings may be concatenated: "date""time".
+	 */
+	for ( ; ; ++p)
+	{
+		if (p[0] == '\'')					/* 'c' or '\n' or '\000' */
+		{
+			if (!p[1])						/* ' at end of line */
+				break;
+			i = 2;
+			if (p[1] == '\\')				/* '\n' or '\000' */
+			{
+				++i;
+				while (isdigit(p[i - 1]))	/* '\000' */
+					++i;
+			}
+			if (p[i] == '\'')				/* check for trailing ' */
+			{
+				p += i;
+				continue;
+			}
+		}
+		else if (p[0] == '"')				/* start of string */
+		{
+			for (++p; p[0]; ++p)
+			{
+				if (p[0] == '\\' && p[1])
+					++p;
+				else if (p[0] == '"')		/* end of string */
+					break;
+			}
+			continue;
+		}
+		break;								/* no string found */
+	}
+	if (!*p)
+		--p;								/* backup from NUL */
+	return p;
+}
+
+	static int
+isif(p)
+	char_u	*p;
+{
+	return (STRNCMP(p, "if", 2) == 0 && !isidchar(p[2]));
+}
+
+	static int
+iselse(p)
+	char_u	*p;
+{
+	return (STRNCMP(p, "else", 4) == 0 && !isidchar(p[4]));
+}
+
+	static int
+isdo(p)
+	char_u	*p;
+{
+	return (STRNCMP(p, "do", 2) == 0 && !isidchar(p[2]));
+}
+
+/*
+ * Check if this is a "while" that should have a matching "do".
+ * We only accept a "while (condition) ;", with only white space between the
+ * ')' and ';'. The condition may be spread over several lines.
+ */
+	static int
+iswhileofdo(p, lnum, ind_maxparen)			/* XXX */
+	char_u		*p;
+	linenr_t	lnum;
+	int			ind_maxparen;
+{
+	FPOS		cursor_save;
+	FPOS		*trypos;
+	int			retval = FALSE;
+
+	p = skipwhite(p);
+	if (STRNCMP(p, "while", 5) == 0 && !isidchar(p[5]))
+	{
+		cursor_save = curwin->w_cursor;
+		curwin->w_cursor.lnum = lnum;
+		curwin->w_cursor.col = 0;
+		if ((trypos = findmatchlimit(0, 0, ind_maxparen)) != NULL)
+		{
+			p = ml_get_pos(trypos) + 1;
+			p = skipwhite(p);
+			if (*p == ';')
+				retval = TRUE;
+		}
+		curwin->w_cursor = cursor_save;
+	}
+	return retval;
+}
+
+/*
+ * Find the start of a comment, not knowing if we are in a comment right now.
+ * Search starts at w_cursor.lnum and goes backwards.
+ */
+	static FPOS *
+find_start_comment(ind_maxcomment)			/* XXX */
+	int			ind_maxcomment;
+{
+	FPOS		*pos;
+	char_u		*line;
+	char_u		*p;
+
+	if ((pos = findmatchlimit('*', FM_BACKWARD, ind_maxcomment)) == NULL)
+		return NULL;
+
+	/*
+	 * Check if the comment start we found is inside a string.
+	 */
+	line = ml_get(pos->lnum);
+	for (p = line; *p && (unsigned)(p - line) < pos->col; ++p)
+		p = skip_string(p);
+	if ((unsigned)(p - line) > pos->col)
+		return NULL;
+	return pos;
+}
+
+/*
+ * Find the '{' at the start of the block we are in.
+ * Return NULL of no match found.
+ * Ignore a '{' that is in a comment, makes indenting the next three lines
+ * work. */
+/* foo()	*/
+/* {		*/
+/* }		*/
+
+	static FPOS *
+find_start_brace(ind_maxcomment)			/* XXX */
+	int			ind_maxcomment;
+{
+	FPOS		cursor_save;
+	FPOS		*trypos;
+	FPOS		*pos;
+	static FPOS	pos_copy;
+
+	cursor_save = curwin->w_cursor;
+	while ((trypos = findmatchlimit('{', FM_BLOCKSTOP, 0)) != NULL)
+	{
+		pos_copy = *trypos;		/* copy FPOS, next findmatch will change it */
+		trypos = &pos_copy;
+		curwin->w_cursor = *trypos;
+		pos = NULL;
+		if (!iscomment(skipwhite(ml_get(trypos->lnum))) &&
+				 (pos = find_start_comment(ind_maxcomment)) == NULL) /* XXX */
+			break;
+		if (pos != NULL)
+			curwin->w_cursor.lnum = pos->lnum;
+	}
+	curwin->w_cursor = cursor_save;
+	return trypos;
+}
+
+/*
+ * Find the matching '(', failing if it is in a comment.
+ * Return NULL of no match found.
+ */
+	static FPOS *
+find_match_paren(ind_maxparen, ind_maxcomment)		/* XXX */
+	int			ind_maxparen;
+	int			ind_maxcomment;
+{
+	FPOS		cursor_save;
+	FPOS		*trypos;
+	static FPOS	pos_copy;
+
+	cursor_save = curwin->w_cursor;
+	if ((trypos = findmatchlimit('(', 0, ind_maxparen)) != NULL)
+	{
+		if (iscomment(skipwhite(ml_get(trypos->lnum))))
+			trypos = NULL;
+		else
+		{
+			pos_copy = *trypos;		/* copy trypos, findmatch will change it */
+			trypos = &pos_copy;
+			curwin->w_cursor = *trypos;
+			if (find_start_comment(ind_maxcomment) != NULL)	/* XXX */
+				trypos = NULL;
+		}
+	}
+	curwin->w_cursor = cursor_save;
+	return trypos;
+}
+
+/*
+ * Set w_cursor.col to the column number of the last ')' in line "l".
+ */
+	static int
+find_last_paren(l)
+	char_u *l;
+{
+	int		i;
+	int		retval = FALSE;
+
+	curwin->w_cursor.col = 0;				/* default is start of line */
+
+	for (i = 0; l[i]; i++)
+	{
+		i = skip_string(l + i) - l;			/* ignore parens in quotes */
+		if (l[i] == ')')
+		{
+			curwin->w_cursor.col = i;
+			retval = TRUE;
+		}
+	}
+	return retval;
+}
+
+	int
+get_c_indent()
+{
+	/*
+	 * spaces from a block's opening brace the prevailing indent for that
+	 * block should be
+	 */
+	int ind_level = curbuf->b_p_sw;
+
+	/*
+	 * spaces from the edge of the line an open brace that's at the end of a
+	 * line is imagined to be.
+	 */
+	int ind_open_imag = 0;
+
+	/*
+	 * spaces from the prevailing indent for a line that is not precededof by
+	 * an opening brace.
+	 */
+	int ind_no_brace = 0;
+
+	/*
+	 * column where the first { of a function should be located
+	 */
+	int ind_first_open = 0;
+
+	/*
+	 * spaces from the prevailing indent a leftmost open brace should be
+	 * located
+	 */
+	int ind_open_extra = 0;
+
+	/*
+	 * spaces from the matching open brace (real location for one at the left
+	 * edge; imaginary location from one that ends a line) the matching close
+	 * brace should be located
+	 */
+	int ind_close_extra = 0;
+
+	/*
+	 * spaces from the edge of the line an open brace sitting in the leftmost
+	 * column is imagined to be
+	 */
+	int ind_open_left_imag = 0;
+
+	/*
+	 * spaces from the switch() indent a "case xx" label should be located
+	 */
+	int ind_case = curbuf->b_p_sw;
+
+	/*
+	 * spaces from the "case xx:" code after a switch() should be located
+	 */
+	int ind_case_code = curbuf->b_p_sw;
+
+	/*
+	 * amount K&R-style parameters should be indented
+	 */
+	int ind_param = curbuf->b_p_sw;
+
+	/*
+	 * amount a function type spec should be indented
+	 */
+	int ind_func_type = curbuf->b_p_sw;
+
+	/*
+	 * additional spaces beyond the prevailing indent a continuation line
+	 * should be located
+	 */
+	int ind_continuation = curbuf->b_p_sw;
+
+	/*
+	 * spaces from the indent of the line with an unclosed parentheses
+	 */
+	int ind_unclosed = curbuf->b_p_sw * 2;
+
+	/*
+	 * spaces from the comment opener when there is nothing after it.
+	 */
+	int ind_in_comment = 3;
+
+	/*
+	 * max lines to search for an open paren
+	 */
+	int ind_maxparen = 20;
+
+	/*
+	 * max lines to search for an open comment
+	 */
+	int ind_maxcomment = 30;
+
+	FPOS		cur_curpos;
+	int			amount;
+	int			scope_amount;
+	int			cur_amount;
+	colnr_t		col;
+	char_u		*theline;
+	char_u		*linecopy;
+	FPOS		*trypos;
+	FPOS		our_paren_pos;
+	char_u		*start;
+	int			start_brace;
+#define BRACE_IN_COL0	1			/* '{' is in comumn 0 */
+#define BRACE_AT_START	2			/* '{' is at start of line */
+#define BRACE_AT_END	3			/* '{' is at end of line */
+	linenr_t	ourscope;
+	char_u		*l;
+	char_u		*look;
+	int			lookfor;
+#define LOOKFOR_IF		1
+#define LOOKFOR_DO		2
+#define LOOKFOR_CASE	3
+#define LOOKFOR_ANY		4
+#define LOOKFOR_TERM	5
+#define LOOKFOR_UNTERM	6
+	int			whilelevel;
+	linenr_t	lnum;
+	char_u		*options;
+	int			fraction = 0;		/* init for GCC */
+	int			divider;
+	int			n;
+
+	for (options = curbuf->b_p_cino; *options; )
+	{
+		l = options++;
+		if (*options == '-')
+			++options;
+		n = getdigits(&options);
+		divider = 0;
+		if (*options == '.')		/* ".5s" means a fraction */
+		{
+			fraction = atol((char *)++options);
+			while (isdigit(*options))
+			{
+				++options;
+				if (divider)
+					divider *= 10;
+				else
+					divider = 10;
+			}
+		}
+		if (*options == 's')		/* "2s" means two times 'shiftwidth' */
+		{
+			if (n == 0 && fraction == 0)
+				n = curbuf->b_p_sw;		/* just "s" is one 'shiftwidth' */
+			else
+			{
+				n *= curbuf->b_p_sw;
+				if (divider)
+					n += (curbuf->b_p_sw * fraction + divider / 2) / divider;
+			}
+			++options;
+		}
+		if (l[1] == '-')
+			n = -n;
+		switch (*l)
+		{
+			case '>': ind_level = n; break;
+			case 'e': ind_open_imag = n; break;
+			case 'n': ind_no_brace = n; break;
+			case 'f': ind_first_open = n; break;
+			case '{': ind_open_extra = n; break;
+			case '}': ind_close_extra = n; break;
+			case '^': ind_open_left_imag = n; break;
+			case ':': ind_case = n; break;
+			case '=': ind_case_code = n; break;
+			case 'p': ind_param = n; break;
+			case 't': ind_func_type = n; break;
+			case 'c': ind_in_comment = n; break;
+			case '+': ind_continuation = n; break;
+			case '(': ind_unclosed = n; break;
+			case ')': ind_maxparen = n; break;
+			case '*': ind_maxcomment = n; break;
+		}
+	}
+
+	/* remember where the cursor was when we started */
+
+	cur_curpos = curwin->w_cursor;
+
+	/* get the current contents of the line.
+	 * This is required, because onle the most recent line obtained with
+	 * ml_get is valid! */
+
+	linecopy = strsave(ml_get(cur_curpos.lnum));
+	if (linecopy == NULL)
+		return 0;
+
+	/*
+	 * In insert mode and the cursor is on a ')' trunctate the line at the
+	 * cursor position.  We don't want to line up with the matching '(' when
+	 * inserting new stuff.
+	 */
+	if ((State & INSERT) && linecopy[curwin->w_cursor.col] == ')')
+		linecopy[curwin->w_cursor.col] = NUL;
+
+	theline = skipwhite(linecopy);
+
+	/* move the cursor to the start of the line */
+
+	curwin->w_cursor.col = 0;
+
+	/*
+	 * #defines and so on always go at the left when included in 'cinkeys'.
+	 */
+	if (*theline == '#' && (*linecopy == '#' || in_cinkeys('#', ' ', TRUE)))
+	{
+		amount = 0;
+	}
+
+	/* 
+	 * Is it a non-case label?  Then that goes at the left margin too.
+  	 */
+	else if (islabel(ind_maxcomment))		/* XXX */
+	{
+		amount = 0;
+	}
+
+	/* 
+	 * If we're inside a comment and not looking at the start of the
+	 * comment...
+	 */
+	else if (!iscomment(theline) &&
+			  (trypos = find_start_comment(ind_maxcomment)) != NULL) /* XXX */
+	{
+
+		/* find how indented the line beginning the comment is */
+		getvcol(curwin, trypos, &col, NULL, NULL);
+		amount = col;
+
+		/* if our line starts with an asterisk, line up with the
+		 * asterisk in the comment opener; otherwise, line up
+		 * with the first character of the comment text.
+		 */
+		if (theline[0] == '*')
+		{
+			amount += 1;
+		}
+		else
+		{
+			/*
+			 * If we are more than one line away from the comment opener, take
+			 * the indent of the previous non-empty line.
+			 * If we are just below the comment opener and there are any
+			 * white characters after it line up with the text after it.
+			 * up with them; otherwise, just use a single space.
+			 */
+			amount = -1;
+			for (lnum = cur_curpos.lnum - 1; lnum > trypos->lnum; --lnum)
+			{
+				if (linewhite(lnum))				/* skip blank lines */
+					continue;
+				amount = get_indent_lnum(lnum);		/* XXX */
+				break;
+			}
+			if (amount == -1)						/* use the comment opener */
+			{
+				start = ml_get(trypos->lnum);
+				look = start + trypos->col + 2;  	/* skip / and * */
+				if (*look)							/* if something after it */
+					trypos->col = skipwhite(look) - start;
+				getvcol(curwin, trypos, &col, NULL, NULL);
+				amount = col;
+				if (!*look)
+					amount += ind_in_comment;
+			}
+		}
+	}
+
+	/*
+	 * Are we inside parentheses?
+	 */												/* XXX */
+	else if ((trypos = find_match_paren(ind_maxparen, ind_maxcomment)) != NULL)
+	{
+		/*
+		 * If the matching paren is more than one line away, use the indent of
+		 * a previous non-empty line that matches the same paren.
+		 */
+		amount = -1;
+		our_paren_pos = *trypos;
+		if (theline[0] != ')')
+		{
+			for (lnum = cur_curpos.lnum - 1; lnum > our_paren_pos.lnum; --lnum)
+			{
+				l = skipwhite(ml_get(lnum));
+				if (commentorempty(l))		/* skip comment lines */
+					continue;
+				if (ispreproc(l))			/* ignore #defines, #if, etc. */
+					continue;
+				curwin->w_cursor.lnum = lnum;
+				/* XXX */
+				if ((trypos = find_match_paren(ind_maxparen,
+												   ind_maxcomment)) != NULL &&
+										 trypos->lnum == our_paren_pos.lnum &&
+											 trypos->col == our_paren_pos.col)
+				{
+					amount = get_indent_lnum(lnum);		/* XXX */
+					break;
+				}
+			}
+		}
+
+		/*
+		 * Line up with line where the matching paren is.
+		 * If the line starts with a '(' or the indent for unclosed
+		 * parentheses is zero, line up with the unclosed parentheses.
+		 */
+		if (amount == -1)
+		{
+			amount = skip_label(our_paren_pos.lnum, &look, ind_maxcomment);
+			if (theline[0] == ')' || ind_unclosed == 0 ||
+													  *skipwhite(look) == '(')
+			{
+
+				/* 
+				 * If we're looking at a close paren, line up right there;
+				 * otherwise, line up with the next non-white character.
+				 */
+				if (theline[0] != ')')
+				{
+					col = our_paren_pos.col + 1;
+					look = ml_get(our_paren_pos.lnum);
+					while (vim_iswhite(look[col]))
+						col++;
+					if (look[col] != NUL)		/* In case of trailing space */
+						our_paren_pos.col = col;
+					else
+						our_paren_pos.col++;
+				}
+
+				/*
+				 * Find how indented the paren is, or the character after it if
+				 * we did the above "if".
+				 */
+				getvcol(curwin, &our_paren_pos, &col, NULL, NULL);
+				amount = col;
+			}
+			else
+				amount += ind_unclosed;
+		}
+	}
+
+	/*
+	 * Are we at least inside braces, then?
+	 */
+	else if ((trypos = find_start_brace(ind_maxcomment)) != NULL) /* XXX */
+	{
+		ourscope = trypos->lnum;
+		start = ml_get(ourscope);
+
+		/* 
+		 * Now figure out how indented the line is in general.
+		 * If the brace was at the start of the line, we use that;
+		 * otherwise, check out the indentation of the line as
+		 * a whole and then add the "imaginary indent" to that.
+		 */
+		look = skipwhite(start);
+		if (*look == '{')
+		{
+			getvcol(curwin, trypos, &col, NULL, NULL);
+			amount = col;
+			if (*start == '{')
+				start_brace = BRACE_IN_COL0;
+			else
+				start_brace = BRACE_AT_START;
+		}
+		else
+		{
+			/* 
+			 * that opening brace might have been on a continuation
+			 * line.  if so, find the start of the line.
+			 */
+			curwin->w_cursor.lnum = ourscope;
+
+			/* 
+			 * position the cursor over the rightmost paren, so that
+			 * matching it will take us back to the start of the line.
+			 */
+			lnum = ourscope;
+			if (find_last_paren(start) &&
+					(trypos = find_match_paren(ind_maxparen,
+													 ind_maxcomment)) != NULL)
+				lnum = trypos->lnum;
+
+			/*
+			 * It could have been something like
+			 *     case 1: if (asdf &&
+			 *     				ldfd) {
+			 *     			}
+			 */
+			amount = skip_label(lnum, &l, ind_maxcomment);
+
+			start_brace = BRACE_AT_END;
+		}
+
+		/* 
+		 * if we're looking at a closing brace, that's where
+		 * we want to be.  otherwise, add the amount of room
+		 * that an indent is supposed to be.
+		 */
+		if (theline[0] == '}')
+		{
+			/* 
+			 * they may want closing braces to line up with something
+			 * other than the open brace.  indulge them, if so. 
+			 */
+			amount += ind_close_extra;
+		}
+		else
+		{
+			/* 
+			 * If we're looking at an "else", try to find an "if"
+			 * to match it with.
+			 * If we're looking at a "while", try to find a "do"
+			 * to match it with.
+			 */
+			lookfor = 0;
+			if (iselse(theline))
+				lookfor = LOOKFOR_IF;
+			else if (iswhileofdo(theline, cur_curpos.lnum, ind_maxparen))
+																	/* XXX */
+				lookfor = LOOKFOR_DO;
+			if (lookfor)
+			{
+				curwin->w_cursor.lnum = cur_curpos.lnum;
+				if (find_match(lookfor, ourscope, ind_maxparen,
+														ind_maxcomment) == OK)
+				{
+					amount = get_indent();		/* XXX */
+					goto theend;
+				}
+			}
+
+			/* 
+			 * We get here if we are not on an "while-of-do" or "else" (or
+			 * failed to find a matching "if").
+			 * Search backwards for something to line up with.
+			 * First set amount for when we don't find anything.
+			 */
+
+			/* 
+			 * if the '{' is  _really_ at the left margin, use the imaginary
+			 * location of a left-margin brace.  Otherwise, correct the
+			 * location for ind_open_extra.
+			 */
+
+			if (start_brace == BRACE_IN_COL0)		/* '{' is in column 0 */
+			{
+				amount = ind_open_left_imag;
+			}
+			else 
+			{
+				if (start_brace == BRACE_AT_END)	/* '{' is at end of line */
+					amount += ind_open_imag;
+				else
+				{
+					amount -= ind_open_extra;
+					if (amount < 0)
+						amount = 0;
+				}
+			}
+
+			if (iscase(theline))		/* it's a switch() label */
+			{
+				lookfor = LOOKFOR_CASE;	/* find a previous switch() label */
+				amount += ind_case;
+			}
+			else
+			{
+				lookfor = LOOKFOR_ANY;
+				amount += ind_level;	/* ind_level from start of block */
+			}
+			scope_amount = amount;
+			whilelevel = 0;
+
+			/*
+			 * Search backwards.  If we find something we recognize, line up
+			 * with that.
+			 *
+			 * if we're looking at an open brace, indent
+			 * the usual amount relative to the conditional
+			 * that opens the block.
+			 */
+			curwin->w_cursor = cur_curpos;
+			for (;;)
+			{
+				curwin->w_cursor.lnum--;
+				curwin->w_cursor.col = 0;
+
+				/*
+				 * If we went all the way back to the start of our scope, line
+				 * up with it.
+				 */
+				if (curwin->w_cursor.lnum <= ourscope)
+				{
+					if (lookfor == LOOKFOR_UNTERM)
+						amount += ind_continuation;
+					else if (lookfor != LOOKFOR_TERM)
+						amount = scope_amount;
+					break;
+				}
+
+				/*
+				 * If we're in a comment now, skip to the start of the comment.
+				 */											/* XXX */
+				if ((trypos = find_start_comment(ind_maxcomment)) != NULL)
+				{
+					curwin->w_cursor.lnum = trypos->lnum + 1;
+					continue;
+				}
+
+				l = ml_get_curline();
+
+				/*
+				 * If this is a switch() label, may line up relative to that.
+				 */
+				if (iscase(l))
+				{
+					/*
+					 *  case xx:
+					 * 	    c = 99 +		<- this indent plus continuation
+					 *->           here;
+					 */
+					if (lookfor == LOOKFOR_UNTERM)
+					{
+						amount += ind_continuation;
+						break;
+					}
+
+					/*
+					 *  case xx:		<- line up with this case
+					 *      x = 333;
+					 *  case yy:
+					 */
+					if (lookfor == LOOKFOR_CASE)
+					{
+						/*
+						 * Check that this case label is not for another
+						 * switch()
+						 */									/* XXX */
+						if ((trypos = find_start_brace(ind_maxcomment)) ==
+											 NULL || trypos->lnum == ourscope)
+						{
+							amount = get_indent();		/* XXX */
+							break;
+						}
+						continue;
+					}
+
+					n = get_indent_nolabel(curwin->w_cursor.lnum);  /* XXX */
+
+					/*
+					 *   case xx: if (cond)			<- line up with this if
+					 *                y = y + 1;
+					 * ->         s = 99;
+					 *
+					 *   case xx:
+					 *       if (cond)			<- line up with this line
+					 *           y = y + 1;
+					 * ->    s = 99;
+					 */
+					if (lookfor == LOOKFOR_TERM)
+					{
+						if (n)
+							amount = n;
+						break;
+					}
+
+					/*
+					 *   case xx: x = x + 1;		<- line up with this x
+					 * ->         y = y + 1;
+					 *
+					 *   case xx: if (cond)			<- line up with this if
+					 * ->              y = y + 1;
+					 */
+					if (n)
+					{
+						amount = n;
+						l = after_label(ml_get_curline());
+						if (l != NULL && is_cinword(l))
+							amount += ind_level + ind_no_brace;
+						break;
+					}
+
+					/*
+					 *   Try to get the indent of a statement before the
+					 *   switch label.  If nothing is found, line up relative
+					 *   to the switch label.
+					 *   	break;				<- may line up with this line
+					 *   case xx:
+					 * ->   y = 1;
+					 */
+					scope_amount = get_indent() + ind_case_code;	/* XXX */
+					lookfor = LOOKFOR_ANY;
+					continue;
+				}
+
+				/*
+				 * Looking for a switch() label, ignore other lines.
+				 */
+				if (lookfor == LOOKFOR_CASE)
+					continue;
+
+				/*
+				 * Ignore jump labels with nothing after them.
+				 */
+				if (islabel(ind_maxcomment))
+				{
+					l = after_label(ml_get_curline());
+					if (l == NULL || commentorempty(l))
+						continue;
+				}
+
+				/*
+				 * Ignore #defines, #if, etc.
+				 * Ignore comment and empty lines.
+				 * (need to get the line again, islabel() may have unlocked it)
+				 */
+				l = ml_get_curline();
+				if (ispreproc(l) || commentorempty(l))
+					continue;
+
+				/*
+				 * What happens next depends on the line being terminated.
+				 */
+				if (!isterminated(l))
+				{
+					/* 
+					 * if we're in the middle of a paren thing,
+					 * go back to the line that starts it so
+					 * we can get the right prevailing indent
+					 *     if ( foo &&
+					 *             	bar )
+					 */
+					/* 
+					 * position the cursor over the rightmost paren, so that
+					 * matching it will take us back to the start of the line.
+					 */
+					(void)find_last_paren(l);
+					if ((trypos = find_match_paren(ind_maxparen,
+													 ind_maxcomment)) != NULL)
+					{
+						/*
+						 * Check if we are on a case label now.  This is
+						 * handled above.
+						 *     case xx:  if ( asdf &&
+						 *                      asdf)
+						 */
+						curwin->w_cursor.lnum = trypos->lnum;
+						l = ml_get_curline();
+						if (iscase(l))
+						{
+							++curwin->w_cursor.lnum;
+							continue;
+						}
+					}
+
+					/*
+					 * Get indent and pointer to text for current line,
+					 * ignoring any jump label.		XXX
+					 */
+					cur_amount = skip_label(curwin->w_cursor.lnum,
+														  &l, ind_maxcomment);
+
+					/*
+					 * If this is just above the line we are indenting, and it
+					 * starts with a '{', line it up with this line.
+					 * 			while (not)
+					 * ->		{
+					 * 			}
+					 */
+					if (lookfor != LOOKFOR_TERM && theline[0] == '{')
+					{
+						amount = cur_amount + ind_open_extra;
+						break;
+					}
+
+					/*
+					 * Check if we are after an "if", "while", etc.
+					 */
+					if (is_cinword(l))
+					{
+						/*
+						 * Found an unterminated line after an if (), line up
+						 * with the last one.
+						 *	 if (cond)
+						 *			100 +
+						 * ->			here;
+						 */
+						if (lookfor == LOOKFOR_UNTERM)
+						{
+							amount += ind_continuation;
+							break;
+						}
+
+						/*
+						 * If this is just above the line we are indenting, we
+						 * are finished.
+						 * 			while (not)
+						 * ->			here;
+						 * Otherwise this indent can be used when the line
+						 * before this is terminated.
+						 * 		yyy;
+						 * 		if (stat)
+						 * 			while (not)
+						 * 				xxx;
+						 * ->	here;
+						 */
+						amount = cur_amount;
+						if (lookfor != LOOKFOR_TERM)
+						{
+							amount += ind_level + ind_no_brace;
+							break;
+						}
+
+						/*
+						 * Special trick: when expecting the while () after a
+						 * do, line up with the while()
+						 *     do
+						 *          x = 1;
+						 * ->  here
+						 */
+						l = skipwhite(ml_get_curline());
+						if (isdo(l))
+						{
+							if (whilelevel == 0)
+								break;
+							--whilelevel;
+						}
+
+						/*
+						 * When searching for a terminated line, don't use the
+						 * one between the "if" and the "else".
+						 */
+						if (iselse(l))
+						{
+							if (find_match(LOOKFOR_IF, ourscope,
+										ind_maxparen, ind_maxcomment) == FAIL)
+								break;
+						}
+					}
+
+					/* 
+					 * If we're below an unterminated line that is not an
+					 * "if" or something, we may line up with this line or
+					 * add someting for a continuation line, depending on
+					 * the line before this one.
+					 */
+					else
+					{
+						/*
+						 * Found two unterminated lines on a row, line up with
+						 * the last one.
+						 *	 c = 99 +
+						 *			100 +
+						 * ->		here;
+						 */
+						if (lookfor == LOOKFOR_UNTERM)
+							break;
+
+						/*
+						 * Found first unterminated line on a row, may line up
+						 * with this line, remember its indent
+						 *			100 +
+						 * ->		here;
+						 */
+						amount = cur_amount;
+						if (lookfor != LOOKFOR_TERM)
+							lookfor = LOOKFOR_UNTERM;
+					}
+				}
+
+				/*
+				 * Check if we are after a while (cond);
+				 * If so: Ignore the matching "do".
+				 */
+														/* XXX */
+				else if (iswhileofdo(l, curwin->w_cursor.lnum, ind_maxparen))
+				{
+					/*
+					 * Found an unterminated line after a while ();, line up
+					 * with the last one.
+					 *		while (cond);
+					 *		100 +				<- line up with this one
+					 * ->			here;
+					 */
+					if (lookfor == LOOKFOR_UNTERM)
+					{
+						amount += ind_continuation;
+						break;
+					}
+
+					if (whilelevel == 0)
+					{
+						lookfor = LOOKFOR_TERM;
+						amount = get_indent();		/* XXX */
+						if (theline[0] == '{')
+							amount += ind_open_extra;
+					}
+					++whilelevel;
+				}
+
+				/*
+				 * We are after a "normal" statement.
+				 * If we had another statement we can stop now and use the
+				 * indent of that other statement.
+				 * Otherwise the indent of the current statement may be used,
+				 * search backwards for the next "normal" statement.
+				 */
+				else
+				{
+					/*
+					 * Found a terminated line above an unterminated line. Add
+					 * the amount for a continuation line.
+					 *   x = 1;
+					 *   y = foo +
+					 * ->		here;
+					 */
+					if (lookfor == LOOKFOR_UNTERM)
+					{
+						amount += ind_continuation;
+						break;
+					}
+
+					/*
+					 * Found a terminated line above a terminated line or "if"
+					 * etc. line. Use the amount of the line below us.
+					 *   x = 1;							x = 1;
+					 *   if (asdf)					y = 2;
+					 *		 while (asdf)         ->here;
+					 *		 	here;
+					 * ->foo;
+					 */
+					if (lookfor == LOOKFOR_TERM)
+					{
+						if (whilelevel == 0)
+							break;
+					}
+
+					/*
+					 * First line above the one we're indenting is terminated.
+					 * To know what needs to be done look further backward for
+					 * a terminated line.
+					 */
+					else
+					{
+						/* 
+						 * position the cursor over the rightmost paren, so
+						 * that matching it will take us back to the start of
+						 * the line.  Helps for:
+						 *     func(asdr,
+						 *            asdfasdf);
+						 *     here;
+						 */
+						l = ml_get_curline();
+						if (find_last_paren(l) &&
+								(trypos = find_match_paren(ind_maxparen,
+													 ind_maxcomment)) != NULL)
+						{
+							/*
+							 * Check if we are on a case label now.  This is
+							 * handled above.
+							 *     case xx:  if ( asdf &&
+							 *                      asdf)
+							 */
+							curwin->w_cursor.lnum = trypos->lnum;
+							l = ml_get_curline();
+							if (iscase(l))
+							{
+								++curwin->w_cursor.lnum;
+								continue;
+							}
+						}
+
+						/*
+						 * Get indent and pointer to text for current line,
+						 * ignoring any jump label.
+						 */
+						amount = skip_label(curwin->w_cursor.lnum,
+														  &l, ind_maxcomment);
+
+						if (theline[0] == '{')
+							amount += ind_open_extra;
+						lookfor = LOOKFOR_TERM;
+
+						/*
+						 * If we're at the end of a block, skip to the start of
+						 * that block.
+						 */
+						if (*skipwhite(l) == '}' &&
+								   (trypos = find_start_brace(ind_maxcomment))
+															!= NULL) /* XXX */
+							curwin->w_cursor.lnum = trypos->lnum;
+					}
+				}
+			}
+		}
+	}
+
+	/* 
+	 * ok -- we're not inside any sort of structure at all!
+	 *
+	 * this means we're at the top level, and everything should
+	 * basically just match where the previous line is, except
+	 * for the lines immediately following a function declaration,
+	 * which are K&R-style parameters and need to be indented.
+	 */
+	else
+	{
+		/* 
+		 * if our line starts with an open brace, forget about any 
+		 * prevailing indent and make sure it looks like the start 
+		 * of a function
+		 */
+
+		if (theline[0] == '{')
+		{
+			amount = ind_first_open;
+		}
+
+		/* 
+		 * If the NEXT line is a function declaration, the current
+		 * line needs to be indented as a function type spec.
+		 * Don't do this if the current line looks like a comment.
+		 */
+		else if (cur_curpos.lnum < curbuf->b_ml.ml_line_count &&
+												   !commentorempty(theline) &&
+									  isfuncdecl(ml_get(cur_curpos.lnum + 1)))
+		{
+			amount = ind_func_type;
+		}
+		else
+		{
+			amount = 0;
+			curwin->w_cursor = cur_curpos;
+
+			/* search backwards until we find something we recognize */
+
+			while (curwin->w_cursor.lnum > 1)
+			{
+				curwin->w_cursor.lnum--;
+				curwin->w_cursor.col = 0;
+
+				l = ml_get_curline();
+
+				/*
+				 * If we're in a comment now, skip to the start of the comment.
+				 */												/* XXX */
+				if ((trypos = find_start_comment(ind_maxcomment)) != NULL)
+				{
+					curwin->w_cursor.lnum = trypos->lnum + 1;
+					continue;
+				}
+
+				/*
+				 * If the line looks like a function declaration, and we're
+				 * not in a comment, put it the left margin.
+				 */
+				if (isfuncdecl(theline))
+					break;
+
+				/* 
+				 * Skip preprocessor directives and blank lines.
+				 */
+				if (ispreproc(l))
+					continue;
+
+				if (commentorempty(l))
+					continue;
+
+				/* 
+				 * If the PREVIOUS line is a function declaration, the current
+				 * line (and the ones that follow) needs to be indented as
+				 * parameters.
+				 */
+				if (isfuncdecl(l))
+				{
+					amount = ind_param;
+					break;
+				}
+
+				/* 
+				 * Doesn't look like anything interesting -- so just
+				 * use the indent of this line.
+				 * 
+				 * Position the cursor over the rightmost paren, so that
+				 * matching it will take us back to the start of the line.
+				 */
+				find_last_paren(l);
+
+				if ((trypos = find_match_paren(ind_maxparen,
+													 ind_maxcomment)) != NULL)
+					curwin->w_cursor.lnum = trypos->lnum;
+				amount = get_indent();		/* XXX */
+				break;
+			}
+		}
+	}
+
+theend:
+	/* put the cursor back where it belongs */
+	curwin->w_cursor = cur_curpos;
+
+	vim_free(linecopy);
+
+	if (amount < 0)
+		return 0;
+	return amount;
+}
+
+	static int
+find_match(lookfor, ourscope, ind_maxparen, ind_maxcomment)
+	int			lookfor;
+	linenr_t	ourscope;
+	int			ind_maxparen;
+	int			ind_maxcomment;
+{
+	char_u		*look;
+	FPOS		*theirscope;
+	char_u		*mightbeif;
+	int			elselevel;
+	int			whilelevel;
+
+	if (lookfor == LOOKFOR_IF)
+	{
+		elselevel = 1;
+		whilelevel = 0;
+	}
+	else
+	{
+		elselevel = 0;
+		whilelevel = 1;
+	}
+
+	curwin->w_cursor.col = 0;
+
+	while (curwin->w_cursor.lnum > ourscope + 1)
+	{
+		curwin->w_cursor.lnum--;
+		curwin->w_cursor.col = 0;
+
+		look = skipwhite(ml_get_curline());
+		if (iselse(look) || isif(look) || isdo(look) ||
+			 iswhileofdo(look, curwin->w_cursor.lnum, ind_maxparen))  /* XXX */
+		{
+			/* 
+			 * if we've gone outside the braces entirely,
+			 * we must be out of scope...
+			 */
+			theirscope = find_start_brace(ind_maxcomment);	/* XXX */
+			if (theirscope == NULL)
+				break;
+
+			/* 
+			 * and if the brace enclosing this is further
+			 * back than the one enclosing the else, we're
+			 * out of luck too.
+			 */
+			if (theirscope->lnum < ourscope)
+				break;
+
+			/* 
+			 * and if they're enclosed in a *deeper* brace,
+			 * then we can ignore it because it's in a
+			 * different scope...
+			 */
+			if (theirscope->lnum > ourscope)
+				continue;
+
+			/* 
+			 * if it was an "else" (that's not an "else if")
+			 * then we need to go back to another if, so 
+			 * increment elselevel
+			 */
+			look = skipwhite(ml_get_curline());
+			if (iselse(look))
+			{
+				mightbeif = skipwhite(look + 4);
+				if (!isif(mightbeif))
+					++elselevel;
+				continue;
+			}
+
+			/* 
+			 * if it was a "while" then we need to go back to
+			 * another "do", so increment whilelevel.
+			 */
+			if (iswhileofdo(look, curwin->w_cursor.lnum, ind_maxparen))/* XXX */
+			{
+				++whilelevel;
+				continue;
+			}
+
+			/* If it's an "if" decrement elselevel */
+			look = skipwhite(ml_get_curline());
+			if (isif(look))
+			{
+				elselevel--;
+				/*
+				 * When looking for an "if" ignore "while"s that
+				 * get in the way.
+				 */
+				if (elselevel == 0 && lookfor == LOOKFOR_IF)
+					whilelevel = 0;
+			}
+
+			/* If it's a "do" decrement whilelevel */
+			if (isdo(look))
+				whilelevel--;
+
+			/* 
+			 * if we've used up all the elses, then
+			 * this must be the if that we want!
+			 * match the indent level of that if.
+			 */
+			if (elselevel <= 0 && whilelevel <= 0)
+			{
+				return OK;
+			}
+		}
+	}
+	return FAIL;
+}
+
+#endif /* CINDENT */
+
+#ifdef LISPINDENT
+	int
+get_lisp_indent()
+{
+	FPOS		*pos, realpos;
+	long		amount = 0;
+	char_u		*that;
+	colnr_t		col;
+	colnr_t		maybe;
+	colnr_t		firsttry;
+
+
+	realpos = curwin->w_cursor;
+	curwin->w_cursor.col = 0;
+
+	if ((pos = findmatch('(')) != NULL)
+	{
+		curwin->w_cursor.lnum = pos->lnum;
+		curwin->w_cursor.col = pos->col;
+		col = pos->col;
+
+		that = ml_get_curline();
+		maybe = get_indent();		/* XXX */
+
+		if (maybe == 0)
+			amount = 2;
+		else
+		{
+			while (*that && col)
+			{
+				amount += lbr_chartabsize(that, (colnr_t)amount);
+				col--;
+				that++;
+			}
+
+ 			that++;
+			amount++;
+			firsttry = amount;
+
+			/*
+			 * Go to the start of the second word.
+			 * If there is no second word, go back to firsttry.
+			 * Also stop at a '('.
+			 */
+
+			while (vim_iswhite(*that))
+			{
+				amount += lbr_chartabsize(that, (colnr_t)amount);
+				that++;
+			}
+			while (*that && !vim_iswhite(*that) && *that != '(')
+			{
+				amount += lbr_chartabsize(that, (colnr_t)amount);
+				that++;
+			}
+			while (vim_iswhite(*that))
+			{
+				amount += lbr_chartabsize(that, (colnr_t)amount);
+				that++;
+			}
+			if (! *that)
+				amount = firsttry;
+		}
+	}
+	else	/* no matching '(' found, use indent of previous non-empty line */
+	{
+		while (curwin->w_cursor.lnum > 1)
+		{
+			--curwin->w_cursor.lnum;
+			if (!linewhite(curwin->w_cursor.lnum))
+				break;
+		}
+		amount = get_indent();		/* XXX */
+	}
+
+	curwin->w_cursor = realpos;
+
+	if (amount < 0)
+		amount = 0;
+	return (int)amount;
+}
+#endif /* LISPINDENT */
+
+#if defined(UNIX) || defined(WIN32) || defined(__EMX__)
+/*
+ * Preserve files and exit.
+ * When called IObuff must contain a message.
+ */
+	void
+preserve_exit()
+{
+	BUF		*buf;
+
+#ifdef USE_GUI
+	if (gui.in_use)
+	{
+		gui.dying = TRUE;
+		trash_output_buf();		/* trash any pending output */
+	}
+	else
+#endif
+	{
+		windgoto((int)Rows - 1, 0);
+
+		/*
+		 * Switch terminal mode back now, so these messages end up on the
+		 * "normal" screen (if there are two screens).
+		 */
+		settmode(0);
+#ifdef WIN32
+		if (can_end_termcap_mode(FALSE) == TRUE)
+#endif
+			stoptermcap();
+		flushbuf();
+	}
+
+	outstr(IObuff);
+	screen_start();					/* don't know where cursor is now */
+	flushbuf();
+
+	ml_close_notmod();				/* close all not-modified buffers */
+
+	for (buf = firstbuf; buf != NULL; buf = buf->b_next)
+	{
+		if (buf->b_ml.ml_mfp != NULL && buf->b_ml.ml_mfp->mf_fname != NULL)
+		{
+			OUTSTR("Vim: preserving files...\n");
+			screen_start();			/* don't know where cursor is now */
+			flushbuf();
+			ml_sync_all(FALSE, FALSE);	/* preserve all swap files */
+			break;
+		}
+	}
+
+	ml_close_all(FALSE);			/* close all memfiles, without deleting */
+
+	OUTSTR("Vim: Finished.\n");
+
+	getout(1);
+}
+#endif /* defined(UNIX) || defined(WIN32) || defined(__EMX__) */
+
+/*
+ * return TRUE if "fname" exists.
+ */
+	int
+vim_fexists(fname)
+	char_u	*fname;
+{
+	struct stat st;
+
+	if (stat((char *)fname, &st))
+		return FALSE;
+	return TRUE;
+}
+
+/*
+ * Check for CTRL-C pressed, but only once in a while.
+ * Should be used instead of mch_breakcheck() for functions that check for
+ * each line in the file.  Calling mch_breakcheck() each time takes too much
+ * time, because it can be a system call.
+ */
+
+#ifndef BREAKCHECK_SKIP
+# define BREAKCHECK_SKIP 32
+#endif
+
+	void
+line_breakcheck()
+{
+	static int	count = 0;
+
+	if (++count == BREAKCHECK_SKIP)
+	{
+		count = 0;
+		mch_breakcheck();
+	}
+}
+
+/*
+ * Free the list of files returned by ExpandWildCards() or other expansion
+ * functions.
+ */
+	void
+FreeWild(num, file)
+	int		num;
+	char_u	**file;
+{
+	if (file == NULL || num == 0)
+		return;
+#if defined(__EMX__) && defined(__ALWAYS_HAS_TRAILING_NULL_POINTER) /* XXX */
+	/*
+	 * Is this still OK for when other functions thatn ExpandWildCards() have
+	 * been used???
+	 */
+	_fnexplodefree((char **)file);
+#else
+	while (num--)
+		vim_free(file[num]);
+	vim_free(file);
+#endif
+}
+