vim: src/os_msdos.c comparison

comparison src/os_msdos.c @ 7:3fc0f57ecb91 v7.0001

updated for version 7.0001

author	vimboss
date	Sun, 13 Jun 2004 20:20:40 +0000
parents
children	4102fb4ea781

comparison

equal deleted inserted replaced

-:c2daee826b8f
+:3fc0f57ecb91
+/* 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 */
+}

Mercurial > vim

comparison src/os_msdos.c @ 7:3fc0f57ecb91 v7.0001