Snapshot 44

[MacVim.git] / src / os_msdos.c

/* 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 "vimio.h"
#include "vim.h"

#include <conio.h>

/*
 * 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 coordinate */
static int mouse_y = -1;                /* mouse y coordinate */
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 when 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)
{
    long        starttime = 0;

    if (msec != 0)
        starttime = biostime(0, 0L);

    for (;;)
    {
#ifdef FEAT_MOUSE
        long            clicktime;
        static int      old_status = 0;
        union REGS      regs;
        int             x, y;

        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 */

    /*
     * 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
            return 0;
        }
    }
    else    /* time == -1 */
    {
        /*
         * If there is no character available within 2 seconds (default)
         * write the autoscript file to disk.  Or cause the CursorHold event
         * to be triggered.
         */
        if (WaitForChar(p_ut) == 0)
        {
#ifdef FEAT_AUTOCMD
            if (trigger_cursorhold() && maxlen >= 3)
            {
                buf[0] = K_SPECIAL;
                buf[1] = KS_EXTRA;
                buf[2] = (int)KE_CURSORHOLD;
                return 3;
            }
#endif
            before_blocking();
        }
    }
    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 */
    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 */
    {
        vim_strncpy(buf, fname, len - 1);
        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 */
        vim_strncpy(buf, fullpath, len - 1);
        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)
                            STRMOVE(tail + 1 + added, tail + 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 = '/';
            mb_ptr_adv(p);
        }
    else
#endif
    while (*p)
    {
        if (*p == psepcN)
            *p = psepc;
        mb_ptr_adv(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; mb_ptr_adv(p))
    {
        if (vim_strchr((char_u *)"?*[", *p) != NULL
                || (*p == '~' && p[1] != NUL))
            return TRUE;
    }
    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; mb_ptr_adv(p))
    {
        if (vim_strchr((char_u *)
#  ifdef VIM_BACKTICK
                                    "?*$[`"
#  else
                                    "?*$["
#  endif
                                                , *p) != NULL
                || (*p == '~' && p[1] != NUL))
            return TRUE;
    }
    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 buffer 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;
}

/*
 * Return 1 if "name" can be executed, 0 if not.
 * Return -1 if unknown.
 */
    int
mch_can_exe(name)
    char_u      *name;
{
    char        *p;

    p = searchpath(name);
    if (p == NULL || mch_isdir(p))
        return FALSE;
    return TRUE;
}

/*
 * 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
    vim_strncpy(s, "PC (32 bits Vim)", len - 1);
#else
    vim_strncpy(s, "PC (16 bits Vim)", len - 1);
#endif
}