updated for version 7.0001v7.0001

1 files changed, 3114 insertions, 0 deletions

diff --git a/src/os_msdos.c b/src/os_msdos.c
new file mode 100644
index 000000000..2d8b127e6
--- /dev/null
+++ b/src/os_msdos.c
@@ -0,0 +1,3114 @@
+/* vi:set ts=8 sts=4 sw=4:
+ *
+ * VIM - Vi IMproved	by Bram Moolenaar
+ *
+ * Do ":help uganda"  in Vim to read copying and usage conditions.
+ * Do ":help credits" in Vim to see a list of people who contributed.
+ * See README.txt for an overview of the Vim source code.
+ */
+
+/*
+ * os_msdos.c
+ *
+ * MSDOS system-dependent routines.
+ * A cheap plastic imitation of the amiga dependent code.
+ * A lot in this file was made by Juergen Weigert (jw).
+ *
+ * DJGPP changes by Gert van Antwerpen
+ * Faster text screens by John Lange (jlange@zilker.net)
+ * Windows clipboard functionality added by David Kotchan (dk)
+ *
+ * Some functions are also used for Win16 (MS-Windows 3.1).
+ */
+
+#include <io.h>
+#include "vim.h"
+
+#include <conio.h>
+#ifdef HAVE_FCNTL_H
+# include <fcntl.h>
+#endif
+
+/*
+ * MS-DOS only code, not used for Win16.
+ */
+#ifndef WIN16
+
+
+#include <bios.h>
+#ifdef DJGPP
+# include <dpmi.h>
+# include <signal.h>
+# include <sys/movedata.h>
+# include <crt0.h>
+# ifdef FEAT_CLIPBOARD
+#  include <sys/segments.h>
+# endif
+#else
+# include <alloc.h>
+#endif
+
+#if defined(DJGPP) || defined(PROTO)
+# define _cdecl	    /* DJGPP doesn't have this */
+#endif
+
+static int cbrk_pressed = FALSE;    /* set by ctrl-break interrupt */
+static int ctrlc_pressed = FALSE;   /* set when ctrl-C or ctrl-break detected */
+static int delayed_redraw = FALSE;  /* set when ctrl-C detected */
+
+static int bioskey_read = _NKEYBRD_READ;   /* bioskey() argument: read key */
+static int bioskey_ready = _NKEYBRD_READY; /* bioskey() argument: key ready? */
+
+#ifdef FEAT_MOUSE
+static int mouse_avail = FALSE;		/* mouse present */
+static int mouse_active;		/* mouse enabled */
+static int mouse_hidden;		/* mouse not shown */
+static int mouse_click = -1;		/* mouse status */
+static int mouse_last_click = -1;	/* previous status at click */
+static int mouse_x = -1;		/* mouse x coodinate */
+static int mouse_y = -1;		/* mouse y coodinate */
+static long mouse_click_time = 0;	/* biostime() of last click */
+static int mouse_click_count = 0;	/* count for multi-clicks */
+static int mouse_click_x = 0;		/* x of previous mouse click */
+static int mouse_click_y = 0;		/* y of previous mouse click */
+static linenr_T mouse_topline = 0;	/* w_topline at previous mouse click */
+#ifdef FEAT_DIFF
+static int mouse_topfill = 0;		/* w_topfill at previous mouse click */
+#endif
+static int mouse_x_div = 8;		/* column = x coord / mouse_x_div */
+static int mouse_y_div = 8;		/* line   = y coord / mouse_y_div */
+#endif
+
+#define BIOSTICK    55			/* biostime() increases one tick about
+					   every 55 msec */
+
+static int orig_attr = 0x0700;		/* video attributes when starting */
+
+static int S_iLeft = 0;			/* Scroll window; these are 1 offset */
+static int S_iTop = 0;
+static int S_iRight = 0;
+static int S_iBottom = 0;
+
+/*
+ * Need to remember the values, because we set horizontal and vertical
+ * edges separately.
+ */
+    static void
+mywindow(int iLeft, int iTop, int iRight, int iBottom)
+{
+    S_iLeft = iLeft;
+    S_iTop = iTop;
+    S_iRight = iRight;
+    S_iBottom = iBottom;
+    window(iLeft, iTop, iRight, iBottom);
+}
+
+#ifdef DJGPP
+/*
+ * For DJGPP, use our own functions for fast text screens.  JML 1/18/98
+ */
+
+unsigned long	S_ulScreenBase = 0xb8000;
+unsigned short	S_uiAttribute = 0;
+int		S_iCurrentRow = 0;	/* These are 0 offset */
+int		S_iCurrentColumn = 0;
+short		S_selVideo;	/* Selector for DJGPP direct video transfers */
+
+/*
+ * Use burst writes to improve mch_write speed - VJN 01/10/99
+ */
+unsigned short	S_linebuffer[8000]; /* <VN> enough for 160x50 */
+unsigned short	S_blankbuffer[256]; /* <VN> max length of console line */
+unsigned short	*S_linebufferpos = S_linebuffer;
+int		S_iBufferRow;
+int		S_iBufferColumn;
+
+    static void
+myflush(void)
+{
+    if (S_linebufferpos != S_linebuffer)
+    {
+	_dosmemputw(S_linebuffer, (S_linebufferpos - S_linebuffer),
+		S_ulScreenBase
+		      + S_iBufferRow * (Columns << 1) + (S_iBufferColumn << 1));
+	S_linebufferpos = S_linebuffer;
+    }
+}
+
+    static void
+mygotoxy(int x, int y)
+{
+    S_iCurrentRow = y - 1;
+    S_iCurrentColumn = x - 1;
+}
+
+/*
+ * Set the system cursor to our cursor position.
+ */
+    static void
+set_sys_cursor(void)
+{
+    if (term_console && full_screen)
+    {
+	myflush();
+	gotoxy(S_iCurrentColumn + 1, S_iCurrentRow + 1);
+    }
+}
+
+    static void
+setblankbuffer(unsigned short uiValue)
+{
+    int				i;
+    static unsigned short	olduiValue = 0;
+
+    if (olduiValue != uiValue)
+    {
+	/* Load blank line buffer with spaces */
+	for (i = 0; i < Columns; ++i)
+	    S_blankbuffer[i] = uiValue;
+	olduiValue = uiValue;
+    }
+}
+
+    static void
+myclreol(void)
+{
+    /* Clear to end of line */
+    setblankbuffer(S_uiAttribute | ' ');
+    _dosmemputw(S_blankbuffer, S_iRight - S_iCurrentColumn, S_ulScreenBase
+			 + (S_iCurrentRow) * (Columns << 1)
+			 + (S_iCurrentColumn << 1));
+}
+
+    static void
+myclrscr(void)
+{
+    /* Clear whole screen */
+    short	iColumn;
+    int		endpoint = (Rows * Columns) << 1;
+
+    setblankbuffer(S_uiAttribute | ' ');
+
+    for (iColumn = 0; iColumn < endpoint; iColumn += (Columns << 1))
+	_dosmemputw(S_blankbuffer, Columns, S_ulScreenBase + iColumn);
+}
+
+    static void
+mydelline(void)
+{
+    short iRow, iColumn;
+
+    iColumn = (S_iLeft - 1) << 1;
+
+    /* Copy the lines underneath */
+    for (iRow = S_iCurrentRow; iRow < S_iBottom - 1; iRow++)
+	movedata(S_selVideo, (((iRow + 1) * Columns) << 1) + iColumn,
+		S_selVideo, ((iRow * Columns) << 1) + iColumn,
+		(S_iRight - S_iLeft + 1) << 1);
+
+    /* Clear the new row */
+    setblankbuffer(S_uiAttribute | ' ');
+
+    _dosmemputw(S_blankbuffer, (S_iRight - S_iLeft) + 1, S_ulScreenBase
+			 + (S_iBottom - 1) * (Columns << 1) + iColumn);
+}
+
+    static void
+myinsline(void)
+{
+    short iRow, iColumn;
+
+    iColumn = (S_iLeft - 1) << 1;
+
+    /* Copy the lines underneath */
+    for (iRow = S_iBottom - 1; iRow >= S_iTop; iRow--)
+	movedata(S_selVideo, (((iRow - 1) * Columns) << 1) + iColumn,
+		S_selVideo, ((iRow * Columns) << 1) + iColumn,
+		(S_iRight - S_iLeft + 1) << 1);
+
+    /* Clear the new row */
+    setblankbuffer(S_uiAttribute | ' ');
+
+    _dosmemputw(S_blankbuffer, (S_iRight - S_iLeft) + 1, S_ulScreenBase
+			 + (S_iTop - 1) * (Columns << 1) + iColumn);
+}
+
+/*
+ * Scroll the screen one line up, clear the last line.
+ */
+    static void
+myscroll(void)
+{
+    short		iRow, iColumn;
+
+    iColumn = (S_iLeft - 1) << 1;
+
+    /* Copy the screen */
+    for (iRow = S_iTop; iRow < S_iBottom; iRow++)
+	movedata(S_selVideo, ((iRow * Columns) << 1) + iColumn,
+		S_selVideo, (((iRow - 1) * Columns) << 1) + iColumn,
+		(S_iRight - S_iLeft + 1) << 1);
+
+    /* Clear the bottom row */
+    setblankbuffer(S_uiAttribute | ' ');
+
+    _dosmemputw(S_blankbuffer, (S_iRight - S_iLeft) + 1, S_ulScreenBase
+			 + (S_iBottom - 1) * (Columns << 1) + iColumn);
+}
+
+    static int
+myputch(int iChar)
+{
+    unsigned short uiValue;
+
+    if (iChar == '\n')
+    {
+	myflush();
+	if (S_iCurrentRow >= S_iBottom - S_iTop)
+	    myscroll();
+	else
+	{
+	    S_iCurrentColumn = S_iLeft - 1;
+	    S_iCurrentRow++;
+	}
+    }
+    else if (iChar == '\r')
+    {
+	myflush();
+	S_iCurrentColumn = S_iLeft - 1;
+    }
+    else if (iChar == '\b')
+    {
+	myflush();
+	if (S_iCurrentColumn >= S_iLeft)
+	    S_iCurrentColumn--;
+    }
+    else if (iChar == 7)
+    {
+	sound(440);	/* short beep */
+	delay(200);
+	nosound();
+    }
+    else
+    {
+	uiValue = S_uiAttribute | (unsigned char)iChar;
+
+	/*
+	 * Normal char - are we starting to buffer?
+	 */
+	if (S_linebufferpos == S_linebuffer)
+	{
+	    S_iBufferColumn = S_iCurrentColumn;
+	    S_iBufferRow = S_iCurrentRow;
+	}
+
+	*S_linebufferpos++ = uiValue;
+
+	S_iCurrentColumn++;
+	if (S_iCurrentColumn >= S_iRight && S_iCurrentRow >= S_iBottom - S_iTop)
+	{
+	    myflush();
+	    myscroll();
+	    S_iCurrentColumn = S_iLeft - 1;
+	    S_iCurrentRow++;
+	}
+    }
+
+    return 0;
+}
+
+    static void
+mytextinit(struct text_info *pTextinfo)
+{
+    S_selVideo = __dpmi_segment_to_descriptor(S_ulScreenBase >> 4);
+    S_uiAttribute = pTextinfo->normattr << 8;
+}
+
+    static void
+get_screenbase(void)
+{
+    static union REGS	    regs;
+
+    /* old Hercules grafic card has different base address (Macewicz) */
+    regs.h.ah = 0x0f;
+    (void)int86(0x10, &regs, &regs);	/* int 10 0f */
+    if (regs.h.al == 0x07)		/* video mode 7 -- hercules mono */
+	S_ulScreenBase = 0xb0000;
+    else
+	S_ulScreenBase = 0xb8000;
+}
+
+    static void
+mytextattr(int iAttribute)
+{
+    S_uiAttribute = (unsigned short)iAttribute << 8;
+}
+
+    static void
+mynormvideo(void)
+{
+    mytextattr(orig_attr);
+}
+
+    static void
+mytextcolor(int iTextColor)
+{
+    S_uiAttribute = (unsigned short)((S_uiAttribute & 0xf000)
+					   | (unsigned short)iTextColor << 8);
+}
+
+    static void
+mytextbackground(int iBkgColor)
+{
+    S_uiAttribute = (unsigned short)((S_uiAttribute & 0x0f00)
+					 | (unsigned short)(iBkgColor << 12));
+}
+/*
+ * Getdigits: Get a number from a string and skip over it.
+ * Note: the argument is a pointer to a char_u pointer!
+ */
+
+    static long
+mygetdigits(pp)
+    char_u **pp;
+{
+    char_u	*p;
+    long	retval = 0;
+
+    p = *pp;
+    if (*p == '-')		/* skip negative sign */
+	++p;
+    while (VIM_ISDIGIT(*p))
+    {
+	retval = (retval * 10) + (*p - '0');
+	++p;
+    }
+    if (**pp == '-')		/* process negative sign */
+	retval = -retval;
+
+    *pp = p;
+    return retval;
+}
+#else
+# define mygotoxy gotoxy
+# define myputch putch
+# define myscroll scroll
+# define mynormvideo normvideo
+# define mytextattr textattr
+# define mytextcolor textcolor
+# define mytextbackground textbackground
+# define mygetdigits getdigits
+# define myclreol clreol
+# define myclrscr clrscr
+# define myinsline insline
+# define mydelline delline
+#endif
+
+static const struct
+{
+    char_u	scancode;
+    char_u	metakey;
+} altkey_table[] =
+{
+    {0x1e, 0xe1}, /* a */
+    {0x30, 0xe2}, /* b */
+    {0x2e, 0xe3}, /* c */
+    {0x20, 0xe4}, /* d */
+    {0x12, 0xe5}, /* e */
+    {0x21, 0xe6}, /* f */
+    {0x22, 0xe7}, /* g */
+    {0x23, 0xe8}, /* h */
+    {0x17, 0xe9}, /* i */
+    {0x24, 0xea}, /* j */
+    {0x25, 0xeb}, /* k */
+    {0x26, 0xec}, /* l */
+    {0x32, 0xed}, /* m */
+    {0x31, 0xee}, /* n */
+    {0x18, 0xef}, /* o */
+    {0x19, 0xf0}, /* p */
+    {0x10, 0xf1}, /* q */
+    {0x13, 0xf2}, /* r */
+    {0x1f, 0xf3}, /* s */
+    {0x14, 0xf4}, /* t */
+    {0x16, 0xf5}, /* u */
+    {0x2f, 0xf6}, /* v */
+    {0x11, 0xf7}, /* w */
+    {0x2d, 0xf8}, /* x */
+    {0x15, 0xf9}, /* y */
+    {0x2c, 0xfa}, /* z */
+    {0x78, 0xb1}, /* 1 */
+    {0x79, 0xb2}, /* 2 */
+    {0x7a, 0xb3}, /* 3 */
+    {0x7b, 0xb4}, /* 4 */
+    {0x7c, 0xb5}, /* 5 */
+    {0x7d, 0xb6}, /* 6 */
+    {0x7e, 0xb7}, /* 7 */
+    {0x7f, 0xb8}, /* 8 */
+    {0x80, 0xb9}, /* 9 */
+    {0x81, 0xb0}, /* 0 */
+};
+
+/*
+ * Translate extended keycodes into meta-chars where applicable
+ */
+    static int
+translate_altkeys(int rawkey)
+{
+    int i, c;
+
+    if ((rawkey & 0xff) == 0)
+    {
+	c = (rawkey >> 8);
+	for (i = sizeof(altkey_table) / sizeof(altkey_table[0]); --i >= 0; )
+	{
+	    if (c == altkey_table[i].scancode)
+		return (int)altkey_table[i].metakey;
+	}
+    }
+    return rawkey;
+}
+
+/*
+ * Set normal fg/bg color, based on T_ME.  Called whem t_me has been set.
+ */
+    void
+mch_set_normal_colors()
+{
+    char_u	*p;
+    int		n;
+
+    cterm_normal_fg_color = (orig_attr & 0xf) + 1;
+    cterm_normal_bg_color = ((orig_attr >> 4) & 0xf) + 1;
+    if (T_ME[0] == ESC && T_ME[1] == '|')
+    {
+	p = T_ME + 2;
+	n = getdigits(&p);
+	if (*p == 'm' && n > 0)
+	{
+	    cterm_normal_fg_color = (n & 0xf) + 1;
+	    cterm_normal_bg_color = ((n >> 4) & 0xf) + 1;
+	}
+    }
+}
+
+#if defined(MCH_CURSOR_SHAPE) || defined(PROTO)
+/*
+ * Save/restore the shape of the cursor.
+ * call with FALSE to save, TRUE to restore
+ */
+    static void
+mch_restore_cursor_shape(int restore)
+{
+    static union REGS	    regs;
+    static int		    saved = FALSE;
+
+    if (restore)
+    {
+	if (saved)
+	    regs.h.ah = 0x01;	    /*Set Cursor*/
+	else
+	    return;
+    }
+    else
+    {
+	regs.h.ah = 0x03;	    /*Get Cursor*/
+	regs.h.bh = 0x00;	    /*Page */
+	saved = TRUE;
+    }
+
+    (void)int86(0x10, &regs, &regs);
+}
+
+/*
+ * Set the shape of the cursor.
+ * 'thickness' can be from 0 (thin) to 7 (block)
+ */
+    static void
+mch_set_cursor_shape(int thickness)
+{
+    union REGS	    regs;
+
+    regs.h.ch = 7 - thickness;	    /*Starting Line*/
+    regs.h.cl = 7;		    /*Ending Line*/
+    regs.h.ah = 0x01;		    /*Set Cursor*/
+    (void)int86(0x10, &regs, &regs);
+}
+
+    void
+mch_update_cursor(void)
+{
+    int		idx;
+    int		thickness;
+
+    /*
+     * How the cursor is drawn depends on the current mode.
+     */
+    idx = get_shape_idx(FALSE);
+
+    if (shape_table[idx].shape == SHAPE_BLOCK)
+	thickness = 7;
+    else
+	thickness = (7 * shape_table[idx].percentage + 90) / 100;
+    mch_set_cursor_shape(thickness);
+}
+#endif
+
+/*
+ * Return amount of memory currently available.
+ */
+    long_u
+mch_avail_mem(int special)
+{
+#ifdef DJGPP
+    return _go32_dpmi_remaining_virtual_memory();
+#else
+    return coreleft();
+#endif
+}
+
+#ifdef FEAT_MOUSE
+
+/*
+ * Set area where mouse can be moved to: The whole screen.
+ * Rows and Columns must be valid when calling!
+ */
+    static void
+mouse_area(void)
+{
+    union REGS	    regs;
+
+    if (mouse_avail)
+    {
+	regs.x.cx = 0;	/* mouse visible between cx and dx */
+	regs.x.dx = Columns * mouse_x_div - 1;
+	regs.x.ax = 7;
+	(void)int86(0x33, &regs, &regs);
+
+	regs.x.cx = 0;	/* mouse visible between cx and dx */
+	regs.x.dx = Rows * mouse_y_div - 1;
+	regs.x.ax = 8;
+	(void)int86(0x33, &regs, &regs);
+    }
+}
+
+    static void
+show_mouse(int on)
+{
+    static int	    was_on = FALSE;
+    union REGS	    regs;
+
+    if (mouse_avail)
+    {
+	if (!mouse_active || mouse_hidden)
+	    on = FALSE;
+	/*
+	 * Careful: Each switch on must be compensated by exactly one switch
+	 * off
+	 */
+	if ((on && !was_on) || (!on && was_on))
+	{
+	    was_on = on;
+	    regs.x.ax = on ? 1 : 2;
+	    int86(0x33, &regs, &regs);	/* show mouse */
+	    if (on)
+		mouse_area();
+	}
+    }
+}
+
+#endif
+
+/*
+ * Version of kbhit() and getch() that use direct console I/O.
+ * This avoids trouble with CTRL-P and the like, and should work over a telnet
+ * connection (it works for Xvi).
+ */
+
+static int cons_key = -1;
+
+/*
+ * Try to get one character directly from the console.
+ * If there is a key, it is stored in cons_key.
+ * Only call when cons_key is -1!
+ */
+    static void
+cons_getkey(void)
+{
+    union REGS regs;
+
+    /* call DOS function 6: Direct console I/O */
+    regs.h.ah = 0x06;
+    regs.h.dl = 0xff;
+    (void)intdos(&regs, &regs);
+    if ((regs.x.flags & 0x40) == 0)	/* zero flag not set? */
+	cons_key = (regs.h.al & 0xff);
+}
+
+/*
+ * Return TRUE if a character is available.
+ */
+    static int
+cons_kbhit(void)
+{
+    if (cons_key < 0)
+	cons_getkey();
+    return (cons_key >= 0);
+}
+
+/*
+ * Return a character from the console.
+ * Should only be called when vim_kbhit() returns TRUE.
+ */
+    static int
+cons_getch(void)
+{
+    int	    c = -1;
+
+    if (cons_key < 0)
+	cons_getkey();
+    c = cons_key;
+    cons_key = -1;
+    return c;
+}
+
+
+#ifdef DJGPP
+/*
+ * DJGPP provides a kbhit() function that goes to the BIOS instead of DOS.
+ * This doesn't work for terminals connected to a serial port.
+ * Redefine kbhit() here to make it work.
+ */
+    static int
+vim_kbhit(void)
+{
+    union REGS regs;
+
+    regs.h.ah = 0x0b;
+    (void)intdos(&regs, &regs);
+    return regs.h.al;
+}
+
+#ifdef kbhit
+# undef kbhit	    /* might have been defined in conio.h */
+#endif
+#define kbhit()	vim_kbhit()
+
+#endif
+
+/*
+ * Simulate WaitForChar() by slowly polling with bioskey(1) or kbhit().
+ *
+ * If Vim should work over the serial line after a 'ctty com1' we must use
+ * kbhit() and getch(). (jw)
+ * Usually kbhit() is not used, because then CTRL-C and CTRL-P
+ * will be catched by DOS (mool).
+ *
+ * return TRUE if a character is available, FALSE otherwise
+ */
+
+#define FOREVER 1999999999L
+
+    static  int
+WaitForChar(long msec)
+{
+    union REGS	regs;
+    long	starttime = 0;
+    int		x, y;
+
+    if (msec != 0)
+	starttime = biostime(0, 0L);
+
+    for (;;)
+    {
+#ifdef FEAT_MOUSE
+	long		clicktime;
+	static int	old_status = 0;
+
+	if (mouse_avail && mouse_active && mouse_click < 0)
+	{
+	    regs.x.ax = 3;
+	    int86(0x33, &regs, &regs);	    /* check mouse status */
+		/* only recognize button-down and button-up event */
+	    x = regs.x.cx / mouse_x_div;
+	    y = regs.x.dx / mouse_y_div;
+	    if ((old_status == 0) != (regs.x.bx == 0))
+	    {
+		if (old_status)	/* button up */
+		    mouse_click = MOUSE_RELEASE;
+		else			/* button down */
+		{
+		    /*
+		     * Translate MSDOS mouse events to Vim mouse events.
+		     * TODO: should handle middle mouse button, by pressing
+		     * left and right at the same time.
+		     */
+		    if (regs.x.bx & MSDOS_MOUSE_LEFT)
+			mouse_click = MOUSE_LEFT;
+		    else if (regs.x.bx & MSDOS_MOUSE_RIGHT)
+			mouse_click = MOUSE_RIGHT;
+		    else if (regs.x.bx & MSDOS_MOUSE_MIDDLE)
+			mouse_click = MOUSE_MIDDLE;
+
+		    /*
+		     * Find out if this is a multi-click
+		     */
+		    clicktime = biostime(0, 0L);
+		    if (mouse_click_x == x && mouse_click_y == y
+			    && mouse_topline == curwin->w_topline
+#ifdef FEAT_DIFF
+			    && mouse_topfill == curwin->w_topfill
+#endif
+			    && mouse_click_count != 4
+			    && mouse_click == mouse_last_click
+			    && clicktime < mouse_click_time
+							+ p_mouset / BIOSTICK)
+			++mouse_click_count;
+		    else
+			mouse_click_count = 1;
+		    mouse_click_time = clicktime;
+		    mouse_last_click = mouse_click;
+		    mouse_click_x = x;
+		    mouse_click_y = y;
+		    mouse_topline = curwin->w_topline;
+#ifdef FEAT_DIFF
+		    mouse_topfill = curwin->w_topfill;
+#endif
+		    SET_NUM_MOUSE_CLICKS(mouse_click, mouse_click_count);
+		}
+	    }
+	    else if (old_status && (x != mouse_x || y != mouse_y))
+		mouse_click = MOUSE_DRAG;
+	    old_status = regs.x.bx;
+	    if (mouse_hidden && mouse_x >= 0 && (mouse_x != x || mouse_y != y))
+	    {
+		mouse_hidden = FALSE;
+		show_mouse(TRUE);
+	    }
+	    mouse_x = x;
+	    mouse_y = y;
+	}
+#endif
+
+	if ((p_consk ? cons_kbhit()
+				 : p_biosk ? bioskey(bioskey_ready) : kbhit())
+		|| cbrk_pressed
+#ifdef FEAT_MOUSE
+						    || mouse_click >= 0
+#endif
+		)
+	    return TRUE;
+	/*
+	 * Use biostime() to wait until our time is done.
+	 * We busy-wait here.  Unfortunately, delay() and usleep() have been
+	 * reported to give problems with the original Windows 95.  This is
+	 * fixed in service pack 1, but not everybody installed that.
+	 * The DJGPP implementation of usleep() uses a busy-wait loop too.
+	 */
+	if (msec == 0 || (msec != FOREVER
+			    && biostime(0, 0L) > starttime + msec / BIOSTICK))
+	    break;
+
+#ifdef DJGPP
+	/* Yield the CPU to the next process. */
+	__dpmi_yield();
+#endif
+    }
+    return FALSE;
+}
+
+/*
+ * don't do anything for about "msec" msec
+ */
+    void
+mch_delay(
+    long	msec,
+    int		ignoreinput)
+{
+    long	starttime;
+
+    if (ignoreinput)
+    {
+	/*
+	 * We busy-wait here.  Unfortunately, delay() and usleep() have been
+	 * reported to give problems with the original Windows 95.  This is
+	 * fixed in service pack 1, but not everybody installed that.
+	 */
+	starttime = biostime(0, 0L);
+	while (biostime(0, 0L) < starttime + msec / BIOSTICK)
+	    ;
+    }
+    else
+	WaitForChar(msec);
+}
+
+/*
+ * mch_write(): write the output buffer to the screen
+ */
+    void
+mch_write(
+    char_u	*s,
+    int		len)
+{
+    char_u	*p;
+    int		row, col;
+
+    if (term_console && full_screen)
+	while (len--)
+	{
+	    /* translate ESC | sequences into bios calls */
+	    if (p_wd)	    /* testing: wait a bit for each char */
+		WaitForChar(p_wd);
+
+	    if (s[0] == '\n')
+#ifdef DJGPP
+	    {
+		myflush();
+		S_iCurrentColumn = S_iLeft - 1;
+	    }
+#else
+		myputch('\r');
+#endif
+	    else if (s[0] == ESC && len > 1 && s[1] == '|')
+	    {
+		switch (s[2])
+		{
+#ifdef DJGPP
+		case 'B':   ScreenVisualBell();
+			    goto got3;
+#endif
+		case 'J':
+#ifdef DJGPP
+			    myflush();
+#endif
+			    myclrscr();
+			    goto got3;
+
+		case 'K':
+#ifdef DJGPP
+			    myflush();
+#endif
+			    myclreol();
+			    goto got3;
+
+		case 'L':
+#ifdef DJGPP
+			    myflush();
+#endif
+			    myinsline();
+			    goto got3;
+
+		case 'M':
+#ifdef DJGPP
+			    myflush();
+#endif
+			    mydelline();
+got3:			    s += 3;
+			    len -= 2;
+			    continue;
+
+		case '0':
+		case '1':
+		case '2':
+		case '3':
+		case '4':
+		case '5':
+		case '6':
+		case '7':
+		case '8':
+		case '9':   p = s + 2;
+			    row = mygetdigits(&p);    /* no check for length! */
+			    if (p > s + len)
+				break;
+			    if (*p == ';')
+			    {
+				++p;
+				col = mygetdigits(&p); /* no check for length! */
+				if (p > s + len)
+				    break;
+				if (*p == 'H' || *p == 'r' || *p == 'V')
+				{
+#ifdef DJGPP
+				    myflush();
+#endif
+				    if (*p == 'H')  /* set cursor position */
+					mygotoxy(col, row);
+				    else if (*p == 'V')
+					mywindow(row, S_iTop, col, S_iBottom);
+				    else	    /* set scroll region  */
+					mywindow(S_iLeft, row, S_iRight, col);
+				    len -= p - s;
+				    s = p + 1;
+				    continue;
+				}
+			    }
+			    else if (*p == 'm' || *p == 'f' || *p == 'b')
+			    {
+				if (*p == 'm')	    /* set color */
+				{
+				    if (row == 0)
+					mynormvideo();/* reset color */
+				    else
+					mytextattr(row);
+				}
+				else if (*p == 'f') /* set foreground color */
+				    mytextcolor(row);
+				else		    /* set background color */
+				    mytextbackground(row);
+
+				len -= p - s;
+				s = p + 1;
+				continue;
+			    }
+		}
+	    }
+	    myputch(*s++);
+	}
+    else
+    {
+	write(1, s, (unsigned)len);
+    }
+}
+
+/*
+ * mch_inchar(): low level input funcion.
+ * Get a characters from the keyboard.
+ * If time == 0 do not wait for characters.
+ * If time == n wait a short time for characters.
+ * If time == -1 wait forever for characters.
+ *
+ * return the number of characters obtained
+ */
+    int
+mch_inchar(
+    char_u	*buf,
+    int		maxlen,
+    long	time,
+    int		tb_change_cnt)
+{
+    int		len = 0;
+    int		c;
+    int		tmp_c;
+    static int	nextchar = 0;	    /* may keep character when maxlen == 1 */
+#ifdef FEAT_AUTOCMD
+    static int	once_already = 0;
+#endif
+
+    /*
+     * if we got a ctrl-C when we were busy, there will be a "^C" somewhere
+     * on the sceen, so we need to redisplay it.
+     */
+    if (delayed_redraw)
+    {
+	delayed_redraw = FALSE;
+	update_screen(CLEAR);
+	setcursor();
+	out_flush();
+    }
+
+    /* return remaining character from last call */
+    if (nextchar)
+    {
+	*buf = nextchar;
+	nextchar = 0;
+	return 1;
+    }
+
+#ifdef FEAT_MOUSE
+    if (time != 0)
+	show_mouse(TRUE);
+#endif
+#ifdef DJGPP
+    set_sys_cursor();
+#endif
+    if (time >= 0)
+    {
+	if (WaitForChar(time) == 0)	/* no character available */
+	{
+#ifdef FEAT_MOUSE
+	    show_mouse(FALSE);
+#endif
+#ifdef FEAT_AUTOCMD
+	    once_already = 0;
+#endif
+	    return 0;
+	}
+    }
+    else    /* time == -1 */
+    {
+#ifdef FEAT_AUTOCMD
+	if (once_already == 2)
+	    updatescript(0);
+	else if (once_already == 1)
+	{
+	    setcursor();
+	    once_already = 2;
+	    return 0;
+	}
+	else
+#endif
+	/*
+	 * If there is no character available within 2 seconds (default)
+	 * write the autoscript file to disk
+	 */
+	    if (WaitForChar(p_ut) == 0)
+	{
+#ifdef FEAT_AUTOCMD
+	    if (has_cursorhold() && get_real_state() == NORMAL_BUSY)
+	    {
+		apply_autocmds(EVENT_CURSORHOLD, NULL, NULL, FALSE, curbuf);
+		update_screen(VALID);
+		once_already = 1;
+		return 0;
+	    }
+	    else
+#endif
+		updatescript(0);
+	}
+    }
+    WaitForChar(FOREVER);	/* wait for key or mouse click */
+
+/*
+ * Try to read as many characters as there are, until the buffer is full.
+ */
+    /*
+     * we will get at least one key. Get more if they are available
+     * After a ctrl-break we have to read a 0 (!) from the buffer.
+     * bioskey(1) will return 0 if no key is available and when a
+     * ctrl-break was typed. When ctrl-break is hit, this does not always
+     * implies a key hit.
+     */
+    cbrk_pressed = FALSE;
+#ifdef FEAT_MOUSE
+    if (mouse_click >= 0 && maxlen >= 5)
+    {
+	len = 5;
+	*buf++ = ESC + 128;
+	*buf++ = 'M';
+	*buf++ = mouse_click;
+	*buf++ = mouse_x + '!';
+	*buf++ = mouse_y + '!';
+	mouse_click = -1;
+    }
+    else
+#endif
+    {
+#ifdef FEAT_MOUSE
+	mouse_hidden = TRUE;
+#endif
+	if (p_biosk && !p_consk)
+	{
+	    while ((len == 0 || bioskey(bioskey_ready)) && len < maxlen)
+	    {
+		c = translate_altkeys(bioskey(bioskey_read)); /* get the key */
+		/*
+		 * translate a few things for inchar():
+		 * 0x0000 == CTRL-break		-> 3	(CTRL-C)
+		 * 0x0300 == CTRL-@		-> NUL
+		 * 0xnn00 == extended key code	-> K_NUL, nn
+		 * 0xnne0 == enhanced keyboard	-> K_NUL, nn
+		 * K_NUL			-> K_NUL, 3
+		 */
+		if (c == 0)
+		    c = 3;
+		else if (c == 0x0300)
+		    c = NUL;
+		else if ((c & 0xff) == 0
+			|| c == K_NUL
+			|| c == 0x4e2b
+			|| c == 0x4a2d
+			|| c == 0x372a
+			|| ((c & 0xff) == 0xe0 && c != 0xe0))
+		{
+		    if (c == K_NUL)
+			c = 3;
+		    else
+			c >>= 8;
+		    *buf++ = K_NUL;
+		    ++len;
+		}
+
+		if (len < maxlen)
+		{
+		    *buf++ = c;
+		    len++;
+#ifdef FEAT_MBYTE
+		    /* Convert from 'termencoding' to 'encoding'. Only
+		     * translate normal characters, not key codes. */
+		    if (input_conv.vc_type != CONV_NONE
+					    && (len == 1 || buf[-2] != K_NUL))
+			len += convert_input(buf - 1, 1, maxlen - len + 1) - 1;
+#endif
+		}
+		else
+		    nextchar = c;
+	    }
+	}
+	else
+	{
+	    while ((len == 0 || (p_consk ? cons_kbhit() : kbhit()))
+		    && len < maxlen)
+	    {
+		switch (c = (p_consk ? cons_getch() : getch()))
+		{
+		    case 0:
+			/* NUL means that there is another character.
+			 * Get it immediately, because kbhit() doesn't always
+			 * return TRUE for the second character.
+			 */
+			if (p_consk)
+			    c = cons_getch();
+			else
+			    c = getch();
+			tmp_c = translate_altkeys(c << 8);
+			if (tmp_c == (c << 8))
+			{
+			    *buf++ = K_NUL;
+			    ++len;
+			}
+			else
+			    c = tmp_c;
+			break;
+		    case K_NUL:
+			*buf++ = K_NUL;
+			++len;
+			c = 3;
+			break;
+		    case 3:
+			cbrk_pressed = TRUE;
+			/*FALLTHROUGH*/
+		    default:
+			break;
+		}
+		if (len < maxlen)
+		{
+		    *buf++ = c;
+		    ++len;
+		}
+		else
+		    nextchar = c;
+	    }
+	}
+    }
+#ifdef FEAT_MOUSE
+    show_mouse(FALSE);
+#endif
+
+    beep_count = 0;	    /* may beep again now that we got some chars */
+#ifdef FEAT_AUTOCMD
+    once_already = 0;
+#endif
+    return len;
+}
+
+/*
+ * return non-zero if a character is available
+ */
+    int
+mch_char_avail(void)
+{
+    return WaitForChar(0L);
+}
+
+#ifdef DJGPP
+# define INT_ARG    int
+#else
+# define INT_ARG
+#endif
+
+/*
+ * function for ctrl-break interrupt
+ */
+    static void interrupt
+#ifdef DJGPP
+catch_cbrk(int a)
+#else
+catch_cbrk(void)
+#endif
+{
+    cbrk_pressed = TRUE;
+    ctrlc_pressed = TRUE;
+}
+
+#ifndef DJGPP
+/*
+ * ctrl-break handler for DOS. Never called when a ctrl-break is typed, because
+ * we catch interrupt 1b. If you type ctrl-C while Vim is waiting for a
+ * character this function is not called. When a ctrl-C is typed while Vim is
+ * busy this function may be called. By that time a ^C has been displayed on
+ * the screen, so we have to redisplay the screen. We can't do that here,
+ * because we may be called by DOS. The redraw is in mch_inchar().
+ */
+    static int _cdecl
+cbrk_handler(void)
+{
+    delayed_redraw = TRUE;
+    return 1;		    /* resume operation after ctrl-break */
+}
+
+/*
+ * function for critical error interrupt
+ * For DOS 1 and 2 return 0 (Ignore).
+ * For DOS 3 and later return 3 (Fail)
+ */
+    static void interrupt
+catch_cint(bp, di, si, ds, es, dx, cx, bx, ax)
+    unsigned bp, di, si, ds, es, dx, cx, bx, ax;
+{
+    ax = (ax & 0xff00);	    /* set AL to 0 */
+    if (_osmajor >= 3)
+	ax |= 3;	    /* set AL to 3 */
+}
+#endif
+
+/*
+ * Set the interrupt vectors for use with Vim on or off.
+ * on == TRUE means as used within Vim
+ */
+    static void
+set_interrupts(int on)
+{
+    static int saved_cbrk;
+#ifndef DJGPP
+    static void interrupt (*old_cint)();
+#endif
+    static void interrupt (*old_cbrk)(INT_ARG);
+
+    if (on)
+    {
+	saved_cbrk = getcbrk();		/* save old ctrl-break setting */
+	setcbrk(0);			/* do not check for ctrl-break */
+#ifdef DJGPP
+	old_cbrk = signal(SIGINT, catch_cbrk);	/* critical error interrupt */
+#else
+	old_cint = getvect(0x24);	/* save old critical error interrupt */
+	setvect(0x24, catch_cint);	/* install our critical error interrupt */
+	old_cbrk = getvect(0x1B);	/* save old ctrl-break interrupt */
+	setvect(0x1B, catch_cbrk);	/* install our ctrl-break interrupt */
+	ctrlbrk(cbrk_handler);		/* vim's ctrl-break handler */
+#endif
+	if (term_console)
+	    out_str(T_ME);		/* set colors */
+    }
+    else
+    {
+	setcbrk(saved_cbrk);		/* restore ctrl-break setting */
+#ifdef DJGPP
+	signal(SIGINT,old_cbrk);	/* critical error interrupt */
+#else
+	setvect(0x24, old_cint);	/* restore critical error interrupt */
+	setvect(0x1B, old_cbrk);	/* restore ctrl-break interrupt */
+#endif
+	/* restore ctrl-break handler, how ??? */
+	if (term_console)
+	    mynormvideo();		/* restore screen colors */
+    }
+}
+
+/*
+ * We have no job control, fake it by starting a new shell.
+ */
+    void
+mch_suspend(void)
+{
+    suspend_shell();
+}
+
+extern int _fmode;
+
+/*
+ * Prepare window for use by Vim.
+ */
+    void
+mch_init(void)
+{
+    union REGS regs;
+
+#if defined(DJGPP) && defined(FEAT_CLIPBOARD)
+    __dpmi_regs  dpmi_regs;
+#endif
+
+    /*
+     * Get the video attributes at the cursor.  These will be used as the
+     * default attributes.
+     */
+    regs.h.ah = 0x08;
+    regs.h.bh = 0x00;		/* video page 0 */
+    int86(0x10, &regs, &regs);
+    orig_attr = regs.h.ah;
+    mynormvideo();
+    if (cterm_normal_fg_color == 0)
+	cterm_normal_fg_color = (orig_attr & 0xf) + 1;
+    if (cterm_normal_bg_color == 0)
+	cterm_normal_bg_color = ((orig_attr >> 4) & 0xf) + 1;
+
+    term_console = TRUE;    /* assume using the console for the things here */
+    _fmode = O_BINARY;	    /* we do our own CR-LF translation */
+    out_flush();
+    set_interrupts(TRUE);   /* catch interrupts */
+
+#ifdef DJGPP
+    /*
+     * Use Long File Names by default, if $LFN not set.
+     */
+    if (getenv("LFN") == NULL)
+	putenv("LFN=y");
+
+    get_screenbase();
+#endif
+
+#ifdef FEAT_MOUSE
+/* find out if a MS compatible mouse is available */
+    regs.x.ax = 0;
+    (void)int86(0x33, &regs, &regs);
+    mouse_avail = regs.x.ax;
+    /* best guess for mouse coordinate computations */
+    mch_get_shellsize();
+    if (Columns <= 40)
+	mouse_x_div = 16;
+    if (Rows == 30)
+	mouse_y_div = 16;
+#endif
+
+    /*
+     * Try switching to 16 colors for background, instead of 8 colors and
+     * blinking.  Does this always work?  Can the old value be restored?
+     */
+    regs.x.ax = 0x1003;
+    regs.h.bl = 0x00;
+    regs.h.bh = 0x00;
+    int86(0x10, &regs, &regs);
+
+    /*
+     * Test if we have an enhanced AT keyboard.  Write 0xFFFF to the keyboard
+     * buffer and try to read it back.  If we can't in 16 tries, it's an old
+     * type XT keyboard.
+     */
+    regs.h.ah = 0x05;
+    regs.x.cx = 0xffff;
+    int86(0x16, &regs, &regs);
+    if (regs.h.al != 1)	/* skip this when keyboard buffer is full */
+    {
+	int i;
+
+	for (i = 0; i < 16; ++i)
+	{
+	    regs.h.ah = 0x10;
+	    int86(0x16, &regs, &regs);
+	    if (regs.x.ax == 0xffff)
+		break;
+	}
+	if (i == 16)	/* 0xffff not read, must be old keyboard */
+	{
+	    bioskey_read = 0;
+	    bioskey_ready = 1;
+	}
+    }
+
+#ifdef MCH_CURSOR_SHAPE
+    /* Save the old cursor shape */
+    mch_restore_cursor_shape(FALSE);
+    /* Initialise the cursor shape */
+    mch_update_cursor();
+#endif
+
+#if defined(DJGPP) && defined(FEAT_CLIPBOARD)
+    /*
+     * Check to see if the Windows clipboard is available, ie. are we
+     * running from a DOS session within Windows.  Obviously, the Windows
+     * clipboard will not be available if we're running under pure DOS.
+     *
+     * int 0x2f, AX = 0x1700 identifies the Windows version we're running
+     * under.  Upon return from the interrupt, if AX is unchanged, we're
+     * running under pure DOS and no Windows clipboard is available.
+     *
+     * Remark: could use int86() here but __dpmi_int() is recommended in
+     * the DJGPP docs, since int86() doesn't cover all available interrupts.
+     */
+    dpmi_regs.x.ax = 0x1700;
+    if (__dpmi_int(0x2f, &dpmi_regs) == -1)
+	/* real-mode interrupt failed? */
+	dpmi_regs.x.ax = 0x1700;	/* force failure */
+
+    if (dpmi_regs.x.ax == 0x1700)	/* no change in AX? */
+	clip_init(FALSE);		/* no clipboard available, too bad */
+    else				/* else, running under Windows, OK */
+	clip_init(TRUE);		/* clipboard is available */
+#endif
+}
+
+    int
+mch_check_win(
+    int		argc,
+    char	**argv)
+{
+    /* store argv[0], may be used for $VIM */
+    if (*argv[0] != NUL)
+	exe_name = FullName_save((char_u *)argv[0], FALSE);
+
+    /*
+     * Try the DOS search path.  The executable may in
+     * fact be called differently, so try this last.
+     */
+    if (exe_name == NULL || *exe_name == NUL)
+	exe_name = searchpath("vim.exe");
+
+    if (isatty(1))
+	return OK;
+    return FAIL;
+}
+
+/*
+ * Return TRUE if the input comes from a terminal, FALSE otherwise.
+ */
+    int
+mch_input_isatty(void)
+{
+    if (isatty(read_cmd_fd))
+	return TRUE;
+    return FALSE;
+}
+
+#if defined(USE_FNAME_CASE) || defined(PROTO)
+/*
+ * fname_case(): Set the case of the file name, if it already exists.
+ * TODO: should expand short to long file names.  Need to use DOS interrupts,
+ * see DJGPP sources libc/dos/dir/findfirs.c.
+ */
+    void
+fname_case(char_u *name, int len)
+{
+    char_u	    *tail;
+    struct ffblk    fb;
+
+    slash_adjust(name);
+    if (findfirst(name, &fb, 0) == 0)
+    {
+	tail = gettail(name);
+	if (len == 0 ? STRLEN(tail) == STRLEN(fb.ff_name)
+		: (tail - name) + STRLEN(fb.ff_name) < len)
+	    STRCPY(tail, fb.ff_name);
+    }
+}
+#endif
+
+/*
+ * return process ID
+ */
+    long
+mch_get_pid(void)
+{
+    return (long)0;
+}
+
+/*
+ * Change default drive (just like _chdrive of Borland C 3.1)
+ */
+    static int
+change_drive(int drive)
+{
+    union REGS regs;
+
+    regs.h.ah = 0x0e;
+    regs.h.dl = drive - 1;
+    intdos(&regs, &regs);   /* set default drive */
+    regs.h.ah = 0x19;
+    intdos(&regs, &regs);   /* get default drive */
+    if (regs.h.al == drive - 1)
+	return 0;
+    return -1;
+}
+
+/*
+ * Get absolute file name into buffer 'buf' of length 'len' bytes.
+ * All slashes are replaced with backslashes, to avoid trouble when comparing
+ * file names.  When 'shellslash' set do it the other way around.
+ *
+ * return FAIL for failure, OK otherwise
+ */
+    int
+mch_FullName(
+    char_u	*fname,
+    char_u	*buf,
+    int		len,
+    int		force)
+{
+    if (!force && mch_isFullName(fname))	/* already expanded */
+    {
+	STRNCPY(buf, fname, len);
+	buf[len - 1] = NUL;
+	slash_adjust(buf);
+	return OK;
+    }
+
+#ifdef __BORLANDC__		/* Only Borland C++ has this */
+    if (_fullpath((char *)buf, (char *)fname, len - 1) == NULL)
+	return FAIL;
+    return OK;
+#else			/* almost the same as mch_FullName() in os_unix.c */
+    {
+# if 1
+	char_u	fullpath[MAXPATHL];
+
+	if (!_truename(fname, fullpath))
+	    return FAIL;
+	slash_adjust(fullpath);	    /* Only needed when 'shellslash' set */
+	STRNCPY(buf, fullpath, len);
+	buf[len - 1] = NUL;
+	return OK;
+
+# else  /* Old code, to be deleted... */
+	int	l;
+	char_u	olddir[MAXPATHL];
+	char_u	*p, *q;
+	int	c;
+	int	retval = OK;
+
+	*buf = 0;
+	/*
+	 * change to the 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.
+	 */
+	p = vim_strrchr(fname, '/');
+	q = vim_strrchr(fname, '\\');
+	if (q != NULL && (p == NULL || q > p))
+	    p = q;
+	q = vim_strrchr(fname, ':');
+	if (q != NULL && (p == NULL || q > p))
+	    p = q;
+	if (p != NULL)
+	{
+	    if (getcwd(olddir, MAXPATHL) == NULL)
+	    {
+		p = NULL;	/* can't get current dir: don't chdir */
+		retval = FAIL;
+	    }
+	    else
+	    {
+		if (p == fname)			/* /fname	    */
+		    q = p + 1;			/* -> /		    */
+		else if (q + 1 == p)		/* ... c:\foo	    */
+		    q = p + 1;			/* -> c:\	    */
+		else				/* but c:\foo\bar   */
+		    q = p;			/* -> c:\foo	    */
+
+		c = *q;			/* truncate at start of fname */
+		*q = NUL;
+# ifdef DJGPP
+		STRCPY(buf, fname);
+		slash_adjust(buf);	/* needed when fname starts with \ */
+		if (mch_chdir(buf))	/* change to the directory */
+# else
+		if (mch_chdir(fname))	/* change to the directory */
+# endif
+		    retval = FAIL;
+		else
+		{
+		    fname = q;
+		    if (c == psepc)	    /* if we cut the name at a */
+			fname++;	    /* '\', don't add it again */
+		}
+		*q = c;
+	    }
+	}
+	if (getcwd(buf, len) == NULL)
+	{
+	    retval = FAIL;
+	    *buf = NUL;
+	}
+#  ifdef USE_FNAME_CASE
+	else
+	{
+	    char_u	*head;
+	    char_u	*tail;
+	    struct ffblk fb;
+	    int		c;
+	    int		added;
+
+	    /* Apparently "longna~1" isn't expanded by getcwd(), at least not
+	     * for DJGPP.  Expand it here.  Have to do each dirname
+	     * separately. */
+	    slash_adjust(buf);
+	    head = buf;
+	    if (isalpha(*head) && head[1] == ':')
+		head += 2;	/* skip "c:" */
+	    while (*head != NUL)
+	    {
+		/* Advance "head" to the start of a dirname and "tail" to just
+		 * after it. */
+		while (*head == '/' || *head == '\\')
+		    ++head;
+		for (tail = head; *tail != NUL; ++tail)
+		    if (*tail == '/' || *tail == '\\')
+			break;
+		c = *tail;
+		*tail = NUL;
+
+		if (findfirst(buf, &fb, FA_DIREC) == 0)
+		{
+		    added = STRLEN(fb.ff_name);
+		    if ((head - buf) + added + STRLEN(tail + 1) + 2 < len)
+		    {
+			added -= (tail - head);
+			if (added != 0)
+			    mch_memmove(tail + 1 + added, tail + 1,
+							STRLEN(tail + 1) + 1);
+			STRCPY(head, fb.ff_name);
+			tail += added;
+		    }
+		}
+		*tail = c;
+		head = tail;
+	    }
+	}
+#  endif
+	if (p != NULL)
+	    mch_chdir(olddir);
+	/*
+	 * Concatenate the file name to the path.
+	 */
+	if (*fname != NUL)
+	{
+	    l = STRLEN(buf);
+	    if (l > 0 && buf[l - 1] != '/' && buf[l - 1] != '\\')
+		strcat(buf, pseps);
+	    strcat(buf, fname);
+	}
+	return retval;
+# endif
+    }
+#endif
+}
+
+/*
+ * Replace all slashes by backslashes.
+ * This used to be the other way around, but MS-DOS sometimes has problems
+ * with slashes (e.g. in a command name).  We can't have mixed slashes and
+ * backslashes, because comparing file names will not work correctly.  The
+ * commands that use a file name should try to avoid the need to type a
+ * backslash twice.
+ * When 'shellslash' set do it the other way around.
+ */
+    void
+slash_adjust(char_u *p)
+{
+#ifdef OLD_DJGPP    /* this seems to have been fixed in DJGPP 2.01 */
+    /* DJGPP can't handle a file name that starts with a backslash, and when it
+     * starts with a slash there should be no backslashes */
+    if (*p == '\\' || *p == '/')
+	while (*p)
+	{
+	    if (*p == '\\')
+		*p = '/';
+#ifdef FEAT_MBYTE
+	    if (has_mbyte)
+		p += (*mb_ptr2len_check)(p);
+	    else
+#endif
+		++p;
+	}
+    else
+#endif
+    while (*p)
+    {
+	if (*p == psepcN)
+	    *p = psepc;
+#ifdef FEAT_MBYTE
+	if (has_mbyte)
+	    p += (*mb_ptr2len_check)(p);
+	else
+#endif
+	    ++p;
+    }
+}
+
+/*
+ * Return TRUE if "fname" does not depend on the current directory.
+ */
+    int
+mch_isFullName(char_u *fname)
+{
+    /* A name like "d:/foo" and "//server/share" is absolute */
+    return (fname[0] != NUL && fname[1] == ':'
+				     && (fname[2] == '/' || fname[2] == '\\'))
+	|| (fname[0] == fname[1] && (fname[0] == '/' || fname[0] == '\\'));
+}
+
+
+    void
+mch_early_init(void)
+{
+}
+
+/*
+ * Careful: mch_exit() may be called before mch_init()!
+ */
+    void
+mch_exit(int r)
+{
+    settmode(TMODE_COOK);
+    stoptermcap();
+    set_interrupts(FALSE);	    /* restore interrupts */
+#ifdef DJGPP
+    set_sys_cursor();
+#endif
+    /* Somehow outputting CR-NL causes the original colors to be restored */
+    out_char('\r');
+    out_char('\n');
+    out_flush();
+    ml_close_all(TRUE);		    /* remove all memfiles */
+#ifdef MCH_CURSOR_SHAPE
+    mch_restore_cursor_shape(TRUE);
+#endif
+    exit(r);
+}
+
+/*
+ * set the tty in (raw) ? "raw" : "cooked" mode
+ * Does not change the tty, as bioskey() and kbhit() work raw all the time.
+ */
+    void
+mch_settmode(int tmode)
+{
+}
+
+#ifdef FEAT_MOUSE
+    void
+mch_setmouse(int on)
+{
+    mouse_active = on;
+    mouse_hidden = TRUE;	/* dont show it until moved */
+}
+#endif
+
+/*
+ * set screen mode
+ * return FAIL for failure, OK otherwise
+ */
+    int
+mch_screenmode(char_u *arg)
+{
+    int		    mode;
+    int		    i;
+    static char	   *(names[]) = {"BW40", "C40", "BW80", "C80", "MONO", "C4350"};
+    static int	    modes[]   = { BW40,	  C40,	 BW80,	 C80,	MONO,	C4350};
+
+    mode = -1;
+    if (VIM_ISDIGIT(*arg))		    /* mode number given */
+	mode = atoi((char *)arg);
+    else
+    {
+	for (i = 0; i < sizeof(names) / sizeof(char_u *); ++i)
+	    if (stricmp(names[i], (char *)arg) == 0)
+	    {
+		mode = modes[i];
+		break;
+	    }
+    }
+    if (mode == -1)
+    {
+	EMSG("E362: Unsupported screen mode");
+	return FAIL;
+    }
+    textmode(mode);		    /* use Borland function */
+#ifdef DJGPP
+    /* base address may have changed */
+    get_screenbase();
+#endif
+
+    /* Screen colors may have changed. */
+    out_str(T_ME);
+
+#ifdef FEAT_MOUSE
+    if (mode <= 1 || mode == 4 || mode == 5 || mode == 13 || mode == 0x13)
+	mouse_x_div = 16;
+    else
+	mouse_x_div = 8;
+    if (mode == 0x11 || mode == 0x12)
+	mouse_y_div = 16;
+    else if (mode == 0x10)
+	mouse_y_div = 14;
+    else
+	mouse_y_div = 8;
+    shell_resized();
+#endif
+    return OK;
+}
+
+/*
+ * Structure used by Turbo-C/Borland-C to store video parameters.
+ */
+#ifndef DJGPP
+extern struct text_info _video;
+#endif
+
+/*
+ * try to get the real window size
+ * return FAIL for failure, OK otherwise
+ */
+    int
+mch_get_shellsize(void)
+{
+    struct text_info textinfo;
+
+    /*
+     * The screenwidth is returned by the BIOS OK.
+     * The screenheight is in a location in the bios RAM, if the display is
+     * EGA or VGA.
+     */
+    if (!term_console)
+	return FAIL;
+    gettextinfo(&textinfo);
+    Columns = textinfo.screenwidth;
+    Rows = textinfo.screenheight;
+#ifndef DJGPP
+    if (textinfo.currmode > 10)
+	Rows = *(char far *)MK_FP(0x40, 0x84) + 1;
+#endif
+
+    if (Columns < MIN_COLUMNS || Rows < MIN_LINES)
+    {
+	/* these values are overwritten by termcap size or default */
+	Columns = 80;
+	Rows = 25;
+	return FAIL;
+    }
+#ifdef DJGPP
+    mytextinit(&textinfo);   /* Added by JML, 1/15/98 */
+#endif
+
+    return OK;
+}
+
+/*
+ * Set the active window for delline/insline.
+ */
+    static void
+set_window(void)
+{
+    if (term_console)
+    {
+#ifndef DJGPP
+	_video.screenheight = Rows;
+#endif
+	mywindow(1, 1, Columns, Rows);
+    }
+    screen_start();
+}
+
+    void
+mch_set_shellsize(void)
+{
+    /* Should try to set the window size to Rows and Columns.
+     * May involve switching display mode....
+     * We assume the user knows the size and just use it. */
+}
+
+/*
+ * Rows and/or Columns has changed.
+ */
+    void
+mch_new_shellsize()
+{
+#ifdef FEAT_MOUSE
+    /* best guess for mouse coordinate computations */
+    if (Columns <= 40)
+	mouse_x_div = 16;
+    if (Rows == 30)
+	mouse_y_div = 16;
+#endif
+    set_window();
+#ifdef FEAT_MOUSE
+    mouse_area();	/* set area where mouse can go */
+#endif
+}
+
+#if defined(DJGPP) || defined(PROTO)
+/*
+ * Check the number of Columns with a BIOS call.  This avoids a crash of the
+ * DOS console when 'columns' is set to a too large value.
+ */
+    void
+mch_check_columns()
+{
+    static union REGS	regs;
+
+    regs.h.ah = 0x0f;
+    (void)int86(0x10, &regs, &regs);
+    if ((unsigned)Columns > (unsigned)regs.h.ah)
+	Columns = (unsigned)regs.h.ah;
+}
+#endif
+
+/*
+ * call shell, return FAIL for failure, OK otherwise
+ * options: SHELL_*, see vim.h.
+ */
+    int
+mch_call_shell(
+    char_u	*cmd,
+    int		options)
+{
+    int		x;
+    int		tmode = cur_tmode;
+#ifndef DJGPP
+    char_u	*newcmd;
+#endif
+
+    out_flush();
+#ifdef DJGPP
+    set_sys_cursor();
+#endif
+
+    if (options & SHELL_COOKED)
+	settmode(TMODE_COOK);	/* set to normal mode */
+    set_interrupts(FALSE);	/* restore interrupts */
+
+#ifdef DJGPP
+    /* ignore signals while external command is running */
+    signal(SIGINT, SIG_IGN);
+    signal(SIGHUP, SIG_IGN);
+    signal(SIGQUIT, SIG_IGN);
+    signal(SIGTERM, SIG_IGN);
+#endif
+    if (cmd == NULL)
+	x = system((char *)p_sh);
+    else
+    {
+#ifdef DJGPP
+	/*
+	 * Use 'shell' for system().
+	 */
+	setenv("SHELL", (char *)p_sh, 1);
+	x = system(cmd);
+#else
+	/* we use "command" to start the shell, slow but easy */
+	newcmd = alloc(STRLEN(p_sh) + STRLEN(p_shcf) + STRLEN(cmd) + 3);
+	if (newcmd == NULL)
+	    x = -1;
+	else
+	{
+	    sprintf((char *)newcmd, "%s %s %s", p_sh, p_shcf, cmd);
+	    x = system((char *)newcmd);
+	    vim_free(newcmd);
+	}
+#endif
+    }
+#ifdef DJGPP
+    signal(SIGINT, SIG_DFL);
+    signal(SIGHUP, SIG_DFL);
+    signal(SIGQUIT, SIG_DFL);
+    signal(SIGTERM, SIG_DFL);
+#endif
+    if (tmode == TMODE_RAW)
+	settmode(TMODE_RAW);	/* set to raw mode */
+    set_interrupts(TRUE);	/* catch interrupts */
+
+    if (x && !(options & SHELL_SILENT) && !emsg_silent)
+    {
+	MSG_PUTS("\nshell returned ");
+	msg_outnum((long)x);
+	msg_putchar('\n');
+    }
+
+    return x;
+}
+
+/*
+ * check for an "interrupt signal": CTRL-break or CTRL-C
+ */
+    void
+mch_breakcheck(void)
+{
+    if (ctrlc_pressed)
+    {
+	ctrlc_pressed = FALSE;
+	got_int = TRUE;
+    }
+}
+
+/*
+ * Return TRUE if "p" contain a wildcard that can be expanded by
+ * dos_expandpath().
+ */
+    int
+mch_has_exp_wildcard(char_u *p)
+{
+    for ( ; *p; ++p)
+    {
+	if (vim_strchr((char_u *)"?*[", *p) != NULL
+		|| (*p == '~' && p[1] != NUL))
+	    return TRUE;
+#ifdef FEAT_MBYTE
+	if (has_mbyte)
+	    p += (*mb_ptr2len_check)(p) - 1;
+#endif
+    }
+    return FALSE;
+}
+
+/*
+ * Return TRUE if "p" contain a wildcard or a "~1" kind of thing (could be a
+ * shortened file name).
+ */
+    int
+mch_has_wildcard(char_u *p)
+{
+    for ( ; *p; ++p)
+    {
+	if (vim_strchr((char_u *)
+#  ifdef VIM_BACKTICK
+				    "?*$[`"
+#  else
+				    "?*$["
+#  endif
+						, *p) != NULL
+		|| (*p == '~' && p[1] != NUL))
+	    return TRUE;
+#ifdef FEAT_MBYTE
+	if (has_mbyte)
+	    p += (*mb_ptr2len_check)(p) - 1;
+#endif
+    }
+    return FALSE;
+}
+
+/*
+ * Change directory to "path".
+ * The normal chdir() does not change the default drive.  This one does.
+ * Return 0 for success, -1 for failure.
+ */
+    int
+mch_chdir(char *path)
+{
+    if (path[0] == NUL)		    /* just checking... */
+	return 0;
+    if (path[1] == ':')		    /* has a drive name */
+    {
+	if (change_drive(TOLOWER_ASC(path[0]) - 'a' + 1))
+	    return -1;		    /* invalid drive name */
+	path += 2;
+    }
+    if (*path == NUL)		    /* drive name only */
+	return 0;
+    return chdir(path);		    /* let the normal chdir() do the rest */
+}
+
+#ifdef DJGPP
+/*
+ * mch_rename() works around a bug in rename (aka MoveFile) in
+ * Windows 95: rename("foo.bar", "foo.bar~") will generate a
+ * file whose short file name is "FOO.BAR" (its long file name will
+ * be correct: "foo.bar~").  Because a file can be accessed by
+ * either its SFN or its LFN, "foo.bar" has effectively been
+ * renamed to "foo.bar", which is not at all what was wanted.  This
+ * seems to happen only when renaming files with three-character
+ * extensions by appending a suffix that does not include ".".
+ * Windows NT gets it right, however, with an SFN of "FOO~1.BAR".
+ * This works like mch_rename in os_win32.c, but is a bit simpler.
+ *
+ * Like rename(), returns 0 upon success, non-zero upon failure.
+ * Should probably set errno appropriately when errors occur.
+ */
+
+    int
+mch_rename(const char *OldFile, const char *NewFile)
+{
+    char_u  *TempFile;
+    int	    retval;
+    int	    fd;
+
+    /* rename() works correctly without long file names, so use that */
+    if (!_USE_LFN)
+	return rename(OldFile, NewFile);
+
+    if ((TempFile = alloc((unsigned)(STRLEN(OldFile) + 13))) == NULL)
+	return -1;
+
+    STRCPY(TempFile, OldFile);
+    STRCPY(gettail(TempFile), "axlqwqhy.ba~");
+    if (rename(OldFile, TempFile))
+	retval = -1;
+    else
+    {
+	/* now create an empty file called OldFile; this prevents
+	 * the operating system using OldFile as an alias (SFN)
+	 * if we're renaming within the same directory.  For example,
+	 * we're editing a file called filename.asc.txt by its SFN,
+	 * filena~1.txt.  If we rename filena~1.txt to filena~1.txt~
+	 * (i.e., we're making a backup while writing it), the SFN
+	 * for filena~1.txt~ will be filena~1.txt, by default, which
+	 * will cause all sorts of problems later in buf_write.  So, we
+	 * create an empty file called filena~1.txt and the system will have
+	 * to find some other SFN for filena~1.txt~, such as filena~2.txt
+	 */
+	if ((fd = open(OldFile, O_RDWR|O_CREAT|O_EXCL, 0444)) < 0)
+	    return -1;
+	retval = rename(TempFile, NewFile);
+	close(fd);
+	mch_remove((char_u *)OldFile);
+
+	/* If renaming to NewFile failed, rename TempFile back to OldFile, so
+	 * that it looks like nothing happened. */
+	if (retval)
+	    rename(TempFile, OldFile);
+    }
+    vim_free(TempFile);
+
+    return retval;  /* success */
+}
+#endif
+
+#if defined(DJGPP) || defined(PROTO)
+/*
+ * setlocale() for DJGPP with MS-DOS codepage support
+ * Author: Cyril Slobin <slobin@fe.msk.ru>
+ *
+ * Scaled down a lot for use by Vim: Only support setlocale(LC_ALL, "").
+ */
+
+#undef setlocale
+
+#include <go32.h>
+#include <inlines/ctype.ha>
+#include <locale.h>
+
+#define UPCASE (__dj_ISALNUM | __dj_ISALPHA | __dj_ISGRAPH | __dj_ISPRINT | __dj_ISUPPER)
+#define LOCASE (__dj_ISALNUM | __dj_ISALPHA | __dj_ISGRAPH | __dj_ISPRINT | __dj_ISLOWER)
+
+    char *
+djgpp_setlocale(void)
+{
+    __dpmi_regs regs;
+    struct { char id; unsigned short off, seg; } __attribute__ ((packed)) info;
+    unsigned char buffer[0x82], lower, upper;
+    int i;
+
+    regs.x.ax = 0x6502;
+    regs.x.bx = 0xffff;
+    regs.x.dx = 0xffff;
+    regs.x.cx = 5;
+    regs.x.es = __tb >> 4;
+    regs.x.di = __tb & 0xf;
+
+    __dpmi_int(0x21, &regs);
+
+    if (regs.x.flags & 1)
+	return NULL;
+
+    dosmemget(__tb, 5, &info);
+    dosmemget((info.seg << 4) + info.off, 0x82, buffer);
+
+    if (*(short *)buffer != 0x80)
+	return NULL;
+
+    /* Fix problem of underscores being replaced with y-umlaut. (Levin) */
+    if (buffer[26] == 0x5f)
+	buffer[26] = 0x98;
+
+    for (i = 0; i < 0x80; i++)
+    {
+	lower = i + 0x80;
+	upper = (buffer+2)[i];
+	if (lower != upper)
+	{
+	    __dj_ctype_flags[lower+1] = LOCASE;
+	    __dj_ctype_toupper[lower+1] = upper;
+	    if (__dj_ctype_flags[upper+1] == 0)
+		__dj_ctype_flags[upper+1] = UPCASE;
+	    if (__dj_ctype_tolower[upper+1] == upper)
+		__dj_ctype_tolower[upper+1] = lower;
+	}
+    }
+
+    return "C";
+}
+
+#if defined(FEAT_CLIPBOARD) || defined(PROTO)
+
+/*
+ * Clipboard stuff, for cutting and pasting text to other windows.
+ *
+ * Implementation of DOS/Windows clipboard data transfer
+ * by David Kotchan (dkotchan@sympatico.ca)
+ */
+
+#define CF_TEXT	    0x01    /* Windows clipboard format: Windows (ANSI) text */
+#define CF_OEMTEXT  0x07    /* Windows clipboard format: OEM (DOS) text */
+#define CF_VIMCLIP  0x04    /* trick: SYLK clipboard format for VimClipboard */
+
+static int Win16OpenClipboard(void);
+static int Win16CloseClipboard(void);
+static int Win16EmptyClipboard(void);
+static char_u *Win16GetClipboardData(int clip_data_format);
+static int Win16SetClipboardData(int clip_data_format, char_u *clip_data, int clip_data_size, int clip_data_type);
+
+/*
+ * Make vim the owner of the current selection.  Return OK upon success.
+ */
+    int
+clip_mch_own_selection(VimClipboard *cbd)
+{
+    /*
+     * Never actually own the clipboard.  If another application sets the
+     * clipboard, we don't want to think that we still own it.
+     */
+    return FAIL;
+}
+
+/*
+ * Make vim NOT the owner of the current selection.
+ */
+    void
+clip_mch_lose_selection(VimClipboard *cbd)
+{
+    /* Nothing needs to be done here */
+}
+
+/*
+ * Read the Windows clipboard text and put it in Vim's clipboard register.
+ */
+    void
+clip_mch_request_selection(VimClipboard *cbd)
+{
+    int		type = MCHAR;
+    char_u	*pAllocated = NULL;
+    char_u	*pClipText = NULL;
+    int		clip_data_format = 0;
+
+    if (Win16OpenClipboard())
+    {
+	/* Check for Vim's own clipboard format first.  The CF_VIMCLIP format
+	 * is just ordinary text (like CF_TEXT) except prepended by the
+	 * selection type (as a single character).  Note that under DOS we
+	 * actually cannot define a custom CF_VIMCLIP clipboard format; we
+	 * use instead one of the existing Windows-defined formats, usually
+	 * "DIF" or "SYLK".  See Win16GetClipboardData() for details.
+	 *
+	 * Note that Win16GetClipboardData() returns the address of the memory
+	 * block it allocated.  This is not necessary the start of the
+	 * clipboard text data: there may be other bytes ahead of the
+	 * text (particularly for CF_VIMCLIP) which are used for data
+	 * management.  So pClipText is not necessarily == pAllocated.
+	 */
+
+	if ((pAllocated = Win16GetClipboardData(CF_VIMCLIP)) != NULL)
+	{
+	    clip_data_format = CF_VIMCLIP;
+	    pClipText = pAllocated;
+
+	    switch (*pClipText++)	/* after ++, pClipText points to text */
+	    {
+		default:
+		case 'L':	type = MLINE;	break;
+		case 'C':	type = MCHAR;	break;
+#ifdef FEAT_VISUAL
+		case 'B':	type = MBLOCK;	break;
+#endif
+	    }
+	}
+
+	/* Otherwise, check for the normal Windows text formats.  There are
+	 * two of these: CF_TEXT (common) and CF_OEMTEXT (used for DOS
+	 * compatibility).  Experiments show that, under the DOS/Windows
+	 * clipboard interface, writing CF_TEXT data to the clipboard
+	 * automatically creates a CF_OEMTEXT format as well.
+	 */
+
+	else if ((pAllocated = Win16GetClipboardData(CF_TEXT)) != NULL)
+	{
+	    clip_data_format = CF_TEXT;
+	    pClipText = pAllocated;
+	    type = (vim_strchr((char*)pClipText, '\r') != NULL) ? MLINE : MCHAR;
+	}
+
+	else if ((pAllocated = Win16GetClipboardData(CF_OEMTEXT)) != NULL)
+	{
+	    clip_data_format = CF_OEMTEXT;
+	    pClipText = pAllocated;
+	    type = (vim_strchr((char*)pClipText, '\r') != NULL) ? MLINE : MCHAR;
+	}
+
+	/* Did we get anything? */
+
+	if (pClipText != NULL)
+	{
+	    char_u *pDest;
+	    char_u *pStart;
+	    char_u *pEnd;
+
+	    long_u clip_data_size = 0;
+
+	    /* The Windows clipboard normally stores its text lines terminated
+	     * by <CR><NL>.  But Vim uses only <NL>, so translate the <CR><NL>
+	     * into <NL>.  Also, watch for possible null bytes at the end of
+	     * pClipText.  These are padding added by "get_clipboard_data"
+	     * (int 0x2f, AX= 0x1705) in order to round the data size up to the
+	     * next multiple of 32 bytes.  See Win16GetClipboardData() for
+	     * details.
+	     */
+
+	    pDest = strstr( pClipText, "\r\n" );    /* find first <CR><NL> */
+
+	    if (pDest != NULL)			/* found one? */
+	    {
+		pStart = pDest + 1;		/* points to <NL> after <CR> */
+		pEnd = strstr( pStart, "\r\n" );/* find next <CR><NL> */
+
+		while (pEnd != NULL)		/* found one? */
+		{
+		    memmove(pDest, pStart, (long)(pEnd - pStart));
+							/* exclude <CR> */
+		    pDest += (long)(pEnd - pStart);	/* new destination */
+		    pStart = pEnd + 1;			/* new starting point */
+		    pEnd = strstr(pStart, "\r\n");	/* find next <CR><NL> */
+		}
+
+		/* Fell out of while() loop: no more <CR><NL> pairs.  Just copy
+		 * the rest of the data, up to the first null byte.  */
+		pEnd = strchr(pStart, '\0');		/* find first null */
+
+		memmove(pDest, pStart, (long)(pEnd - pStart)); /* exclude nul */
+		pDest += (long)(pEnd - pStart);
+		*pDest = '\0';				    /* terminate */
+
+		/* Now that all <CR><NL> pairs have been "compressed" into just
+		 * <NL>'s, determine the true text length.  */
+		clip_data_size = (long_u)(pDest - pClipText);
+	    }
+	    else
+	    {
+		/* no <CR><NL> pairs at all */
+		/* Since the data may have been padded with trailing nulls,
+		 * determine the true string length. */
+		clip_data_size = STRLEN(pClipText);	/* true data length */
+	    }
+
+	    /* Copy the cleaned-up data over to Vim's clipboard "*" register. */
+	    clip_yank_selection(type, pClipText, clip_data_size, cbd);
+
+	    /* Free the memory that Win16GetClipboardData() allocated. */
+	    vim_free(pAllocated);
+	}
+
+	Win16CloseClipboard();
+
+    }  // end if (Win16OpenClipboard())
+}
+
+/*
+ * Send the currently selected Vim text to the Windows clipboard.
+ */
+    void
+clip_mch_set_selection( VimClipboard *cbd )
+{
+    char_u	*pClipData = NULL;
+    long_u	clip_data_size;
+    int		clip_data_type;
+
+    /* If the '*' register isn't already filled in, fill it in now. */
+    cbd->owned = TRUE;
+    clip_get_selection(cbd);
+    cbd->owned = FALSE;
+
+    /*
+     * clip_convert_selection() returns a pointer to a buffer containing
+     * the text to send to the Windows clipboard, together with a count
+     * of the number of characters (bytes) in the buffer.  The function's
+     * return value is the 'type' of selection: MLINE, MCHAR, or MBLOCK;
+     * or -1 for failure.
+     */
+    clip_data_type = clip_convert_selection(&pClipData, &clip_data_size, cbd);
+
+    if (clip_data_type < 0)	    /* could not convert? */
+	return;			    /* early exit */
+
+    if (Win16OpenClipboard())
+    {
+	if (Win16EmptyClipboard())
+	{
+	    int sentOK;
+
+	    sentOK = Win16SetClipboardData(CF_TEXT, pClipData,
+					      clip_data_size, clip_data_type);
+	    sentOK = Win16SetClipboardData(CF_VIMCLIP,
+			 pClipData, clip_data_size, clip_data_type) && sentOK;
+
+	    if (!sentOK)
+	    {
+		/* one or both of Win16SetClipboardData() failed. */
+		/* Technically we don't know why Win16SetClipboardData()
+		 * failed, but almost always it will be because there wasn't
+		 * enough DOS memory to bufer the data, so report that as the
+		 * problem.
+		 *
+		 * We report the error here (instead of in
+		 * Win16SetClipboardData()) because we don't want the error
+		 * reported twice.
+		 */
+		EMSG("E450: Selection too large, cannot allocate DOS buffer");
+	    }
+	}
+
+	Win16CloseClipboard();
+    }
+
+    /* release memory allocated by clip_convert_selection() */
+    vim_free(pClipData);
+
+    return;
+}
+
+/*
+ * Win16OpenClipboard: open the Windows clipboard.  The clipboard must be open
+ * before it can be communicated with at all.  Return TRUE on success,
+ * FALSE on failure.
+ */
+    static int
+Win16OpenClipboard(void)
+{
+    __dpmi_regs  dpmi_regs;
+
+    long    start_time;
+    int	    tick_count;
+
+    /* int 02xf, AX = 0x1701 attempts to open the Windows clipboard.  Upon
+     * return from the interrupt, if AX is non-zero, the clipboard was
+     * successfully opened.  If AX is zero, the clipboard could not be opened
+     * because it is currently in use by another process.
+     *
+     * Remark: other DOS programs I (dk) have written that use the Windows
+     * clipboard sometimes encounter the problem that the clipboard cannot
+     * be opened even though it is demonstrably not in use by any other
+     * process.  In all cases, repeated attempts to open the clipboard
+     * eventually succeed, but the initial attempt occasionally fails.
+     *
+     * The problem is intermittent and appears to be related to DOS being
+     * "busy" at certain unpredictable times.  DOS maintains two internal
+     * flags that indicate whether it's busy: InDOS and CritErr.  The
+     * location of InDOS can be found by calling int 0x21, AH = 0x34.  The
+     * location of CritErr can be found by calling int 0x21, AX = 0x5d06.
+     * If either of these flags is set, DOS is "busy" and cannot be
+     * interrupted.  See "Undocumented DOS" by Schulman et al for details.
+     *
+     * However here I take the easier approach that if the first call to open
+     * the clipboard does not succeed, just try again.  In fact, try once per
+     * biostime() clock tick, up to 18 times (about one second).
+     */
+
+    tick_count = 0;
+
+    dpmi_regs.x.ax = 0x1701;	/* open Windows clipboard */
+    if (__dpmi_int(0x2f, &dpmi_regs) == -1)
+    {
+	/* real-mode interrupt failed? */
+	return FALSE;		/* FALSE --> clipboard not open */
+    }
+
+    /* wait up to one second */
+    while (dpmi_regs.x.ax == 0 && tick_count++ < 18)
+    {
+	/* Wait one clock tick (18.2 ticks/sec = 55 msec per tick).
+	 *
+	 * We busy-wait here.  Unfortunately, delay() and usleep() have been
+	 * reported to give problems with the original Windows 95.  This is
+	 * fixed in service pack 1, but not everybody installed that.
+	 */
+	start_time = biostime(0, 0L);
+	while (biostime(0, 0L) == start_time)
+	    ;
+
+	dpmi_regs.x.ax = 0x1701;    /* open Windows clipboard */
+	if (__dpmi_int(0x2f, &dpmi_regs) == -1)
+	{
+	    /* real-mode interrupt failed? */
+	    return FALSE;		/* FALSE --> clipboard not open */
+	}
+    }
+
+    /* Couldn't open the clipboard, even after 18 attempts? */
+
+    if (tick_count >= 18 && dpmi_regs.x.ax == 0)
+	return FALSE;		/* FALSE --> clipboard not open */
+
+    return TRUE;	/* TRUE --> clipboard opened successfully, OK */
+}
+
+/*
+ * Win16CloseClipboard: close the Windows clipboard.  Return TRUE on
+ * success, FALSE on failure.  This function can always be called,
+ * whether the clipboard is open or not.
+ */
+    static int
+Win16CloseClipboard(void)
+{
+    __dpmi_regs  dpmi_regs;
+
+    /* Close the clipboard.  This interrupt can always be called, even
+     * if the clipboard is already closed.
+     */
+
+    dpmi_regs.x.ax = 0x1708;	    /* close the clipboard */
+    if (__dpmi_int(0x2f, &dpmi_regs) == -1)
+    {
+	/* real-mode interrupt failed? */
+	return FALSE;		/* FALSE --> clipboard could not be closed */
+    }
+
+    return TRUE;	/* TRUE --> clipboard closed successfully, OK */
+}
+
+/*
+ * Win16EmptyClipboard: empty the (previously opened) Windows clipboard.
+ * Return TRUE on success, FALSE on failure.
+ */
+    static int
+Win16EmptyClipboard(void)
+{
+    __dpmi_regs  dpmi_regs;
+
+    /* int 02xf, AX = 0x1702 attempts to empty the Windows clipboard.  Upon
+     * return from the interrupt, if AX == 0, the clipboard could not be
+     * emptied (for some reason).
+     */
+    dpmi_regs.x.ax = 0x1702;    /*  empty the Windows clipboard */
+    if (__dpmi_int(0x2f, &dpmi_regs) == -1)
+    {
+	/* real-mode interrupt failed? */
+	return FALSE;		/* FALSE --> clipboard could not be emptied */
+    }
+
+    /* Did we succeed in clearing the clipboard? */
+    if (dpmi_regs.x.ax == 0)
+	return FALSE;		/* FALSE --> clipboard could not be emptied */
+
+    return TRUE;		/* TRUE --> clipboard was emptied, OK */
+}
+
+/*
+ * FreeDOSMemory: a helper function to free memory previously
+ * allocated by a call to __dpmi_allocate_dos_memory().
+ */
+    static void
+FreeDOSMemory(int protected_mode_selector)
+{
+    /* Free the DOS buffer and release the DPMI prot-mode selector.
+     *
+     * It's important that DOS memory be properly released because
+     * there's only a limited amount of it.  Therefore, if the call
+     * to __dpmi_free_dos_memory() fails, emit an error message
+     * unconditionally.
+     */
+    if (__dpmi_free_dos_memory(protected_mode_selector) == -1)
+	EMSG("E451: could not free DOS memory buffer (DJGPP)");
+}
+
+/*
+ * Win16GetClipboardData: query the Windows clipboard as to whether data
+ * is available in a particular clipboard format.  If data is
+ * available, allocate a buffer for it and read the data from the
+ * clipboard into the buffer.  Return a pointer to the buffer.  If
+ * no data is available in the requested format, return NULL.
+ *
+ * This routine allocates memory to hold the retrieved clipboard
+ * data.  It's the caller's responsibility to free this memory
+ * once it's finished using it.  The memory should be freed by
+ * calling vim_free().
+ */
+    static char_u *
+Win16GetClipboardData(int clip_data_format)
+{
+    __dpmi_regs  dpmi_regs;
+
+    int		real_mode_segment_address;
+    int		protected_mode_selector;
+
+    char_u	*clip_data_buffer;
+    long_u	clip_data_size;
+
+    /* We only handle clipboard formats we recognize, others are ignored.
+     *
+     * It's not possible to create a custom clipboard format for VimClipboard
+     * data under DOS, so one of the predefined Windows formats had to be
+     * used for CF_VIMCLIP.  Two obscure formats, popular when Windows 3.0
+     * came out but no longer in much use today, are the DIF and SYLK formats.
+     * DIF is the Data Interchange Format, SYLK is the Symbolic Link format.
+     * They are both text formats and either one can be hijacked for use as
+     * "the VimClipboard format".  Of course, this conflicts with anyone who
+     * still *is* using DIF or SYLK data formats, but that will be very few
+     * people.
+     *
+     * I (dk) chose SYLK as the more obscure format because it was used
+     * mostly for Microsoft Multiplan (the pre-cursor to Excel) and it's not
+     * likely Multiplan is used anywhere much anymore.  Mind you, Excel can
+     * still export to both DIF and SYLK formats.
+     */
+
+    switch (clip_data_format)
+    {
+    case CF_VIMCLIP:		    /* Vim's own special clipboard format */
+    case CF_TEXT:		    /* Windows text */
+    case CF_OEMTEXT:		    /* DOS (OEM) text */
+
+	/* int 02xf, AX = 0x1704 returns the number of bytes of data currently
+	 * on the Windows clipboard, for the specified format.  Upon return
+	 * from the interrupt, DX:AX = the number of bytes, rounded up to the
+	 * nearest multiple of 32.
+	 */
+
+	dpmi_regs.x.ax = 0x1704;    /* get size of clipbd data */
+	dpmi_regs.x.dx = clip_data_format;
+	if (__dpmi_int(0x2f, &dpmi_regs) == -1)
+	{
+	    /* real-mode interrupt failed? */
+	    return NULL;				    /* early exit */
+	}
+
+	/* Did we get anything?  If not, this is not an error. */
+	if (dpmi_regs.x.dx == 0 && dpmi_regs.x.ax == 0)
+	{
+	    /* no CF_VIMCLIP data? */
+	    return NULL;				    /* early exit */
+	}
+
+	/* There is data available in the requested clipboard format.
+	 *
+	 * Calculate data size.  Remember this is rounded up to the nearest
+	 * multiple of 32, so clip_data_size is actually an upper limit.
+	 * The extra bytes, if any, are set to null (0x00) when the data is
+	 * read from the clipboard.  (Later:) actually I'm no longer sure
+	 * this is strictly true: the end-of-data is marked by a null, but
+	 * the extra bytes appear to sometimes be null, sometimes not.
+	 * They may just be garbage.
+	 */
+	clip_data_size = dpmi_regs.x.ax + (dpmi_regs.x.dx << 16);
+
+	/* Allocate memory to retrieve the data.  The buffer has to lie in the
+	 * DOS memory region (in the first 1 MByte of address space) because
+	 * the Windows clipboard interface expects a 16-bit segment:offset
+	 * pointer to a buffer address within the DOS region.  Must therefore
+	 * use __dpmi_allocate_dos_memory() instead of lalloc() or alloc().
+	 */
+	real_mode_segment_address = __dpmi_allocate_dos_memory(
+		(clip_data_size + 15) >> 4,	/* buffer size, in 16-byte paragraphs */
+		&protected_mode_selector);	/* prot-mode selector for the address */
+
+	if (real_mode_segment_address == -1)
+	{
+	    /* memory allocation failed. */
+
+	    /* Technically we don't know why the allocation failed, but
+	     * almost always it will be because there wasn't enough DOS
+	     * memory to satisfy the request, so report that as the problem.
+	     * On my system, DJGPP is able to satisfy a DOS allocation request
+	     * up to about 600K in size.  This depends on your HIMEM.SYS and
+	     * EMM386.EXE settings however.
+	     */
+	    EMSG("E452: Clipboard data too large, cannot allocate DOS buffer");
+	    return NULL;				    /* early exit */
+	}
+
+	/* Copy data from the clipboard into the buffer.  Experiments show that
+	 * the Windows clipboard is smart enough to handle data transfers
+	 * larger than 64K properly, even though the buffer address is a 16-bit
+	 * segment:offset (which would normally limit the block size to 64K
+	 * unless ES gets incremented).
+	 */
+	dpmi_regs.x.ax = 0x1705;	/* get clipboard data */
+	dpmi_regs.x.dx = clip_data_format;		/* CF_VIMCLIP */
+	dpmi_regs.x.es = real_mode_segment_address;	/* buffer ad: segment */
+	dpmi_regs.x.bx = 0;				/* buffer ad: offset */
+	if (__dpmi_int( 0x2f, &dpmi_regs) == -1)
+	{
+	    /* real-mode interrupt failed? */
+	    EMSG("E453: could not copy clipboard data to DOS buffer");
+	    FreeDOSMemory(protected_mode_selector);	/* clean up DOS mem */
+	    return NULL;				/* early exit */
+	}
+
+	/* Clipboard data is now in DOS memory in the buffer pointed to by
+	 * ES:BX.  Copy this into ordinary memory that Vim can access (ie.
+	 * prot-mode memory).  Allocate one extra byte to ensure the text
+	 * is terminated properly (in case it was somehow corrupted).
+	 */
+	clip_data_buffer = (char_u *)lalloc(clip_data_size + 1, TRUE);
+
+	if (clip_data_buffer == NULL)
+	{
+	    /* allocation failed? */
+	    EMSG("E454: could not allocate clipboard memory buffer");
+	    FreeDOSMemory(protected_mode_selector);	/* clean up DOS mem */
+	    return NULL;				/* early exit */
+	}
+
+	*(clip_data_buffer + clip_data_size) = '\0';	/* ensure terminated */
+
+	/* Copy the data from DOS memory to Vim-accessible memory. */
+	movedata(				/* DJGPP version of memcpy() */
+		protected_mode_selector, 0, /* source: DOS ad (via selector) */
+		_my_ds(), (unsigned)clip_data_buffer,
+						/* target: normal mem address */
+		clip_data_size);		/* how many bytes */
+
+	/* Free the DOS buffer and release the DPMI prot-mode selector. */
+	FreeDOSMemory(protected_mode_selector);	 /* clean up DOS memory */
+
+	return clip_data_buffer;    /* return pointer to allocated buffer */
+
+    default:		/* unknown clipboard format */
+	return NULL;
+    }
+}
+
+/*
+ * Win16SetClipboardData: send 'clip_data_size' bytes of data from the buffer
+ * pointed to by 'clip_data', to the Windows clipboard.  The data is
+ * registered with the clipboard as being in the 'clip_data_format'
+ * format.
+ */
+    static int
+Win16SetClipboardData(
+	int	clip_data_format,
+	char_u	*clip_data,
+	int	clip_data_size,
+	int	clip_data_type)
+{
+    __dpmi_regs  dpmi_regs;
+
+    int		real_mode_segment_address;
+    int		protected_mode_selector;
+    long_u	protected_mode_offset = 0L;
+    int		total_size = clip_data_size;
+
+    char_u	*clip_sel_type;
+
+    /* If we're using the CF_VIMCLIP custom format, allocate an extra
+     * byte for clip_sel_type, which is a character indicating the type
+     * of text selection: MLINE, MCHAR, or MBLOCK.
+     */
+    if (clip_data_format == CF_VIMCLIP)
+	total_size++;			/* extra byte for marker */
+
+    /* Data cannot be sent directly from a Vim string (pClipData) to
+     * the Windows clipboard, because the Windows clipboard interface
+     * expects a 16-bit (DOS) segment:offset address for the source
+     * buffer.  Therefore we must create a "transfer buffer" in the DOS
+     * memory region (in the first 1 MByte of address space) and copy
+     * the Vim string into that.  From there, the data can then be sent
+     * to the Windows clipboard.
+     *
+     * To allocate DOS memory, we must use __dpmi_allocate_dos_memory()
+     * instead of lalloc() or alloc().  If the allocation fails, it will
+     * almost invariably be because there is not enough DOS memory
+     * available to accommodate the size of clip_data.  There is nothing
+     * we can do about this, we simply have to fail.
+     */
+    real_mode_segment_address = __dpmi_allocate_dos_memory(
+	    (total_size + 15) >> 4,	/* buffer size, in 16-byte paragraphs */
+	    &protected_mode_selector);	/* prot-mode selector for the address */
+
+    if (real_mode_segment_address == -1)
+    {
+	/* memory allocation failed. */
+	/* Technically we don't know why the allocation failed, but
+	 * almost always it will be because there wasn't enough DOS
+	 * memory to satisfy the request.  On my system, DJGPP is able
+	 * to satisfy a DOS allocation request up to about 600K in size.
+	 * This depends however on HIMEM.SYS and EMM386.EXE settings.
+	 */
+	return FALSE;				/* early exit */
+    }
+
+    /* Copy data from Vim's buffer (clip_data) into the DOS transfer buffer.
+     * This can be larger than 64K; movedata() takes care of crossing any
+     * 16-bit segment boundaries.
+     *
+     * If we're using Vim's custom clipboard format, we must copy one extra
+     * byte to indicate the type of selection: line, character, or block.
+     */
+    if (clip_data_format == CF_VIMCLIP)
+    {
+	switch (clip_data_type)
+	{
+	    default:
+	    case MLINE:	    clip_sel_type = "L";	break;
+	    case MCHAR:	    clip_sel_type = "C";	break;
+#ifdef FEAT_VISUAL
+	    case MBLOCK:    clip_sel_type = "B";	break;
+#endif
+	}
+
+	movedata(
+		_my_ds(), (unsigned)clip_sel_type,
+					    /* source: normal memory address */
+		protected_mode_selector, 0, /* target: DOS ad (via selector) */
+		1);			    /* how many bytes to copy */
+
+	protected_mode_offset += STRLEN(clip_sel_type);	/* allow for marker */
+    }
+
+    movedata(
+	_my_ds(), (unsigned)clip_data,	/* source: normal memory address */
+	protected_mode_selector,	/* target: DOS address (via selector) */
+	protected_mode_offset,		/* non-zero, if using clip_sel_type */
+	clip_data_size);		/* how many bytes to copy */
+
+    /* Send data from the DOS transfer buffer to the Windows clipboard.
+     * int 02xf, AX = 0x1703 sends SI:CX bytes of data from the buffer
+     * at ES:BX, to the clipboard.
+     */
+    dpmi_regs.x.ax = 0x1703;			/* send clipboard data */
+    dpmi_regs.x.dx = clip_data_format;		/* flag: format of the data */
+    dpmi_regs.x.si = ((total_size >> 16)
+	    & 0x0000ffffL);			/* hi word of data size */
+    dpmi_regs.x.cx = (total_size & 0x0000ffffL);
+						/* lo word of data size */
+    dpmi_regs.x.es = real_mode_segment_address;	/* buffer address: segment */
+    dpmi_regs.x.bx = 0;				/* buffer address: offset */
+    if (__dpmi_int(0x2f, &dpmi_regs) == -1)
+    {
+	/* real-mode interrupt failed. */
+	FreeDOSMemory(protected_mode_selector);   /* clean up DOS memory */
+	return FALSE;				  /* early exit */
+    }
+
+    /* Free the DOS buffer and release the DPMI prot-mode selector. */
+    FreeDOSMemory(protected_mode_selector);	  /* clean up DOS memory */
+
+    return TRUE;	/* TRUE --> data successfully sent to clipboard */
+}
+
+#endif	/* FEAT_CLIPBOARD */
+#endif /* DJGPP */
+
+/*
+ * End of MS-DOS only code
+ */
+#endif /* WIN16 */
+
+/* common MS-DOS and Win16 code follows */
+
+    static int
+vim_chmod(char_u *name)
+{
+    char_u	*p;
+    int		f;
+    int		c = 0;
+
+    /* chmod() can't handle a file name with a trailing slash, remove it.
+     * But don't remove it for "/" or "c:/". */
+    p = name + STRLEN(name);
+    if (p > name)
+	--p;
+    if (p > name && (*p == '\\' || *p == '/') && p[-1] != ':')
+    {
+	c = *p;				/* remove trailing (back)slash */
+	*p = NUL;
+    }
+    else
+	p = NULL;
+#if defined(__BORLANDC__) && (__BORLANDC__ > 0x410)
+    /* this also sets the archive bit, supported by Borland C 4.0 and later,
+     * where __BORLANDC__ is 0x450 (3.1 is 0x410) */
+    f = _rtl_chmod((char *)name, 0, 0);
+#else
+    f = _chmod((char *)name, 0, 0);
+#endif
+    if (p != NULL)
+	*p = c;				/* put back (back)slash */
+    return f;
+}
+
+/*
+ * get file permissions for 'name'
+ * Returns -1 for error.
+ * Returns FA_attributes defined in dos.h
+ */
+    long
+mch_getperm(char_u *name)
+{
+    return (long)vim_chmod(name);	/* get file mode */
+}
+
+/*
+ * set file permission for 'name' to 'perm'
+ *
+ * return FAIL for failure, OK otherwise
+ */
+    int
+mch_setperm(
+    char_u	*name,
+    long	perm)
+{
+    perm |= FA_ARCH;	    /* file has changed, set archive bit */
+#if defined(__BORLANDC__) && (__BORLANDC__ > 0x410)
+    return (_rtl_chmod((char *)name, 1, (int)perm) == -1 ? FAIL : OK);
+#else
+    return (_chmod((char *)name, 1, (int)perm) == -1 ? FAIL : OK);
+#endif
+}
+
+/*
+ * Set hidden flag for "name".
+ */
+    void
+mch_hide(char_u *name)
+{
+    /* DOS 6.2 share.exe causes "seek error on file write" errors when making
+     * the swap file hidden.  Thus don't do it. */
+}
+
+/*
+ * return TRUE if "name" is a directory
+ * return FALSE if "name" is not a directory
+ * return FALSE for error
+ *
+ * beware of a trailing (back)slash
+ */
+    int
+mch_isdir(char_u *name)
+{
+    int		f;
+
+    f = vim_chmod(name);
+    if (f == -1)
+	return FALSE;		    /* file does not exist at all */
+    if ((f & FA_DIREC) == 0)
+	return FALSE;		    /* not a directory */
+    return TRUE;
+}
+
+#if defined(FEAT_EVAL) || defined(PROTO)
+/*
+ * Return 1 if "name" can be executed, 0 if not.
+ * Return -1 if unknown.
+ */
+    int
+mch_can_exe(name)
+    char_u	*name;
+{
+    return (searchpath(name) != NULL);
+}
+#endif
+
+/*
+ * Check what "name" is:
+ * NODE_NORMAL: file or directory (or doesn't exist)
+ * NODE_WRITABLE: writable device, socket, fifo, etc.
+ * NODE_OTHER: non-writable things
+ */
+    int
+mch_nodetype(char_u *name)
+{
+    if (STRICMP(name, "AUX") == 0
+	    || STRICMP(name, "CON") == 0
+	    || STRICMP(name, "CLOCK$") == 0
+	    || STRICMP(name, "NUL") == 0
+	    || STRICMP(name, "PRN") == 0
+	    || ((STRNICMP(name, "COM", 3) == 0
+		    || STRNICMP(name, "LPT", 3) == 0)
+		&& VIM_ISDIGIT(name[3])
+		&& name[4] == NUL))
+	return NODE_WRITABLE;
+    /* TODO: NODE_OTHER? */
+    return NODE_NORMAL;
+}
+
+/*
+ * Get name of current directory into buffer 'buf' of length 'len' bytes.
+ * Return OK for success, FAIL for failure.
+ */
+    int
+mch_dirname(
+    char_u	*buf,
+    int		len)
+{
+#ifdef DJGPP
+    if (getcwd((char *)buf, len) == NULL)
+	return FAIL;
+    /* turn the '/'s returned by DJGPP into '\'s */
+    slash_adjust(buf);
+    return OK;
+#else
+    return (getcwd((char *)buf, len) != NULL ? OK : FAIL);
+#endif
+}
+
+/*
+ * this version of remove is not scared by a readonly (backup) file
+ *
+ * returns -1 on error, 0 otherwise (just like remove())
+ */
+    int
+mch_remove(char_u *name)
+{
+    (void)mch_setperm(name, 0);    /* default permissions */
+    return unlink((char *)name);
+}
+
+/*
+ * Special version of getenv(): Use uppercase name.
+ */
+    char_u *
+mch_getenv(char_u *name)
+{
+    int		i;
+#define MAXENVLEN 50
+    char_u	var_copy[MAXENVLEN + 1];
+    char_u	*p;
+    char_u	*res;
+
+    /*
+     * Take a copy of the argument, and force it to upper case before passing
+     * to getenv().  On DOS systems, getenv() doesn't like lower-case argument
+     * (unlike Win32 et al.)  If the name is too long to fit in var_copy[]
+     * allocate memory.
+     */
+    if ((i = STRLEN(name)) > MAXENVLEN)
+	p = alloc(i + 1);
+    else
+	p = var_copy;
+    if (p == NULL)
+	p = name;   /* out of memory, fall back to unmodified name */
+    else
+    {
+	for (i = 0; name[i] != NUL; ++i)
+	    p[i] = toupper(name[i]);
+	p[i] = NUL;
+    }
+
+    res = (char_u *)getenv((char *)p);
+
+    if (p != var_copy && p != name)
+	vim_free(p);
+
+    return res;
+}
+
+/*
+ * Insert user name in s[len].
+ */
+    int
+mch_get_user_name(
+    char_u	*s,
+    int		len)
+{
+    *s = NUL;
+    return FAIL;
+}
+
+/*
+ * Insert host name is s[len].
+ */
+    void
+mch_get_host_name(
+    char_u	*s,
+    int		len)
+{
+#ifdef DJGPP
+    STRNCPY(s, "PC (32 bits Vim)", len);
+#else
+    STRNCPY(s, "PC (16 bits Vim)", len);
+#endif
+    s[len - 1] = NUL;	/* make sure it's terminated */
+}