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

diff --git a/usr.bin/vim/unix.c b/usr.bin/vim/unix.c
new file mode 100644
index 00000000000..bdb7bf55124
--- /dev/null
+++ b/usr.bin/vim/unix.c
@@ -0,0 +1,2883 @@
+/*	$OpenBSD: unix.c,v 1.1 1996/09/07 21:40:24 downsj Exp $	*/
+/* vi:set ts=4 sw=4:
+ *
+ * VIM - Vi IMproved		by Bram Moolenaar
+ *                OS/2 port by Paul Slootman
+ *
+ * Do ":help uganda"  in Vim to read copying and usage conditions.
+ * Do ":help credits" in Vim to see a list of people who contributed.
+ */
+
+/*
+ * unix.c -- code for all flavors of Unix (BSD, SYSV, SVR4, POSIX, ...)
+ *           Also for OS/2, using the excellent EMX package!!!
+ *
+ * A lot of this file was originally written by Juergen Weigert and later
+ * changed beyond recognition.
+ */
+
+/*
+ * Some systems have a prototype for select() that has (int *) instead of
+ * (fd_set *), which is wrong. This define removes that prototype. We include
+ * our own prototype in osdef.h.
+ */
+#define select select_declared_wrong
+
+#include "vim.h"
+#include "globals.h"
+#include "option.h"
+#include "proto.h"
+
+#ifdef HAVE_FCNTL_H
+# include <fcntl.h>
+#endif
+
+#include "unixunix.h"		/* unix includes for unix.c only */
+
+/*
+ * Use this prototype for select, some include files have a wrong prototype
+ */
+#undef select
+
+#if defined(HAVE_SELECT)
+extern int   select __ARGS((int, fd_set *, fd_set *, fd_set *, struct timeval *));
+#endif
+
+/*
+ * end of autoconf section. To be extended...
+ */
+
+/* Are the following #ifdefs still required? And why? Is that for X11? */
+
+#if defined(ESIX) || defined(M_UNIX) && !defined(SCO)
+# ifdef SIGWINCH
+#  undef SIGWINCH
+# endif
+# ifdef TIOCGWINSZ
+#  undef TIOCGWINSZ
+# endif
+#endif
+
+#if defined(SIGWINDOW) && !defined(SIGWINCH)	/* hpux 9.01 has it */
+# define SIGWINCH SIGWINDOW
+#endif
+
+#if defined(HAVE_X11) && defined(WANT_X11)
+# include <X11/Xlib.h>
+# include <X11/Xutil.h>
+# include <X11/Xatom.h>
+
+Window		x11_window = 0;
+Display		*x11_display = NULL;
+int			got_x_error = FALSE;
+
+static int	get_x11_windis __ARGS((void));
+static void set_x11_title __ARGS((char_u *));
+static void set_x11_icon __ARGS((char_u *));
+#endif
+
+static int get_x11_title __ARGS((int));
+static int get_x11_icon __ARGS((int));
+
+static void may_core_dump __ARGS((void));
+
+static int	Read __ARGS((char_u *, long));
+static int	WaitForChar __ARGS((long));
+static int	RealWaitForChar __ARGS((int, long));
+static void fill_inbuf __ARGS((int));
+
+#if defined(SIGWINCH)
+static RETSIGTYPE sig_winch __ARGS(SIGPROTOARG);
+#endif
+#if defined(SIGALRM) && defined(HAVE_X11) && defined(WANT_X11)
+static RETSIGTYPE sig_alarm __ARGS(SIGPROTOARG);
+#endif
+static RETSIGTYPE deathtrap __ARGS(SIGPROTOARG);
+
+static void catch_signals __ARGS((RETSIGTYPE (*func)()));
+#ifndef __EMX__
+static int	have_wildcard __ARGS((int, char_u **));
+static int	have_dollars __ARGS((int, char_u **));
+#endif
+
+static int		do_resize = FALSE;
+static char_u	*oldtitle = NULL;
+static char_u	*fixedtitle = (char_u *)"Thanks for flying Vim";
+static char_u	*oldicon = NULL;
+#ifndef __EMX__
+static char_u	*extra_shell_arg = NULL;
+static int		show_shell_mess = TRUE;
+#endif
+static int		core_dump = FALSE;			/* core dump in mch_windexit() */
+
+#ifdef SYS_SIGLIST_DECLARED
+/*
+ * I have seen 
+ * 	extern char *_sys_siglist[NSIG];
+ * on Irix, Linux, NetBSD and Solaris. It contains a nice list of strings
+ * that describe the signals. That is nearly what we want here.  But
+ * autoconf does only check for sys_siglist (without the underscore), I
+ * do not want to change everything today.... jw.
+ * This is why AC_DECL_SYS_SIGLIST is commented out in configure.in
+ */
+#endif
+
+static struct
+{
+	int		sig;		/* Signal number, eg. SIGSEGV etc */
+	char	*name;		/* Signal name (not char_u!). */
+	int		dump;		/* Should this signal cause a core dump? */
+} signal_info[] =
+{
+#ifdef SIGHUP
+	{SIGHUP,		"HUP",		FALSE},
+#endif
+#ifdef SIGINT
+	{SIGINT,		"INT",		FALSE},
+#endif
+#ifdef SIGQUIT
+	{SIGQUIT,		"QUIT",		TRUE},
+#endif
+#ifdef SIGILL
+	{SIGILL,		"ILL",		TRUE},
+#endif
+#ifdef SIGTRAP
+	{SIGTRAP,		"TRAP",		TRUE},
+#endif
+#ifdef SIGABRT
+	{SIGABRT,		"ABRT",		TRUE},
+#endif
+#ifdef SIGEMT
+	{SIGEMT,		"EMT",		TRUE},
+#endif
+#ifdef SIGFPE
+	{SIGFPE,		"FPE",		TRUE},
+#endif
+#ifdef SIGBUS
+	{SIGBUS,		"BUS",		TRUE},
+#endif
+#ifdef SIGSEGV
+	{SIGSEGV,		"SEGV",		TRUE},
+#endif
+#ifdef SIGSYS
+	{SIGSYS,		"SYS",		TRUE},
+#endif
+#ifdef SIGALRM
+	{SIGALRM,		"ALRM",		FALSE},
+#endif
+#ifdef SIGTERM
+	{SIGTERM,		"TERM",		FALSE},
+#endif
+#ifdef SIGVTALRM
+	{SIGVTALRM,		"VTALRM",	FALSE},
+#endif
+#ifdef SIGPROF
+	{SIGPROF,		"PROF",		FALSE},
+#endif
+#ifdef SIGXCPU
+	{SIGXCPU,		"XCPU",		TRUE},
+#endif
+#ifdef SIGXFSZ
+	{SIGXFSZ,		"XFSZ",		TRUE},
+#endif
+#ifdef SIGUSR1
+	{SIGUSR1,		"USR1",		FALSE},
+#endif
+#ifdef SIGUSR2
+	{SIGUSR2,		"USR2",		FALSE},
+#endif
+	{-1,			"Unknown!",	-1}
+};
+
+	void
+mch_write(s, len)
+	char_u	*s;
+	int		len;
+{
+#ifdef USE_GUI
+	if (gui.in_use && !gui.dying)
+	{
+		gui_write(s, len);
+		if (p_wd)
+			gui_mch_wait_for_chars(p_wd);
+	}
+	else
+#endif
+	{
+		write(1, (char *)s, len);
+		if (p_wd)			/* Unix is too fast, slow down a bit more */
+			RealWaitForChar(0, p_wd);
+	}
+}
+
+/*
+ * mch_inchar(): low level input funcion.
+ * Get a characters from the keyboard.
+ * Return the number of characters that are available.
+ * If wtime == 0 do not wait for characters.
+ * If wtime == n wait a short time for characters.
+ * If wtime == -1 wait forever for characters.
+ */
+	int
+mch_inchar(buf, maxlen, wtime)
+	char_u	*buf;
+	int		maxlen;
+	long	wtime;			/* don't use "time", MIPS cannot handle it */
+{
+	int			len;
+
+#ifdef USE_GUI
+	if (gui.in_use)
+	{
+		if (!gui_mch_wait_for_chars(wtime))
+			return 0;
+		return Read(buf, (long)maxlen);
+	}
+#endif
+
+	if (wtime >= 0)
+	{
+		while (WaitForChar(wtime) == 0)		/* no character available */
+		{
+			if (!do_resize)			/* return if not interrupted by resize */
+				return 0;
+			set_winsize(0, 0, FALSE);
+			do_resize = FALSE;
+		}
+	}
+	else		/* wtime == -1 */
+	{
+	/*
+	 * If there is no character available within 'updatetime' seconds
+	 * flush all the swap files to disk
+	 * Also done when interrupted by SIGWINCH.
+	 */
+		if (WaitForChar(p_ut) == 0)
+			updatescript(0);
+	}
+
+	for (;;)	/* repeat until we got a character */
+	{
+		if (do_resize)		/* window changed size */
+		{
+			set_winsize(0, 0, FALSE);
+			do_resize = FALSE;
+		}
+		/* 
+		 * we want to be interrupted by the winch signal
+		 */
+		WaitForChar(-1L);
+		if (do_resize)		/* interrupted by SIGWINCHsignal */
+			continue;
+
+		/*
+		 * For some terminals we only get one character at a time.
+		 * We want the get all available characters, so we could keep on
+		 * trying until none is available
+		 * For some other terminals this is quite slow, that's why we don't do
+		 * it.
+		 */
+		len = Read(buf, (long)maxlen);
+		if (len > 0)
+		{
+#ifdef OS2
+			int i;
+
+			for (i = 0; i < len; i++)
+				if (buf[i] == 0)
+					buf[i] = K_NUL;
+#endif
+			return len;
+		}
+	}
+}
+
+/*
+ * return non-zero if a character is available
+ */
+	int
+mch_char_avail()
+{
+#ifdef USE_GUI
+	if (gui.in_use)
+	{
+		gui_mch_update();
+		return !is_input_buf_empty();
+	}
+#endif
+	return WaitForChar(0L);
+}
+
+	long
+mch_avail_mem(special)
+	int special;
+{
+#ifdef __EMX__
+	return ulimit(3, 0L);	/* always 32MB? */
+#else
+ 	return 0x7fffffff;		/* virtual memory eh */
+#endif
+}
+
+	void
+mch_delay(msec, ignoreinput)
+	long		msec;
+	int			ignoreinput;
+{
+	if (ignoreinput)
+#ifndef HAVE_SELECT
+		poll(NULL, 0, (int)msec);
+#else
+# ifdef __EMX__
+	_sleep2(msec);
+# else
+	{
+		struct timeval tv;
+
+		tv.tv_sec = msec / 1000;
+		tv.tv_usec = (msec % 1000) * 1000;
+		select(0, NULL, NULL, NULL, &tv);
+	}
+# endif	/* __EMX__ */
+#endif	/* HAVE_SELECT */
+	else
+#ifdef USE_GUI
+		if (gui.in_use)
+			gui_mch_wait_for_chars(msec);
+		else
+#endif
+			WaitForChar(msec);
+}
+
+#if defined(SIGWINCH)
+/*
+ * We need correct potatotypes, otherwise mean compilers will barf when the
+ * second argument to signal() is ``wrong''.
+ * Let me try it with a few tricky defines from my own osdef.h  (jw).
+ */
+	static RETSIGTYPE
+sig_winch SIGDEFARG(sigarg)
+{
+	/* this is not required on all systems, but it doesn't hurt anybody */
+	signal(SIGWINCH, (RETSIGTYPE (*)())sig_winch);
+	do_resize = TRUE;
+	SIGRETURN;
+}
+#endif
+ 
+#if defined(SIGALRM) && defined(HAVE_X11) && defined(WANT_X11)
+/*
+ * signal function for alarm().
+ */
+	static RETSIGTYPE
+sig_alarm SIGDEFARG(sigarg)
+{
+	/* doesn't do anything, just to break a system call */
+	SIGRETURN;
+}
+#endif
+ 
+	void
+mch_resize()
+{
+	do_resize = TRUE;
+}
+
+/*
+ * This function handles deadly signals.
+ * It tries to preserve any swap file and exit properly.
+ * (partly from Elvis).
+ */
+	static RETSIGTYPE
+deathtrap SIGDEFARG(sigarg)
+{
+	static int		entered = 0;
+#ifdef SIGHASARG
+	int		i;
+
+	for (i = 0; signal_info[i].dump != -1; i++)
+	{
+		if (sigarg == signal_info[i].sig)
+		{
+			if (signal_info[i].dump)
+				core_dump = TRUE;
+			break;
+		}
+	}
+#endif
+
+	/*
+	 * If something goes wrong after entering here, we may get here again.
+	 * When this happens, give a message and try to exit nicely (resetting the
+	 * terminal mode, etc.)
+	 * When this happens twice, just exit, don't even try to give a message,
+	 * stack may be corrupt or something weird.
+	 */
+	if (entered == 2)
+	{
+		may_core_dump();
+		exit(7);
+	}
+	if (entered)
+	{
+		OUTSTR("Vim: Double signal, exiting\n");
+		flushbuf();
+		getout(1);
+	}
+	++entered;
+
+	sprintf((char *)IObuff, "Vim: Caught %s %s\n",
+#ifdef SIGHASARG
+					"deadly signal", signal_info[i].name);
+#else
+					"some", "deadly signal");
+#endif
+
+	preserve_exit();				/* preserve files and exit */
+
+	SIGRETURN;
+}
+
+/*
+ * If the machine has job control, use it to suspend the program,
+ * otherwise fake it by starting a new shell.
+ * When running the GUI iconify the window.
+ */
+	void
+mch_suspend()
+{
+#ifdef USE_GUI
+	if (gui.in_use)
+	{
+		gui_mch_iconify();
+		return;
+	}
+#endif
+#ifdef SIGTSTP
+	flushbuf();				/* needed to make cursor visible on some systems */
+	settmode(0);
+	flushbuf();				/* needed to disable mouse on some systems */
+	kill(0, SIGTSTP);		/* send ourselves a STOP signal */
+	
+	/*
+	 * Set oldtitle to NULL, so the current title is obtained again.
+	 */
+	if (oldtitle != fixedtitle)
+	{
+		vim_free(oldtitle);
+		oldtitle = NULL;
+	}
+	settmode(1);
+#else
+	MSG_OUTSTR("new shell started\n");
+	(void)call_shell(NULL, SHELL_COOKED);
+#endif
+	need_check_timestamps = TRUE;
+}
+
+	void
+mch_windinit()
+{
+	Columns = 80;
+	Rows = 24;
+
+	flushbuf();
+
+	(void)mch_get_winsize();
+
+#if defined(SIGWINCH)
+	/*
+	 * WINDOW CHANGE signal is handled with sig_winch().
+	 */
+	signal(SIGWINCH, (RETSIGTYPE (*)())sig_winch);
+#endif
+
+	/*
+	 * We want the STOP signal to work, to make mch_suspend() work
+	 */
+#ifdef SIGTSTP
+	signal(SIGTSTP, SIG_DFL);
+#endif
+
+	/*
+	 * We want to ignore breaking of PIPEs.
+	 */
+#ifdef SIGPIPE
+	signal(SIGPIPE, SIG_IGN);
+#endif
+
+	/*
+	 * Arrange for other signals to gracefully shutdown Vim.
+	 */
+	catch_signals(deathtrap);
+}
+
+	static void
+catch_signals(func)
+	RETSIGTYPE (*func)();
+{
+	int		i;
+
+	for (i = 0; signal_info[i].dump != -1; i++)
+		signal(signal_info[i].sig, func);
+}
+
+	void
+reset_signals()
+{
+	catch_signals(SIG_DFL);
+}
+
+/*
+ * Check_win checks whether we have an interactive window.
+ */
+	int
+mch_check_win(argc, argv)
+	int		argc;
+	char	**argv;
+{
+	if (isatty(1))
+		return OK;
+	return FAIL;
+}
+
+	int
+mch_check_input()
+{
+	if (isatty(0))
+		return OK;
+	return FAIL;
+}
+
+#if defined(HAVE_X11) && defined(WANT_X11)
+/*
+ * X Error handler, otherwise X just exits!  (very rude) -- webb
+ */
+	static int
+x_error_handler(dpy, error_event)
+	Display		*dpy;
+	XErrorEvent	*error_event;
+{
+	XGetErrorText(dpy, error_event->error_code, (char *)IObuff, IOSIZE);
+	STRCAT(IObuff, "\nVim: Got X error\n");
+
+#if 1
+	preserve_exit();				/* preserve files and exit */
+#else
+	printf(IObuff);					/* print error message and continue */
+									/* Makes my system hang */
+#endif
+
+	return 0;			/* NOTREACHED */
+}
+
+/*
+ * Another X Error handler, just used to check for errors.
+ */
+	static int
+x_error_check(dpy, error_event)
+	Display	*dpy;
+	XErrorEvent	*error_event;
+{
+	got_x_error = TRUE;
+	return 0;
+}
+
+/*
+ * try to get x11 window and display
+ *
+ * return FAIL for failure, OK otherwise
+ */
+	static int
+get_x11_windis()
+{
+	char			*winid;
+	XTextProperty	text_prop;
+	int				(*old_handler)();
+	static int		result = -1;
+	static int		x11_display_opened_here = FALSE;
+
+	/* X just exits if it finds an error otherwise! */
+	XSetErrorHandler(x_error_handler);
+
+#ifdef USE_GUI_X11
+	if (gui.in_use)
+	{
+		/*
+		 * If the X11 display was opened here before, for the window where Vim
+		 * was started, close that one now to avoid a memory leak.
+		 */
+		if (x11_display_opened_here && x11_display != NULL)
+		{
+			XCloseDisplay(x11_display);
+			x11_display = NULL;
+			x11_display_opened_here = FALSE;
+		}
+		return gui_get_x11_windis(&x11_window, &x11_display);
+	}
+#endif
+
+	if (result != -1)		/* Have already been here and set this */
+		return result;		/* Don't do all these X calls again */
+
+	/*
+	 * If WINDOWID not set, should try another method to find out
+	 * what the current window number is. The only code I know for
+	 * this is very complicated.
+	 * We assume that zero is invalid for WINDOWID.
+	 */
+	if (x11_window == 0 && (winid = getenv("WINDOWID")) != NULL) 
+		x11_window = (Window)atol(winid);
+	if (x11_window != 0 && x11_display == NULL)
+	{
+#ifdef SIGALRM
+		RETSIGTYPE (*sig_save)();
+
+		/*
+		 * Opening the Display may hang if the DISPLAY setting is wrong, or
+		 * the network connection is bad.  Set an alarm timer to get out.
+		 */
+		sig_save = (RETSIGTYPE (*)())signal(SIGALRM,
+												 (RETSIGTYPE (*)())sig_alarm);
+		alarm(2);
+#endif
+		x11_display = XOpenDisplay(NULL);
+#ifdef SIGALRM
+		alarm(0);
+		signal(SIGALRM, (RETSIGTYPE (*)())sig_save);
+#endif
+		if (x11_display != NULL)
+		{
+			/*
+			 * Try to get the window title.  I don't actually want it yet, so
+			 * there may be a simpler call to use, but this will cause the
+			 * error handler x_error_check() to be called if anything is wrong,
+			 * such as the window pointer being invalid (as can happen when the
+			 * user changes his DISPLAY, but not his WINDOWID) -- webb
+			 */
+			old_handler = XSetErrorHandler(x_error_check);
+			got_x_error = FALSE;
+			if (XGetWMName(x11_display, x11_window, &text_prop))
+				XFree((void *)text_prop.value);
+			XSync(x11_display, False);
+			if (got_x_error)
+			{
+				/* Maybe window id is bad */
+				x11_window = 0;
+				XCloseDisplay(x11_display);
+				x11_display = NULL;
+			}
+			else
+				x11_display_opened_here = TRUE;
+			XSetErrorHandler(old_handler);
+		}
+	}
+	if (x11_window == 0 || x11_display == NULL)
+		return (result = FAIL);
+	return (result = OK);
+}
+
+/*
+ * Determine original x11 Window Title
+ */
+	static int
+get_x11_title(test_only)
+	int		test_only;
+{
+	XTextProperty	text_prop;
+	int				retval = FALSE;
+
+	if (get_x11_windis() == OK)
+	{
+			/* Get window name if any */
+		if (XGetWMName(x11_display, x11_window, &text_prop))
+		{
+			if (text_prop.value != NULL)
+			{
+				retval = TRUE;
+				if (!test_only)
+					oldtitle = strsave((char_u *)text_prop.value);
+			}
+			XFree((void *)text_prop.value);
+		}
+	}
+	if (oldtitle == NULL && !test_only)		/* could not get old title */
+		oldtitle = fixedtitle;
+
+	return retval;
+}
+
+/*
+ * Determine original x11 Window icon
+ */
+
+	static int
+get_x11_icon(test_only)
+	int		test_only;
+{
+	XTextProperty	text_prop;
+	int				retval = FALSE;
+
+	if (get_x11_windis() == OK)
+	{
+			/* Get icon name if any */
+		if (XGetWMIconName(x11_display, x11_window, &text_prop))
+		{
+			if (text_prop.value != NULL)
+			{
+				retval = TRUE;
+				if (!test_only)
+					oldicon = strsave((char_u *)text_prop.value);
+			}
+			XFree((void *)text_prop.value);
+		}
+	}
+
+		/* could not get old icon, use terminal name */
+	if (oldicon == NULL && !test_only)
+	{
+		if (STRNCMP(term_strings[KS_NAME], "builtin_", 8) == 0)
+			oldicon = term_strings[KS_NAME] + 8;
+		else
+			oldicon = term_strings[KS_NAME];
+	}
+
+	return retval;
+}
+
+/*
+ * Set x11 Window Title
+ *
+ * get_x11_windis() must be called before this and have returned OK
+ */
+    static void
+set_x11_title(title)
+    char_u      *title;
+{
+#if XtSpecificationRelease >= 4
+    XTextProperty text_prop;
+
+    text_prop.value = title;
+    text_prop.nitems = STRLEN(title);
+    text_prop.encoding = XA_STRING;
+    text_prop.format = 8;
+    XSetWMName(x11_display, x11_window, &text_prop);
+#else
+    XStoreName(x11_display, x11_window, (char *)title);
+#endif
+    XFlush(x11_display);
+}
+
+/*
+ * Set x11 Window icon
+ *
+ * get_x11_windis() must be called before this and have returned OK
+ */
+    static void
+set_x11_icon(icon)
+    char_u      *icon;
+{
+#if XtSpecificationRelease >= 4
+    XTextProperty text_prop;
+
+    text_prop.value = icon;
+    text_prop.nitems = STRLEN(icon);
+    text_prop.encoding = XA_STRING;
+    text_prop.format = 8;
+    XSetWMIconName(x11_display, x11_window, &text_prop);
+#else
+    XSetIconName(x11_display, x11_window, (char *)icon);
+#endif
+    XFlush(x11_display);
+}
+
+#else	/* HAVE_X11 && WANT_X11 */
+
+	static int
+get_x11_title(test_only)
+	int		test_only;
+{
+	if (!test_only)
+		oldtitle = fixedtitle;
+	return FALSE;
+}
+
+	static int
+get_x11_icon(test_only)
+	int		test_only;
+{
+	if (!test_only)
+	{
+		if (STRNCMP(term_strings[KS_NAME], "builtin_", 8) == 0)
+			oldicon = term_strings[KS_NAME] + 8;
+		else
+			oldicon = term_strings[KS_NAME];
+	}
+	return FALSE;
+}
+
+#endif	/* HAVE_X11 && WANT_X11 */
+
+	int
+mch_can_restore_title()
+{
+#ifdef USE_GUI
+	/*
+	 * If GUI is (going to be) used, we can always set the window title.
+	 * Saves a bit of time, because the X11 display server does not need to be
+	 * contacted.
+	 */
+	if (gui.starting || gui.in_use)
+		return TRUE;
+#endif
+	return get_x11_title(TRUE);
+}
+
+	int
+mch_can_restore_icon()
+{
+#ifdef USE_GUI
+	/*
+	 * If GUI is (going to be) used, we can always set the icon name.
+	 * Saves a bit of time, because the X11 display server does not need to be
+	 * contacted.
+	 */
+	if (gui.starting || gui.in_use)
+		return TRUE;
+#endif
+	return get_x11_icon(TRUE);
+}
+
+/*
+ * Set the window title and icon.
+ * Currently only works for x11.
+ */
+	void
+mch_settitle(title, icon)
+	char_u *title;
+	char_u *icon;
+{
+	int			type = 0;
+
+	if (term_strings[KS_NAME] == NULL)		/* no terminal name (yet) */
+		return;
+	if (title == NULL && icon == NULL)		/* nothing to do */
+		return;
+
+/*
+ * if the window ID and the display is known, we may use X11 calls
+ */
+#if defined(HAVE_X11) && defined(WANT_X11)
+	if (get_x11_windis() == OK)
+		type = 1;
+#endif
+
+	/*
+	 * Note: if terminal is xterm, title is set with escape sequence rather
+	 * 		 than x11 calls, because the x11 calls don't always work
+	 * Check only if the start of the terminal name is "xterm", also catch
+	 * "xterms".
+	 */
+	if (is_xterm(term_strings[KS_NAME]))
+		type = 2;
+
+	if (is_iris_ansi(term_strings[KS_NAME]))
+		type = 3;
+
+	if (type)
+	{
+		if (title != NULL)
+		{
+			if (oldtitle == NULL)				/* first call, save title */
+				(void)get_x11_title(FALSE);
+
+			switch(type)
+			{
+#if defined(HAVE_X11) && defined(WANT_X11)
+			case 1:	set_x11_title(title);				/* x11 */
+					break;
+#endif
+			case 2: outstrn((char_u *)"\033]2;");		/* xterm */
+					outstrn(title);
+					outchar(Ctrl('G'));
+					flushbuf();
+					break;
+
+			case 3: outstrn((char_u *)"\033P1.y");		/* iris-ansi */
+					outstrn(title);
+					outstrn((char_u *)"\234");
+					flushbuf();
+					break;
+			}
+		}
+
+		if (icon != NULL)
+		{
+			if (oldicon == NULL)				/* first call, save icon */
+				get_x11_icon(FALSE);
+
+			switch(type)
+			{
+#if defined(HAVE_X11) && defined(WANT_X11)
+			case 1:	set_x11_icon(icon);					/* x11 */
+					break;
+#endif
+			case 2: outstrn((char_u *)"\033]1;");		/* xterm */
+					outstrn(icon);
+					outchar(Ctrl('G'));
+					flushbuf();
+					break;
+
+			case 3: outstrn((char_u *)"\033P3.y");		/* iris-ansi */
+					outstrn(icon);
+					outstrn((char_u *)"\234");
+					flushbuf();
+					break;
+			}
+		}
+	}
+}
+
+	int
+is_xterm(name)
+	char_u *name;
+{
+	if (name == NULL)
+		return FALSE;
+	return (vim_strnicmp(name, (char_u *)"xterm", (size_t)5) == 0 ||
+						STRCMP(name, "builtin_xterm") == 0);
+}
+
+	int
+is_iris_ansi(name)
+	char_u	*name;
+{
+	if (name == NULL)
+		return FALSE;
+	return (vim_strnicmp(name, (char_u *)"iris-ansi", (size_t)9) == 0 ||
+						STRCMP(name, "builtin_iris-ansi") == 0);
+}
+
+/*
+ * Return TRUE if "name" is a terminal for which 'ttyfast' should be set.
+ * This should include all windowed terminal emulators.
+ */
+	int
+is_fastterm(name)
+	char_u	*name;
+{
+	if (name == NULL)
+		return FALSE;
+	if (is_xterm(name) || is_iris_ansi(name))
+		return TRUE;
+	return (vim_strnicmp(name, (char_u *)"hpterm", (size_t)6) == 0 ||
+		    vim_strnicmp(name, (char_u *)"sun-cmd", (size_t)7) == 0 ||
+		    vim_strnicmp(name, (char_u *)"screen", (size_t)6) == 0 ||
+		    vim_strnicmp(name, (char_u *)"dtterm", (size_t)6) == 0);
+}
+
+/*
+ * Restore the window/icon title.
+ * which is one of:
+ *	1  Just restore title
+ *  2  Just restore icon
+ *	3  Restore title and icon
+ */
+	void
+mch_restore_title(which)
+	int which;
+{
+	mch_settitle((which & 1) ? oldtitle : NULL, (which & 2) ? oldicon : NULL);
+}
+
+/*
+ * Insert user name in s[len].
+ * Return OK if a name found.
+ */
+	int
+mch_get_user_name(s, len)
+	char_u	*s;
+	int		len;
+{
+#if defined(HAVE_PWD_H) && defined(HAVE_GETPWUID)
+	struct passwd	*pw;
+#endif
+	uid_t			uid;
+
+	uid = getuid();
+#if defined(HAVE_PWD_H) && defined(HAVE_GETPWUID)
+	if ((pw = getpwuid(uid)) != NULL &&
+								   pw->pw_name != NULL && *pw->pw_name != NUL)
+	{
+		STRNCPY(s, pw->pw_name, len);
+		return OK;
+	}
+#endif
+	sprintf((char *)s, "%d", (int)uid);		/* assumes s is long enough */
+	return FAIL;							/* a number is not a name */
+}
+
+/*
+ * Insert host name is s[len].
+ */
+
+#ifdef HAVE_SYS_UTSNAME_H
+	void
+mch_get_host_name(s, len)
+	char_u	*s;
+	int		len;
+{
+    struct utsname vutsname;
+
+    uname(&vutsname);
+    STRNCPY(s, vutsname.nodename, len);
+}
+#else /* HAVE_SYS_UTSNAME_H */
+
+# ifdef HAVE_SYS_SYSTEMINFO_H
+#  define gethostname(nam, len) sysinfo(SI_HOSTNAME, nam, len)
+# endif
+
+	void
+mch_get_host_name(s, len)
+	char_u	*s;
+	int		len;
+{
+	gethostname((char *)s, len);
+}
+#endif /* HAVE_SYS_UTSNAME_H */
+
+/*
+ * return process ID
+ */
+	long
+mch_get_pid()
+{
+	return (long)getpid();
+}
+
+#if !defined(HAVE_STRERROR) && defined(USE_GETCWD)
+static char *strerror __ARGS((int));
+
+	static char *
+strerror(err)
+	int err;
+{
+	extern int		sys_nerr;
+	extern char		*sys_errlist[];
+	static char		er[20];
+
+	if (err > 0 && err < sys_nerr)
+		return (sys_errlist[err]);
+	sprintf(er, "Error %d", err);
+	return er;
+}
+#endif
+
+/*
+ * Get name of current directory into buffer 'buf' of length 'len' bytes.
+ * Return OK for success, FAIL for failure.
+ */
+	int 
+mch_dirname(buf, len)
+	char_u	*buf;
+	int		len;
+{
+#if defined(USE_GETCWD)
+	if (getcwd((char *)buf, len) == NULL)
+	{
+	    STRCPY(buf, strerror(errno));
+	    return FAIL;
+	}
+    return OK;
+#else
+	return (getwd((char *)buf) != NULL ? OK : FAIL);
+#endif
+}
+
+#ifdef __EMX__
+/*
+ * Replace all slashes by backslashes.
+ */
+	static void
+slash_adjust(p)
+	char_u	*p;
+{
+	while (*p)
+	{
+		if (*p == '/')
+			*p = '\\';
+		++p;
+	}
+}
+#endif
+
+/*
+ * Get absolute filename into buffer 'buf' of length 'len' bytes.
+ *
+ * return FAIL for failure, OK for success
+ */
+	int 
+FullName(fname, buf, len, force)
+	char_u *fname, *buf;
+	int len;
+	int	force;			/* also expand when already absolute path name */
+{
+	int		l;
+#ifdef OS2
+	int		only_drive;	/* only a drive letter is specified in file name */
+#endif
+#ifdef HAVE_FCHDIR
+	int		fd = -1;
+	static int	dont_fchdir = FALSE;	/* TRUE when fchdir() doesn't work */
+#endif
+	char_u	olddir[MAXPATHL];
+	char_u	*p;
+	char_u	c;
+	int		retval = OK;
+
+	if (fname == NULL)	/* always fail */
+	{
+		*buf = NUL;
+		return FAIL;
+	}
+
+	*buf = 0;
+	if (force || !isFullName(fname))	/* if forced or not an absolute path */
+	{
+		/*
+		 * If the file name has a path, change to that directory for a moment,
+		 * and then do the getwd() (and get back to where we were).
+		 * This will get the correct path name with "../" things.
+		 */
+#ifdef OS2
+		only_drive = 0;
+		if (((p = vim_strrchr(fname, '/')) != NULL) ||
+		    ((p = vim_strrchr(fname, '\\')) != NULL) ||
+		    (((p = vim_strchr(fname,  ':')) != NULL) && ++only_drive))
+#else
+		if ((p = vim_strrchr(fname, '/')) != NULL)
+#endif
+		{
+#ifdef HAVE_FCHDIR
+			/*
+			 * Use fchdir() if possible, it's said to be faster and more
+			 * reliable.  But on SunOS 4 it might not work.  Check this by
+			 * doing a fchdir() right now.
+			 */
+			if (!dont_fchdir)
+			{
+				fd = open(".", O_RDONLY | O_EXTRA);
+				if (fd >= 0 && fchdir(fd) < 0)
+				{
+					close(fd);
+					fd = -1;
+					dont_fchdir = TRUE;		/* don't try again */
+				}
+			}
+#endif
+			if (
+#ifdef HAVE_FCHDIR
+				fd < 0 &&
+#endif
+							mch_dirname(olddir, MAXPATHL) == FAIL)
+			{
+				p = NULL;		/* can't get current dir: don't chdir */
+				retval = FAIL;
+			}
+			else
+			{
+#ifdef OS2
+				/*
+				 * compensate for case where ':' from "D:" was the only
+				 * path separator detected in the file name; the _next_
+				 * character has to be removed, and then restored later.
+				 */
+				if (only_drive)
+					p++;
+#endif
+				c = *p;
+				*p = NUL;
+				if (vim_chdir((char *)fname))
+					retval = FAIL;
+				else
+					fname = p + 1;
+				*p = c;
+#ifdef OS2
+				if (only_drive)
+				{
+					p--;
+					if (retval != FAIL)
+						fname--;
+				}
+#endif
+			}
+		}
+		if (mch_dirname(buf, len) == FAIL)
+		{
+			retval = FAIL;
+			*buf = NUL;
+		}
+		l = STRLEN(buf);
+		if (l && buf[l - 1] != '/')
+			STRCAT(buf, "/");
+		if (p != NULL)
+		{
+#ifdef HAVE_FCHDIR
+			if (fd >= 0)
+			{
+				fchdir(fd);
+				close(fd);
+			}
+			else
+#endif
+				vim_chdir((char *)olddir);
+		}
+	}
+	STRCAT(buf, fname);
+#ifdef OS2
+	slash_adjust(buf);
+#endif
+	return retval;
+}
+
+/*
+ * return TRUE is fname is an absolute path name
+ */
+	int
+isFullName(fname)
+	char_u		*fname;
+{
+#ifdef __EMX__
+	return _fnisabs(fname);
+#else
+	return (*fname == '/' || *fname == '~');
+#endif
+}
+
+/*
+ * get file permissions for 'name'
+ */
+	long 
+getperm(name)
+	char_u *name;
+{
+	struct stat statb;
+
+	if (stat((char *)name, &statb))
+		return -1;
+	return statb.st_mode;
+}
+
+/*
+ * set file permission for 'name' to 'perm'
+ *
+ * return FAIL for failure, OK otherwise
+ */
+	int
+setperm(name, perm)
+	char_u *name;
+	int perm;
+{
+	return (chmod((char *)name, (mode_t)perm) == 0 ? OK : FAIL);
+}
+
+/*
+ * return TRUE if "name" is a directory
+ * return FALSE if "name" is not a directory
+ * return FALSE for error
+ */
+	int 
+mch_isdir(name)
+	char_u *name;
+{
+	struct stat statb;
+
+	if (stat((char *)name, &statb))
+		return FALSE;
+#ifdef _POSIX_SOURCE
+	return (S_ISDIR(statb.st_mode) ? TRUE : FALSE);
+#else
+	return ((statb.st_mode & S_IFMT) == S_IFDIR ? TRUE : FALSE);
+#endif
+}
+
+	void
+mch_windexit(r)
+	int r;
+{
+	settmode(0);
+	exiting = TRUE;
+	mch_settitle(oldtitle, oldicon);	/* restore xterm title */
+	stoptermcap();
+	flushbuf();
+	ml_close_all(TRUE); 				/* remove all memfiles */
+	may_core_dump();
+	exit(r);
+}
+
+	static void
+may_core_dump()
+{
+#ifdef SIGQUIT
+	signal(SIGQUIT, SIG_DFL);
+	if (core_dump)
+		kill(getpid(), SIGQUIT);		/* force a core dump */
+#endif
+}
+
+static int curr_tmode = 0;	/* contains current raw/cooked mode (0 = cooked) */
+
+	void
+mch_settmode(raw)
+	int				raw;
+{
+	static int first = TRUE;
+
+	/* Why is NeXT excluded here (and not in unixunix.h)? */
+#if defined(ECHOE) && defined(ICANON) && (defined(HAVE_TERMIO_H) || defined(HAVE_TERMIOS_H)) && !defined(__NeXT__)
+	/* for "new" tty systems */
+# ifdef HAVE_TERMIOS_H
+	static struct termios told;
+		   struct termios tnew;
+# else
+	static struct termio told;
+		   struct termio tnew;
+# endif
+
+# ifdef TIOCLGET
+	static unsigned long tty_local;
+# endif
+
+	if (raw)
+	{
+		if (first)
+		{
+			first = FALSE;
+# ifdef TIOCLGET
+			ioctl(0, TIOCLGET, &tty_local);
+# endif
+# if defined(HAVE_TERMIOS_H)
+			tcgetattr(0, &told);
+# else
+			ioctl(0, TCGETA, &told);
+# endif
+		}
+		tnew = told;
+		/*
+		 * ICRNL enables typing ^V^M
+		 */
+		tnew.c_iflag &= ~ICRNL;
+		tnew.c_lflag &= ~(ICANON | ECHO | ISIG | ECHOE
+# if defined(IEXTEN) && !defined(MINT)
+					| IEXTEN		/* IEXTEN enables typing ^V on SOLARIS */
+									/* but it breaks function keys on MINT */
+# endif
+								);
+		tnew.c_cc[VMIN] = 1;			/* return after 1 char */
+		tnew.c_cc[VTIME] = 0;			/* don't wait */
+# if defined(HAVE_TERMIOS_H)
+		tcsetattr(0, TCSANOW, &tnew);
+# else
+		ioctl(0, TCSETA, &tnew);
+# endif
+	}
+	else
+	{
+# if defined(HAVE_TERMIOS_H)
+		tcsetattr(0, TCSANOW, &told);
+# else
+		ioctl(0, TCSETA, &told);
+# endif
+# ifdef TIOCLGET
+		ioctl(0, TIOCLSET, &tty_local);
+# endif
+	}
+#else
+# ifndef TIOCSETN
+#  define TIOCSETN TIOCSETP		/* for hpux 9.0 */
+# endif
+	/* for "old" tty systems */
+	static struct sgttyb ttybold;
+		   struct sgttyb ttybnew;
+
+	if (raw)
+	{
+		if (first)
+		{
+			first = FALSE;
+			ioctl(0, TIOCGETP, &ttybold);
+		}
+		ttybnew = ttybold;
+		ttybnew.sg_flags &= ~(CRMOD | ECHO);
+		ttybnew.sg_flags |= RAW;
+		ioctl(0, TIOCSETN, &ttybnew);
+	}
+	else
+		ioctl(0, TIOCSETN, &ttybold);
+#endif
+	curr_tmode = raw;
+}
+
+/*
+ * Try to get the code for "t_kb" from the stty setting
+ *
+ * Even if termcap claims a backspace key, the user's setting *should*
+ * prevail.  stty knows more about reality than termcap does, and if
+ * somebody's usual erase key is DEL (which, for most BSD users, it will
+ * be), they're going to get really annoyed if their erase key starts
+ * doing forward deletes for no reason. (Eric Fischer)
+ */
+	void
+get_stty()
+{
+	char_u	buf[2];
+	char_u	*p;
+
+	/* Why is NeXT excluded here (and not in unixunix.h)? */
+#if defined(ECHOE) && defined(ICANON) && (defined(HAVE_TERMIO_H) || defined(HAVE_TERMIOS_H)) && !defined(__NeXT__)
+	/* for "new" tty systems */
+# ifdef HAVE_TERMIOS_H
+	struct termios keys;
+# else
+	struct termio keys;
+# endif
+
+# if defined(HAVE_TERMIOS_H)
+	if (tcgetattr(0, &keys) != -1)
+# else
+	if (ioctl(0, TCGETA, &keys) != -1)
+# endif
+	{
+		buf[0] = keys.c_cc[VERASE];
+#else
+	/* for "old" tty systems */
+	struct sgttyb keys;
+
+	if (ioctl(0, TIOCGETP, &keys) != -1)
+	{
+		buf[0] = keys.sg_erase;
+#endif
+		buf[1] = NUL;
+		add_termcode((char_u *)"kb", buf);
+
+		/*
+		 * If <BS> and <DEL> are now the same, redefine <DEL>.
+		 */
+		p = find_termcode((char_u *)"kD");
+		if (p != NULL && p[0] == buf[0] && p[1] == buf[1])
+			do_fixdel();
+	}
+#if 0
+	}		/* to keep cindent happy */
+#endif
+}
+
+#ifdef USE_MOUSE
+/*
+ * set mouse clicks on or off (only works for xterms)
+ */
+	void
+mch_setmouse(on)
+	int		on;
+{
+	static int	ison = FALSE;
+
+	if (on == ison)		/* return quickly if nothing to do */
+		return;
+
+	if (is_xterm(term_strings[KS_NAME]))
+	{
+		if (on)
+			outstrn((char_u *)"\033[?1000h"); /* xterm: enable mouse events */
+		else
+			outstrn((char_u *)"\033[?1000l"); /* xterm: disable mouse events */
+	}
+	ison = on;
+}
+#endif
+
+/*
+ * set screen mode, always fails.
+ */
+	int
+mch_screenmode(arg)
+	char_u	 *arg;
+{
+	EMSG("Screen mode setting not supported");
+	return FAIL;
+}
+
+/*
+ * Try to get the current window size:
+ * 1. with an ioctl(), most accurate method
+ * 2. from the environment variables LINES and COLUMNS
+ * 3. from the termcap
+ * 4. keep using the old values
+ */
+	int
+mch_get_winsize()
+{
+	int			old_Rows = Rows;
+	int			old_Columns = Columns;
+	char_u		*p;
+
+#ifdef USE_GUI
+	if (gui.in_use)
+		return gui_mch_get_winsize();
+#endif
+
+	Columns = 0;
+	Rows = 0;
+
+/*
+ * For OS/2 use _scrsize().
+ */
+# ifdef __EMX__
+	{
+		int s[2];
+		_scrsize(s);
+		Columns = s[0];
+		Rows = s[1];
+	}
+# endif
+
+/*
+ * 1. try using an ioctl. It is the most accurate method.
+ *
+ * Try using TIOCGWINSZ first, some systems that have it also define TIOCGSIZE
+ * but don't have a struct ttysize.
+ */
+# ifdef TIOCGWINSZ
+	{
+		struct winsize	ws;
+
+	    if (ioctl(0, TIOCGWINSZ, &ws) == 0)
+	    {
+			Columns = ws.ws_col;
+			Rows = ws.ws_row;
+	    }
+	}
+# else /* TIOCGWINSZ */
+#  ifdef TIOCGSIZE
+	{
+		struct ttysize	ts;
+
+	    if (ioctl(0, TIOCGSIZE, &ts) == 0)
+	    {
+			Columns = ts.ts_cols;
+			Rows = ts.ts_lines;
+	    }
+	}
+#  endif /* TIOCGSIZE */
+# endif /* TIOCGWINSZ */
+
+/*
+ * 2. get size from environment
+ */
+	if (Columns == 0 || Rows == 0)
+	{
+	    if ((p = (char_u *)getenv("LINES")))
+			Rows = atoi((char *)p);
+	    if ((p = (char_u *)getenv("COLUMNS")))
+			Columns = atoi((char *)p);
+	}
+
+#ifdef HAVE_TGETENT
+/*
+ * 3. try reading the termcap
+ */
+	if (Columns == 0 || Rows == 0)
+		getlinecol();	/* get "co" and "li" entries from termcap */
+#endif
+
+/*
+ * 4. If everything fails, use the old values
+ */
+	if (Columns <= 0 || Rows <= 0)
+	{
+		Columns = old_Columns;
+		Rows = old_Rows;
+		return FAIL;
+	}
+
+	check_winsize();
+
+/* if size changed: screenalloc will allocate new screen buffers */
+	return OK;
+}
+
+	void
+mch_set_winsize()
+{
+	char_u	string[10];
+
+#ifdef USE_GUI
+	if (gui.in_use)
+	{
+		gui_mch_set_winsize();
+		return;
+	}
+#endif
+
+	/* try to set the window size to Rows and Columns */
+	if (is_iris_ansi(term_strings[KS_NAME]))
+	{
+		sprintf((char *)string, "\033[203;%ld;%ld/y", Rows, Columns);
+		outstrn(string);
+		flushbuf();
+		screen_start();					/* don't know where cursor is now */
+	}
+}
+
+	int 
+call_shell(cmd, options)
+	char_u	*cmd;
+	int		options;		/* SHELL_FILTER if called by do_filter() */
+							/* SHELL_COOKED if term needs cooked mode */
+							/* SHELL_EXPAND if called by ExpandWildCards() */
+{
+#ifdef USE_SYSTEM		/* use system() to start the shell: simple but slow */
+
+	int		x;
+#ifndef __EMX__
+	char_u	newcmd[1024];	/* only needed for unix */
+#else /* __EMX__ */
+	/*
+	 * Set the preferred shell in the EMXSHELL environment variable (but
+	 * only if it is different from what is already in the environment).
+	 * Emx then takes care of whether to use "/c" or "-c" in an
+	 * intelligent way. Simply pass the whole thing to emx's system() call.
+	 * Emx also starts an interactive shell if system() is passed an empty
+	 * string.
+	 */
+	char_u *p, *old;
+
+	if (((old = getenv("EMXSHELL")) == NULL) || strcmp(old, p_sh))
+	{
+		/* should check HAVE_SETENV, but I know we don't have it. */
+		p = alloc(10 + strlen(p_sh));
+		if (p)
+		{
+			sprintf(p, "EMXSHELL=%s", p_sh);
+			putenv(p);	/* don't free the pointer! */
+		}
+	}
+#endif
+
+	flushbuf();
+
+	if (options & SHELL_COOKED)
+		settmode(0); 				/* set to cooked mode */
+
+#ifdef __EMX__
+	if (cmd == NULL)
+		x = system("");	/* this starts an interactive shell in emx */
+	else
+		x = system(cmd);
+	if (x == -1) /* system() returns -1 when error occurs in starting shell */
+	{
+		MSG_OUTSTR("\nCannot execute shell ");
+		msg_outstr(p_sh);
+		msg_outchar('\n');
+	}
+#else /* not __EMX__ */
+	if (cmd == NULL)
+		x = system(p_sh);
+	else
+	{
+		sprintf(newcmd, "%s %s -c \"%s\"", p_sh,
+					extra_shell_arg == NULL ? "" : (char *)extra_shell_arg,
+					(char *)cmd);
+		x = system(newcmd);
+	}
+	if (x == 127)
+	{
+ 		MSG_OUTSTR("\nCannot execute shell sh\n");
+	}
+#endif	/* __EMX__ */
+	else if (x && !expand_interactively)
+	{
+		msg_outchar('\n');
+		msg_outnum((long)x);
+		MSG_OUTSTR(" returned\n");
+	}
+
+	settmode(1); 						/* set to raw mode */
+#ifdef OS2
+	/* external command may change the window size in OS/2, so check it */
+	mch_get_winsize();
+#endif
+	resettitle();
+	return (x ? FAIL : OK);
+
+#else /* USE_SYSTEM */		/* don't use system(), use fork()/exec() */
+
+#define EXEC_FAILED 122		/* Exit code when shell didn't execute.  Don't use
+							   127, some shell use that already */
+
+	char_u	newcmd[1024];
+	int		pid;
+#ifdef HAVE_UNION_WAIT
+	union wait status;
+#else
+	int		status = -1;
+#endif
+	int		retval = FAIL;
+	char	**argv = NULL;
+	int		argc;
+	int		i;
+	char_u	*p;
+	int		inquote;
+#ifdef USE_GUI
+	int		pty_master_fd = -1;		/* for pty's */
+	int		pty_slave_fd = -1;
+	char	*tty_name;
+	int		fd_toshell[2];			/* for pipes */
+	int		fd_fromshell[2];
+	int		pipe_error = FALSE;
+# ifdef HAVE_SETENV
+	char	envbuf[50];
+# else
+	static char	envbuf_Rows[20];
+	static char	envbuf_Columns[20];
+# endif
+#endif
+	int		did_settmode = FALSE;	/* TRUE when settmode(1) called */
+
+	flushbuf();
+	if (options & SHELL_COOKED)
+		settmode(0);			/* set to cooked mode */
+
+	/*
+	 * 1: find number of arguments
+	 * 2: separate them and built argv[]
+	 */
+	STRCPY(newcmd, p_sh);
+	for (i = 0; i < 2; ++i)	
+	{
+		p = newcmd;
+		inquote = FALSE;
+		argc = 0;
+		for (;;)
+		{
+			if (i == 1)
+				argv[argc] = (char *)p;
+			++argc;
+			while (*p && (inquote || (*p != ' ' && *p != TAB)))
+			{
+				if (*p == '"')
+					inquote = !inquote;
+				++p;
+			}
+			if (*p == NUL)
+				break;
+			if (i == 1)
+				*p++ = NUL;
+			p = skipwhite(p);
+		}
+		if (i == 0)
+		{
+			argv = (char **)alloc((unsigned)((argc + 4) * sizeof(char *)));
+			if (argv == NULL)		/* out of memory */
+				goto error;
+		}
+	}
+	if (cmd != NULL)
+	{
+		if (extra_shell_arg != NULL)
+			argv[argc++] = (char *)extra_shell_arg;
+		argv[argc++] = "-c";
+		argv[argc++] = (char *)cmd;
+	}
+	argv[argc] = NULL;
+
+#ifdef tower32
+	/*
+	 * reap lost children (seems necessary on NCR Tower,
+	 * although I don't have a clue why...) (Slootman)
+	 */
+	while (wait(&status) != 0 && errno != ECHILD)
+		;	/* do it again, if necessary */
+#endif
+
+#ifdef USE_GUI
+/*
+ * First try at using a pseudo-tty to get the stdin/stdout of the executed
+ * command into the current window for the GUI.
+ */
+
+	if (gui.in_use && show_shell_mess)
+	{
+		/*
+		 * Try to open a master pty.
+		 * If this works, open the slave pty.
+		 * If the slave can't be opened, close the master pty.
+		 */
+		if (p_guipty)
+		{
+			pty_master_fd = OpenPTY(&tty_name);		/* open pty */
+			if (pty_master_fd >= 0 && ((pty_slave_fd =
+									   open(tty_name, O_RDWR | O_EXTRA)) < 0))
+			{
+				close(pty_master_fd);
+				pty_master_fd = -1;
+			}
+		}
+		/*
+		 * If opening a pty didn't work, try using pipes.
+		 */
+		if (pty_master_fd < 0)
+		{
+			pipe_error = (pipe(fd_toshell) < 0);
+			if (!pipe_error)						/* pipe create OK */
+			{
+				pipe_error = (pipe(fd_fromshell) < 0);
+				if (pipe_error)						/* pipe create failed */
+				{
+					close(fd_toshell[0]);
+					close(fd_toshell[1]);
+				}
+			}
+			if (pipe_error)
+			{
+				MSG_OUTSTR("\nCannot create pipes\n");
+				flushbuf();
+			}
+		}
+	}
+
+	if (!pipe_error)					/* pty or pipe opened or not used */
+#endif
+
+	{
+		if ((pid = fork()) == -1)		/* maybe we should use vfork() */
+		{
+			MSG_OUTSTR("\nCannot fork\n");
+#ifdef USE_GUI
+			if (gui.in_use && show_shell_mess)
+			{
+				if (pty_master_fd >= 0)			/* close the pseudo tty */
+				{
+					close(pty_master_fd);
+					close(pty_slave_fd);
+				}
+				else							/* close the pipes */
+				{
+					close(fd_toshell[0]);
+					close(fd_toshell[1]);
+					close(fd_fromshell[0]);
+					close(fd_fromshell[1]);
+				}
+			}
+#endif
+		}
+		else if (pid == 0)		/* child */
+		{
+			reset_signals();			/* handle signals normally */
+			if (!show_shell_mess)
+			{
+				int fd;
+
+				/*
+				 * Don't want to show any message from the shell.  Can't just
+				 * close stdout and stderr though, because some systems will
+				 * break if you try to write to them after that, so we must
+				 * use dup() to replace them with something else -- webb
+				 */
+				fd = open("/dev/null", O_WRONLY | O_EXTRA);
+				fclose(stdout);
+				fclose(stderr);
+
+				/*
+				 * If any of these open()'s and dup()'s fail, we just continue
+				 * anyway.  It's not fatal, and on most systems it will make
+				 * no difference at all.  On a few it will cause the execvp()
+				 * to exit with a non-zero status even when the completion
+				 * could be done, which is nothing too serious.  If the open()
+				 * or dup() failed we'd just do the same thing ourselves
+				 * anyway -- webb
+				 */
+				if (fd >= 0)
+				{
+					/* To replace stdout (file descriptor 1) */
+					dup(fd);
+
+					/* To replace stderr (file descriptor 2) */
+					dup(fd);
+
+					/* Don't need this now that we've duplicated it */
+					close(fd);
+				}
+			}
+#ifdef USE_GUI
+			else if (gui.in_use)
+			{
+
+#ifdef HAVE_SETSID
+				(void)setsid();
+#endif
+#ifdef TIOCSCTTY
+				/* try to become controlling tty (probably doesn't work,
+				 * unless run by root) */
+				ioctl(pty_slave_fd, TIOCSCTTY, (char *)NULL);
+#endif
+				/* Simulate to have a dumb terminal (for now) */
+#ifdef HAVE_SETENV
+				setenv("TERM", "dumb", 1);
+				sprintf((char *)envbuf, "%ld", Rows);
+				setenv("ROWS", (char *)envbuf, 1);
+				sprintf((char *)envbuf, "%ld", Columns);
+				setenv("COLUMNS", (char *)envbuf, 1);
+#else
+				/*
+				 * Putenv does not copy the string, it has to remain valid.
+				 * Use a static array to avoid loosing allocated memory.
+				 */
+				putenv("TERM=dumb");
+				sprintf(envbuf_Rows, "ROWS=%ld", Rows);
+				putenv(envbuf_Rows);
+				sprintf(envbuf_Columns, "COLUMNS=%ld", Columns);
+				putenv(envbuf_Columns);
+#endif
+
+				if (pty_master_fd >= 0)
+				{
+					close(pty_master_fd);	/* close master side of pty */
+
+					/* set up stdin/stdout/stderr for the child */
+					close(0);
+					dup(pty_slave_fd);
+					close(1);
+					dup(pty_slave_fd);
+					close(2);
+					dup(pty_slave_fd);
+
+					close(pty_slave_fd);	/* has been dupped, close it now */
+				}
+				else
+				{
+					/* set up stdin for the child */
+					close(fd_toshell[1]);
+					close(0);
+					dup(fd_toshell[0]);
+					close(fd_toshell[0]);
+
+					/* set up stdout for the child */
+					close(fd_fromshell[0]);
+					close(1);
+					dup(fd_fromshell[1]);
+					close(fd_fromshell[1]);
+
+					/* set up stderr for the child */
+					close(2);
+					dup(1);
+				}
+			}
+#endif
+			/*
+			 * There is no type cast for the argv, because the type may be
+			 * different on different machines. This may cause a warning
+			 * message with strict compilers, don't worry about it.
+			 */
+			execvp(argv[0], argv);
+			exit(EXEC_FAILED);		/* exec failed, return failure code */
+		}
+		else					/* parent */
+		{
+			/*
+			 * While child is running, ignore terminating signals.
+			 */
+			catch_signals(SIG_IGN);
+
+#ifdef USE_GUI
+
+			/*
+			 * For the GUI we redirect stdin, stdout and stderr to our window.
+			 */
+			if (gui.in_use && show_shell_mess)
+			{
+#define BUFLEN 100				/* length for buffer, pseudo tty limit is 128 */
+				char_u		buffer[BUFLEN];
+				int			len;
+				int			p_more_save;
+				int			old_State;
+				int			read_count;
+				int			c;
+				int			toshell_fd;
+				int			fromshell_fd;
+
+				if (pty_master_fd >= 0)
+				{
+					close(pty_slave_fd);		/* close slave side of pty */
+					fromshell_fd = pty_master_fd;
+					toshell_fd = dup(pty_master_fd);
+				}
+				else
+				{
+					close(fd_toshell[0]);
+					close(fd_fromshell[1]);
+					toshell_fd = fd_toshell[1];
+					fromshell_fd = fd_fromshell[0];
+				}
+
+				/*
+				 * Write to the child if there are typed characters.
+				 * Read from the child if there are characters available.
+				 *   Repeat the reading a few times if more characters are
+				 *   available. Need to check for typed keys now and then, but
+				 *   not too often (delays when no chars are available).
+				 * This loop is quit if no characters can be read from the pty
+				 * (WaitForChar detected special condition), or there are no
+				 * characters available and the child has exited.
+				 * Only check if the child has exited when there is no more
+				 * output. The child may exit before all the output has
+				 * been printed.
+				 *
+				 * Currently this busy loops!
+				 * This can probably dead-lock when the write blocks!
+				 */
+				p_more_save = p_more;
+				p_more = FALSE;
+				old_State = State;
+				State = EXTERNCMD;		/* don't redraw at window resize */
+
+				for (;;)
+				{
+					/*
+					 * Check if keys have been typed, write them to the child
+					 * if there are any.  Don't do this if we are expanding
+					 * wild cards (would eat typeahead).
+					 */
+					if (!(options & SHELL_EXPAND) &&
+							  (len = mch_inchar(buffer, BUFLEN - 1, 10)) != 0)
+					{
+						/*
+						 * For pipes:
+						 * Check for CTRL-C: sent interrupt signal to child.
+						 * Check for CTRL-D: EOF, close pipe to child.
+						 */
+						if (len == 1 && (pty_master_fd < 0 || cmd != NULL))
+						{
+#ifdef SIGINT
+							if (buffer[0] == Ctrl('C'))
+							{
+								/* Use both kill() and killpg(), in case one
+								 * of the two fails */
+								kill(pid, SIGINT);
+# ifdef HAVE_KILLPG
+								killpg(0, SIGINT);
+# endif
+							}
+#endif
+							if (pty_master_fd < 0 && toshell_fd >= 0 &&
+													   buffer[0] == Ctrl('D'))
+							{
+								close(toshell_fd);
+								toshell_fd = -1;
+							}
+						}
+
+						/* replace K_BS by <BS> and K_DEL by <DEL> */
+						for (i = 0; i < len; ++i)
+						{
+							if (buffer[i] == CSI && len - i > 2)
+							{
+								c = TERMCAP2KEY(buffer[i + 1], buffer[i + 2]);
+								if (c == K_DEL || c == K_BS)
+								{
+									vim_memmove(buffer + i + 1, buffer + i + 3,
+													   (size_t)(len - i - 2));
+									if (c == K_DEL)
+										buffer[i] = DEL;
+									else
+										buffer[i] = Ctrl('H');
+									len -= 2;
+								}
+							}
+							else if (buffer[i] == '\r')
+								buffer[i] = '\n';
+						}
+
+						/*
+						 * For pipes: echo the typed characters.
+						 * For a pty this does not seem to work.
+						 */
+						if (pty_master_fd < 0)
+						{
+							for (i = 0; i < len; ++i)
+								if (buffer[i] == '\n' || buffer[i] == '\b')
+									msg_outchar(buffer[i]);
+								else
+									msg_outtrans_len(buffer + i, 1);
+							windgoto(msg_row, msg_col);
+							flushbuf();
+						}
+
+						/*
+						 * Write the characters to the child, unless EOF has
+						 * been typed for pipes.  Ignore errors.
+						 */
+						if (toshell_fd >= 0)
+							write(toshell_fd, (char *)buffer, (size_t)len);
+					}
+
+					/*
+					 * Check if the child has any characters to be printed.
+					 * Read them and write them to our window.
+					 * Repeat this a few times as long as there is something
+					 * to do, avoid the 10ms wait for mch_inchar().
+					 * TODO: This should handle escape sequences.
+					 */
+					for (read_count = 0; read_count < 10 &&
+							 RealWaitForChar(fromshell_fd, 10); ++read_count)
+					{
+						len = read(fromshell_fd, (char *)buffer,
+															  (size_t)BUFLEN);
+						if (len == 0)				/* end of file */
+							goto finished;
+						buffer[len] = NUL;
+						msg_outstr(buffer);
+						windgoto(msg_row, msg_col);
+						cursor_on();
+						flushbuf();
+					}
+
+					/*
+					 * Check if the child still exists when we finished
+					 * outputting all characters.
+					 */
+					if (read_count == 0 &&
+#ifdef __NeXT__
+							wait4(pid, &status, WNOHANG, (struct rusage *) 0) &&
+#else
+							waitpid(pid, &status, WNOHANG) &&
+#endif
+															WIFEXITED(status))
+						break;
+				}
+finished:
+				p_more = p_more_save;
+				State = old_State;
+				if (toshell_fd >= 0)
+					close(toshell_fd);
+				close(fromshell_fd);
+			}
+#endif /* USE_GUI */
+
+			/*
+			 * Wait until child has exited.
+			 */
+#ifdef ECHILD
+			/* Don't stop waiting when a signal (e.g. SIGWINCH) is received. */
+			while (wait(&status) == -1 && errno != ECHILD)
+				;
+#else
+			wait(&status);
+#endif
+			/*
+			 * Set to raw mode right now, otherwise a CTRL-C after
+			 * catch_signals will kill Vim.
+			 */
+			settmode(1);
+			did_settmode = TRUE;
+			catch_signals(deathtrap);
+
+			/*
+			 * Check the window size, in case it changed while executing the
+			 * external command.
+			 */
+			mch_get_winsize();
+
+			if (WIFEXITED(status))
+			{
+				i = WEXITSTATUS(status);
+				if (i)
+				{
+					if (i == EXEC_FAILED)
+					{
+						MSG_OUTSTR("\nCannot execute shell ");
+						msg_outtrans(p_sh);
+						msg_outchar('\n');
+					}
+					else if (!expand_interactively)
+					{
+						msg_outchar('\n');
+						msg_outnum((long)i);
+						MSG_OUTSTR(" returned\n");
+					}
+				}
+				else
+					retval = OK;
+			}
+			else
+				MSG_OUTSTR("\nCommand terminated\n");
+		}
+	}
+	vim_free(argv);
+
+error:
+	if (!did_settmode)
+		settmode(1); 						/* always set to raw mode */
+	resettitle();
+
+	return retval;
+
+#endif /* USE_SYSTEM */
+}
+
+/*
+ * The input characters are buffered to be able to check for a CTRL-C.
+ * This should be done with signals, but I don't know how to do that in
+ * a portable way for a tty in RAW mode.
+ */
+
+/*
+ * Internal typeahead buffer.  Includes extra space for long key code
+ * descriptions which would otherwise overflow.  The buffer is considered full
+ * when only this extra space (or part of it) remains.
+ */
+#define INBUFLEN 250
+
+static char_u	inbuf[INBUFLEN + MAX_KEY_CODE_LEN];
+static int		inbufcount = 0;		/* number of chars in inbuf[] */
+
+/*
+ * is_input_buf_full(), is_input_buf_empty(), add_to_input_buf(), and
+ * trash_input_buf() are functions for manipulating the input buffer.  These
+ * are used by the gui_* calls when a GUI is used to handle keyboard input.
+ *
+ * NOTE: These functions will be identical in msdos.c etc, and should probably
+ * be taken out and put elsewhere, but at the moment inbuf is only local.
+ */
+
+	int
+is_input_buf_full()
+{
+	return (inbufcount >= INBUFLEN);
+}
+
+	int
+is_input_buf_empty()
+{
+	return (inbufcount == 0);
+}
+
+/* Add the given bytes to the input buffer */
+	void
+add_to_input_buf(s, len)
+	char_u	*s;
+	int		len;
+{
+	if (inbufcount + len > INBUFLEN + MAX_KEY_CODE_LEN)
+		return;		/* Shouldn't ever happen! */
+	
+	while (len--)
+		inbuf[inbufcount++] = *s++;
+}
+
+/* Remove everything from the input buffer.  Called when ^C is found */
+	void
+trash_input_buf()
+{
+	inbufcount = 0;
+}
+
+	static int
+Read(buf, maxlen)
+	char_u	*buf;
+	long	maxlen;
+{
+	if (inbufcount == 0)		/* if the buffer is empty, fill it */
+		fill_inbuf(TRUE);
+	if (maxlen > inbufcount)
+		maxlen = inbufcount;
+	vim_memmove(buf, inbuf, (size_t)maxlen);
+	inbufcount -= maxlen;
+	if (inbufcount)
+		vim_memmove(inbuf, inbuf + maxlen, (size_t)inbufcount);
+	return (int)maxlen;
+}
+
+	void
+mch_breakcheck()
+{
+#ifdef USE_GUI
+	if (gui.in_use)
+	{
+		gui_mch_update();
+		return;
+	}
+#endif /* USE_GUI */
+
+/*
+ * Check for CTRL-C typed by reading all available characters.
+ * In cooked mode we should get SIGINT, no need to check.
+ */
+	if (curr_tmode && RealWaitForChar(0, 0L))	/* if characters available */
+		fill_inbuf(FALSE);
+}
+
+	static void
+fill_inbuf(exit_on_error)
+	int	exit_on_error;
+{
+	int		len;
+	int		try;
+
+#ifdef USE_GUI
+	if (gui.in_use)
+	{
+		gui_mch_update();
+		return;
+	}
+#endif
+	if (is_input_buf_full())
+		return;
+	/*
+	 * Fill_inbuf() is only called when we really need a character.
+	 * If we can't get any, but there is some in the buffer, just return.
+	 * If we can't get any, and there isn't any in the buffer, we give up and
+	 * exit Vim.
+	 */
+	for (try = 0; try < 100; ++try)
+	{
+		len = read(0, (char *)inbuf + inbufcount,
+											 (size_t)(INBUFLEN - inbufcount));
+		if (len > 0)
+			break;
+		if (!exit_on_error)
+			return;
+	}
+	if (len <= 0)
+	{
+		windgoto((int)Rows - 1, 0);
+		fprintf(stderr, "Vim: Error reading input, exiting...\n");
+		ml_sync_all(FALSE, TRUE);		/* preserve all swap files */
+		getout(1);
+	}
+	while (len-- > 0)
+	{
+		/*
+		 * if a CTRL-C was typed, remove it from the buffer and set got_int
+		 */
+		if (inbuf[inbufcount] == 3)
+		{
+			/* remove everything typed before the CTRL-C */
+			vim_memmove(inbuf, inbuf + inbufcount, (size_t)(len + 1));
+			inbufcount = 0;
+			got_int = TRUE;
+		}
+		++inbufcount;
+	}
+}
+
+/* 
+ * Wait "msec" msec until a character is available from the keyboard or from
+ * inbuf[]. msec == -1 will block forever.
+ * When a GUI is being used, this will never get called -- webb 
+ */
+
+	static	int
+WaitForChar(msec)
+	long	msec;
+{
+	if (inbufcount)		/* something in inbuf[] */
+		return 1;
+	return RealWaitForChar(0, msec);
+}
+
+/* 
+ * Wait "msec" msec until a character is available from file descriptor "fd".
+ * Time == -1 will block forever.
+ * When a GUI is being used, this will not be used for input -- webb 
+ */
+	static	int
+RealWaitForChar(fd, msec)
+	int		fd;
+	long	msec;
+{
+#ifndef HAVE_SELECT
+	struct pollfd fds;
+
+	fds.fd = fd;
+	fds.events = POLLIN;
+	return (poll(&fds, 1, (int)msec) > 0);	/* is this correct when fd != 0?? */
+#else
+	struct timeval tv;
+	fd_set rfds, efds;
+
+# ifdef __EMX__
+	/* don't check for incoming chars if not in raw mode, because select()
+	 * always returns TRUE then (in some version of emx.dll) */
+	if (curr_tmode == 0)
+		return 0;
+# endif
+
+	if (msec >= 0)
+    {
+   		tv.tv_sec = msec / 1000;
+		tv.tv_usec = (msec % 1000) * (1000000/1000);
+    }
+
+	/*
+	 * Select on ready for reading and exceptional condition (end of file).
+	 */
+	FD_ZERO(&rfds);	/* calls bzero() on a sun */
+	FD_ZERO(&efds);
+	FD_SET(fd, &rfds);
+	FD_SET(fd, &efds);
+	return (select(fd + 1, &rfds, NULL, &efds, (msec >= 0) ? &tv : NULL) > 0);
+#endif
+}
+
+/*
+ * ExpandWildCards() - this code does wild-card pattern matching using the shell
+ *
+ * return OK for success, FAIL for error (you may lose some memory) and put
+ * an error message in *file.
+ *
+ * num_pat is number of input patterns
+ * pat is array of pointers to input patterns
+ * num_file is pointer to number of matched file names
+ * file is pointer to array of pointers to matched file names
+ * On Unix we do not check for files only yet
+ * list_notfound is ignored
+ */
+
+extern char *mktemp __ARGS((char *));
+#ifndef SEEK_SET
+# define SEEK_SET 0
+#endif
+#ifndef SEEK_END
+# define SEEK_END 2
+#endif
+
+	int
+ExpandWildCards(num_pat, pat, num_file, file, files_only, list_notfound)
+	int 			num_pat;
+	char_u		  **pat;
+	int 		   *num_file;
+	char_u		 ***file;
+	int				files_only;
+	int				list_notfound;
+{
+	int		i;
+	size_t	len;
+	char_u	*p;
+#ifdef __EMX__
+# define EXPL_ALLOC_INC	16
+	char_u	**expl_files;
+	size_t	files_alloced, files_free;
+
+	*num_file = 0;		/* default: no files found */
+	files_alloced = EXPL_ALLOC_INC;	/* how much space is allocated */
+	files_free = EXPL_ALLOC_INC;	/* how much space is not used  */
+	*file = (char_u **) alloc(sizeof(char_u **) * files_alloced);
+	if (!*file)
+	{
+		emsg(e_outofmem);
+		return FAIL;
+	}
+
+	for (; num_pat > 0; num_pat--, pat++)
+	{
+		expl_files = NULL;
+		if (vim_strchr(*pat, '$') || vim_strchr(*pat, '~'))
+		{
+			/* expand environment var or home dir */
+			char_u	*buf = alloc(1024);
+			if (!buf)
+			{
+				emsg(e_outofmem);
+				return FAIL;
+			}
+			expand_env(*pat, buf, 1024);
+			if (mch_has_wildcard(buf))	/* still wildcards in there? */
+			{
+				expl_files = (char_u **)_fnexplode(buf);
+			}
+			if (expl_files == NULL)
+			{
+				/*
+				 * If no wildcard still remaining, simply add
+				 * the pattern to the results.
+				 * If wildcard did not match, add the pattern to
+				 * the list of results anyway. This way, doing
+				 * :n exist.c notexist*
+				 * will at least edits exist.c and then say
+				 * notexist* [new file]
+				 */
+				expl_files = (char_u **)alloc(sizeof(char_u **) * 2);
+				expl_files[0] = strsave(buf);
+				expl_files[1] = NULL;
+			}
+			vim_free(buf);
+		}
+		else
+		{
+			expl_files = (char_u **)_fnexplode(*pat);
+			if (expl_files == NULL)
+			{
+				/* see above for explanation */
+				expl_files = (char_u **)alloc(sizeof(char_u **) * 2);
+				expl_files[0] = strsave(*pat);
+				expl_files[1] = NULL;
+			}
+		}
+		if (!expl_files)
+		{
+			/* Can't happen */
+			char_u msg[128];
+			sprintf(msg, "%s (unix.c:%d)", e_internal, __LINE__);
+			emsg(msg);
+			*file = (char_u **)"";
+			*num_file = 0;
+			return OK;
+		}
+		/*
+		 * Count number of names resulting from expansion,
+		 * At the same time add a backslash to the end of names that happen to be
+		 * directories, and replace slashes with backslashes.
+		 */
+		for (i = 0; (p = expl_files[i]) != NULL; i++, (*num_file)++)
+		{
+			if (--files_free == 0)
+			{
+				/* need more room in table of pointers */
+				files_alloced += EXPL_ALLOC_INC;
+				*file = (char_u **) realloc(*file,
+											sizeof(char_u **) * files_alloced);
+				files_free = EXPL_ALLOC_INC;
+			}
+			slash_adjust(p);
+			if (mch_isdir(p))
+			{
+				len = strlen(p);
+				p = realloc(p, len + 2);
+				if (!p)
+				{
+					emsg(e_outofmem);
+					return FAIL;
+				}
+				(*file)[*num_file] = p;
+				p += len;
+				*p++ = '\\';
+				*p = 0;
+			}
+			else
+			{
+				(*file)[*num_file] = strsave(p);
+			}
+		}
+		_fnexplodefree(expl_files);
+	}
+	return OK;
+
+#else /* __EMX__ */
+
+	int		dir;
+	char_u	tmpname[TMPNAMELEN];
+	char_u	*command;
+	FILE	*fd;
+	char_u	*buffer;
+	int		use_glob = FALSE;
+
+	*num_file = 0;		/* default: no files found */
+	*file = (char_u **)"";
+
+	/*
+	 * If there are no wildcards, just copy the names to allocated memory.
+	 * Saves a lot of time, because we don't have to start a new shell.
+	 */
+	if (!have_wildcard(num_pat, pat))
+	{
+		*file = (char_u **)alloc(num_pat * sizeof(char_u *));
+		if (*file == NULL)
+		{
+			*file = (char_u **)"";
+			return FAIL;
+		}
+		for (i = 0; i < num_pat; i++)
+			(*file)[i] = strsave(pat[i]);
+		*num_file = num_pat;
+		return OK;
+	}
+
+/*
+ * get a name for the temp file
+ */
+	STRCPY(tmpname, TMPNAME2);
+	if (*mktemp((char *)tmpname) == NUL)
+	{
+		emsg(e_notmp);
+	    return FAIL;
+	}
+
+/*
+ * let the shell expand the patterns and write the result into the temp file
+ * If we use csh, glob will work better than echo.
+ */
+	if ((len = STRLEN(p_sh)) >= 3 && STRCMP(p_sh + len - 3, "csh") == 0)
+		use_glob = TRUE;
+
+	len = TMPNAMELEN + 11;
+	for (i = 0; i < num_pat; ++i)		/* count the length of the patterns */
+		len += STRLEN(pat[i]) + 3;
+	command = alloc(len);
+	if (command == NULL)
+		return FAIL;
+	if (use_glob)
+		STRCPY(command, "glob >");		/* build the shell command */
+	else
+		STRCPY(command, "echo >");		/* build the shell command */
+	STRCAT(command, tmpname);
+	for (i = 0; i < num_pat; ++i)
+	{
+#ifdef USE_SYSTEM
+		STRCAT(command, " \"");				/* need extra quotes because we */
+		STRCAT(command, pat[i]);			/*   start the shell twice */
+		STRCAT(command, "\"");
+#else
+		STRCAT(command, " ");
+		STRCAT(command, pat[i]);
+#endif
+	}
+	if (expand_interactively)
+		show_shell_mess = FALSE;
+	/*
+	 * If we use -f then shell variables set in .cshrc won't get expanded.
+	 * vi can do it, so we will too, but it is only necessary if there is a "$"
+	 * in one of the patterns, otherwise we can still use the fast option.
+	 */
+	if (use_glob && !have_dollars(num_pat, pat))	/* Use csh fast option */
+		extra_shell_arg = (char_u *)"-f";
+	i = call_shell(command, SHELL_EXPAND);		/* execute it */
+	extra_shell_arg = NULL;
+	show_shell_mess = TRUE;
+	vim_free(command);
+	if (i == FAIL)							/* call_shell failed */
+	{
+		vim_remove(tmpname);
+		/*
+		 * With interactive completion, the error message is not printed.
+		 * However with USE_SYSTEM, I don't know how to turn off error messages
+		 * from the shell, so screen may still get messed up -- webb.
+		 */
+#ifndef USE_SYSTEM
+		if (!expand_interactively)
+#endif
+		{
+			must_redraw = CLEAR;			/* probably messed up screen */
+			msg_outchar('\n');				/* clear bottom line quickly */
+			cmdline_row = Rows - 1;			/* continue on last line */
+		}
+		return FAIL;
+	}
+
+/*
+ * read the names from the file into memory
+ */
+ 	fd = fopen((char *)tmpname, "r");
+	if (fd == NULL)
+	{
+		emsg2(e_notopen, tmpname);
+		return FAIL;
+	}
+	fseek(fd, 0L, SEEK_END);
+	len = ftell(fd);				/* get size of temp file */
+	fseek(fd, 0L, SEEK_SET);
+	buffer = alloc(len + 1);
+	if (buffer == NULL)
+	{
+		vim_remove(tmpname);
+		fclose(fd);
+		return FAIL;
+	}
+	i = fread((char *)buffer, 1, len, fd);
+	fclose(fd);
+	vim_remove(tmpname);
+	if (i != len)
+	{
+		emsg2(e_notread, tmpname);
+		vim_free(buffer);
+		return FAIL;
+	}
+
+	if (use_glob)		/* file names are separated with NUL */
+	{
+		buffer[len] = NUL;				/* make sure the buffers ends in NUL */
+		i = 0;
+		for (p = buffer; p < buffer + len; ++p)
+			if (*p == NUL)				/* count entry */
+				++i;
+		if (len)
+			++i;						/* count last entry */
+	}
+	else				/* file names are separated with SPACE */
+	{
+		buffer[len] = '\n';				/* make sure the buffers ends in NL */
+		p = buffer;
+		for (i = 0; *p != '\n'; ++i)	/* count number of entries */
+		{
+			while (*p != ' ' && *p != '\n')	/* skip entry */
+				++p;
+			p = skipwhite(p);			/* skip to next entry */
+		}
+	}
+	if (i == 0)
+	{
+		/*
+		 * Can happen when using /bin/sh and typing ":e $NO_SUCH_VAR^I".
+		 * /bin/sh will happily expand it to nothing rather than returning an
+		 * error; and hey, it's good to check anyway -- webb.
+		 */
+		vim_free(buffer);
+		*file = (char_u **)"";
+		return FAIL;
+	}
+	*num_file = i;
+	*file = (char_u **)alloc(sizeof(char_u *) * i);
+	if (*file == NULL)
+	{
+		vim_free(buffer);
+		*file = (char_u **)"";
+		return FAIL;
+	}
+	
+	/*
+	 * Isolate the individual file names.
+	 */
+	p = buffer;
+	for (i = 0; i < *num_file; ++i)
+	{
+		(*file)[i] = p;
+		if (use_glob)
+		{
+			while (*p && p < buffer + len)		/* skip entry */
+				++p;
+			++p;								/* skip NUL */
+		}
+		else
+		{
+			while (*p != ' ' && *p != '\n')		/* skip entry */
+				++p;
+			if (*p == '\n')						/* last entry */
+				*p = NUL;
+			else
+			{
+				*p++ = NUL;
+				p = skipwhite(p);				/* skip to next entry */
+			}
+		}
+	}
+
+	/*
+	 * Move the file names to allocated memory.
+	 */
+	for (i = 0; i < *num_file; ++i)
+	{
+		/* Require the files to exist.  Helps when using /bin/sh */
+		if (expand_interactively)
+		{
+			struct stat		st;
+			int				j;
+
+			if (stat((char *)((*file)[i]), &st) < 0)
+			{
+				for (j = i; j + 1 < *num_file; ++j)
+					(*file)[j] = (*file)[j + 1];
+				--*num_file;
+				--i;
+				continue;
+			}
+		}
+
+		/* if file doesn't exist don't add '/' */
+		dir = (mch_isdir((*file)[i]));
+		p = alloc((unsigned)(STRLEN((*file)[i]) + 1 + dir));
+		if (p)
+		{
+			STRCPY(p, (*file)[i]);
+			if (dir)
+				STRCAT(p, "/");
+		}
+		(*file)[i] = p;
+	}
+	vim_free(buffer);
+
+	if (*num_file == 0)		/* rejected all entries */
+	{
+		vim_free(*file);
+		*file = (char_u **)"";
+		return FAIL;
+	}
+
+	return OK;
+
+#endif /* __EMX__ */
+}
+
+	int
+mch_has_wildcard(p)
+	char_u	*p;
+{
+	for ( ; *p; ++p)
+	{
+		if (*p == '\\' && p[1] != NUL)
+			++p;
+		else if (vim_strchr((char_u *)"*?[{`~$", *p) != NULL)
+			return TRUE;
+	}
+	return FALSE;
+}
+
+#ifndef __EMX__
+	static int
+have_wildcard(num, file)
+	int		num;
+	char_u	**file;
+{
+	register int i;
+
+	for (i = 0; i < num; i++)
+		if (mch_has_wildcard(file[i]))
+			return 1;
+	return 0;
+}
+
+	static int
+have_dollars(num, file)
+	int		num;
+	char_u	**file;
+{
+	register int i;
+
+	for (i = 0; i < num; i++)
+		if (vim_strchr(file[i], '$') != NULL)
+			return TRUE;
+	return FALSE;
+}
+#endif	/* ifndef __EMX__ */
+
+#ifndef HAVE_RENAME
+/*
+ * Scaled-down version of rename, which is missing in Xenix.
+ * This version can only move regular files and will fail if the
+ * destination exists.
+ */
+	int
+rename(src, dest)
+	const char *src, *dest;
+{
+	struct stat		st;
+
+	if (stat(dest, &st) >= 0)		/* fail if destination exists */
+		return -1;
+	if (link(src, dest) != 0)		/* link file to new name */
+		return -1;
+	if (vim_remove(src) == 0)		/* delete link to old name */
+		return 0;
+	return -1;
+}
+#endif /* !HAVE_RENAME */