开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > 编辑器/阅读器 > 查看源码
os_win32.c
资源名称：vim53src.zip　[点击查看]
上传用户：gddssl
上传日期：2007-01-06
资源大小：1003k
文件大小：88k
源码类别：

编辑器/阅读器

开发平台：

DOS

os_win32.c：源码内容
  1. /* vi:set ts=8 sts=4 sw=4:
  2.  *
  3.  * VIM - Vi IMproved by Bram Moolenaar
  4.  *
  5.  * Do ":help uganda"  in Vim to read copying and usage conditions.
  6.  * Do ":help credits" in Vim to see a list of people who contributed.
  7.  */
  9. /*
  10.  * os_win32.c
  11.  *
  12.  * Used for both the console version and the Win32 GUI.  A lot of code is for
  13.  * the console version only, so there is a lot of "#ifndef USE_GUI_WIN32".
  14.  *
  15.  * Win32 (Windows NT and Windows 95) system-dependent routines.
  16.  * Portions lifted from the Win32 SDK samples, the MSDOS-dependent code,
  17.  * NetHack 3.1.3, GNU Emacs 19.30, and Vile 5.5.
  18.  *
  19.  * George V. Reilly <georgere@microsoft.com> wrote most of this.
  20.  * Roger Knobbe <rogerk@wonderware.com> did the initial port of Vim 3.0.
  21.  */
  23. #include <io.h>
  24. #include "vim.h"
  26. #ifdef HAVE_FCNTL_H
  27. # include <fcntl.h>
  28. #endif
  29. #include <sys/types.h>
  30. #include <errno.h>
  31. #include <signal.h>
  32. #include <limits.h>
  33. #include <process.h>
  35. #define STRICT
  36. #define WIN32_LEAN_AND_MEAN
  37. #include <windows.h>
  39. #undef chdir
  40. #ifdef __GNUC__
  41. #include <dirent.h>
  42. #else
  43. #include <direct.h>
  44. #endif
  47. /* Record all output and all keyboard & mouse input */
  48. /* #define MCH_WRITE_DUMP */
  50. #ifdef MCH_WRITE_DUMP
  51. FILE* fdDump = NULL;
  52. #endif
  55. /*
  56.  * When generating prototypes for Win32 on Unix, these lines make the syntax
  57.  * errors disappear.  They do not need to be correct.
  58.  */
  59. #ifdef PROTO
  60. # define HANDLE int
  61. # define SMALL_RECT int
  62. # define COORD int
  63. # define SHORT int
  64. # define WORD int
  65. # define DWORD int
  66. # define BOOL int
  67. # define LPSTR int
  68. # define KEY_EVENT_RECORD int
  69. # define MOUSE_EVENT_RECORD int
  70. # define WINAPI
  71. # define CONSOLE_CURSOR_INFO int
  72. # define LPCSTR char_u *
  73. # define WINBASEAPI
  74. #endif
  76. #ifndef USE_GUI_WIN32
  77. /* Undocumented API in kernel32.dll needed to work around dead key bug in
  78.  * console-mode applications in NT 4.0.  If you switch keyboard layouts
  79.  * in a console app to a layout that includes dead keys and then hit a
  80.  * dead key, a call to ToAscii will trash the stack.  My thanks to Ian James
  81.  * and Michael Dietrich for helping me figure out this workaround.
  82.  */
  84. /* WINBASEAPI BOOL WINAPI GetConsoleKeyboardLayoutNameA(LPSTR); */
  85. #if defined(__BORLANDC__) || defined(__GNUC__)
  86. typedef BOOL (*PFNGCKLN)(LPSTR);
  87. #else
  88. typedef WINBASEAPI BOOL (WINAPI *PFNGCKLN)(LPSTR);
  89. #endif
  90. PFNGCKLN    s_pfnGetConsoleKeyboardLayoutName = NULL;
  91. #endif
  93. #if defined(__GNUC__) && !defined(PROTO)
  94. int _stricoll(char *a, char *b)
  95. {
  96.     // the ANSI-ish correct way is to use strxfrm():
  97.     char a_buff[512], b_buff[512];  // file names, so this is enough on Win32
  98.     strxfrm(a_buff, a, 512);
  99.     strxfrm(b_buff, b, 512);
  100.     return strcoll(a_buff, b_buff);
  101. }
  103. char * _fullpath(char *buf, char *fname, int len)
  104. {
  105.     LPTSTR toss;
  107.    return (char *) GetFullPathName(fname, len, buf, &toss);
  108. }
  110. int _chdrive(int drive)
  111. {
  112.     char temp [3] = "-:";
  113.     temp[0] = drive + 'A' - 1;
  114.     return !SetCurrentDirectory(temp);
  115. }
  116. #else
  117. #ifdef __BORLANDC__
  118. // being a more ANSI compliant compiler, BorlandC doesn't define _stricoll:
  119. // but it does in BC 5.02!
  120. #if __BORLANDC__ < 0x502
  121. int _stricoll(char *a, char *b)
  122. {
  123. #if 1
  124.     // this is fast but not correct:
  125.     return stricmp(a,b);
  126. #else
  127.     // the ANSI-ish correct way is to use strxfrm():
  128.     char a_buff[512], b_buff[512];  // file names, so this is enough on Win32
  129.     strxfrm(a_buff, a, 512);
  130.     strxfrm(b_buff, b, 512);
  131.     return strcoll(a_buff, b_buff);
  132. #endif
  133. }
  134. #endif
  135. #endif
  136. #endif
  138. #ifndef USE_GUI_WIN32
  139. /* Win32 Console handles for input and output */
  140. static HANDLE g_hConIn = INVALID_HANDLE_VALUE;
  141. static HANDLE g_hSavOut = INVALID_HANDLE_VALUE;
  142. static HANDLE g_hCurOut = INVALID_HANDLE_VALUE;
  143. static HANDLE g_hConOut = INVALID_HANDLE_VALUE;
  145. /* Win32 Screen buffer,coordinate,console I/O information */
  146. static SMALL_RECT g_srScrollRegion;
  147. static COORD   g_coord;  /* 0-based, but external coords are 1-based */
  149. /* The attribute of the screen when the editor was started */
  150. static WORD  g_attrDefault = 7;  /* lightgray text on black background */
  151. static WORD  g_attrCurrent;
  153. static int g_fCBrkPressed = FALSE;  /* set by ctrl-break interrupt */
  154. static int g_fCtrlCPressed = FALSE; /* set when ctrl-C or ctrl-break detected */
  155. static char_u g_chPending = NUL;
  157. static void termcap_mode_start(void);
  158. static void termcap_mode_end(void);
  159. static void clear_chars(COORD coord, DWORD n);
  160. static void clear_screen(void);
  161. static void clear_to_end_of_display(void);
  162. static void clear_to_end_of_line(void);
  163. static void scroll(unsigned cLines);
  164. static void set_scroll_region(unsigned left, unsigned top,
  165.       unsigned right, unsigned bottom);
  166. static void insert_lines(unsigned cLines);
  167. static void delete_lines(unsigned cLines);
  168. static void gotoxy(unsigned x, unsigned y);
  169. static void normvideo(void);
  170. static void textattr(WORD wAttr);
  171. static void textcolor(WORD wAttr);
  172. static void textbackground(WORD wAttr);
  173. static void standout(void);
  174. static void standend(void);
  175. static void visual_bell(void);
  176. static void cursor_visible(BOOL fVisible);
  177. static BOOL write_chars(LPCSTR pchBuf, DWORD cchToWrite, DWORD* pcchWritten);
  178. static char_u tgetch(void);
  179. static void create_conin(void);
  180. static void mch_set_cursor_shape(int thickness);
  181. static int s_cursor_visible = TRUE;
  182. static int did_create_conin = FALSE;
  183. #else
  184. static int s_dont_use_vimrun = TRUE;
  185. static char *vimrun_path = "vimrun ";
  186. #endif
  188. /*
  189.  * The old solution for opening a console is still there.
  190.  */
  191. //#define OLD_CONSOLE_STUFF
  193. #ifdef OLD_CONSOLE_STUFF
  194. static void mch_open_console(void);
  195. static void mch_close_console(int wait_key, DWORD ret);
  196. #endif
  197. struct growarray error_ga = {0, 0, 0, 0, NULL};
  199. #ifndef USE_GUI_WIN32
  200. static int suppress_winsize = 1; /* don't fiddle with console */
  201. #endif
  203. /* This symbol is not defined in older versions of the SDK or Visual C++ */
  205. #ifndef VER_PLATFORM_WIN32_WINDOWS
  206. # define VER_PLATFORM_WIN32_WINDOWS 1
  207. #endif
  209. static void PlatformId(void);
  210. static DWORD g_PlatformId;
  212. /*
  213.  * Set g_PlatformId to VER_PLATFORM_WIN32_NT (NT) or
  214.  * VER_PLATFORM_WIN32_WINDOWS (Win95).
  215.  */
  216.     static void
  217. PlatformId(void)
  218. {
  219.     static int done = FALSE;
  221.     if (!done)
  222.     {
  223. OSVERSIONINFO ovi;
  225. ovi.dwOSVersionInfoSize = sizeof(ovi);
  226. GetVersionEx(&ovi);
  228. g_PlatformId = ovi.dwPlatformId;
  229. done = TRUE;
  230.     }
  231. }
  233. /*
  234.  * Return TRUE when running on Windows 95.  Only to be used after
  235.  * mch_windinit().
  236.  */
  237.     int
  238. mch_windows95(void)
  239. {
  240.     return g_PlatformId == VER_PLATFORM_WIN32_WINDOWS;
  241. }
  243. #ifdef USE_GUI_WIN32
  244. /*
  245.  * Used to work around the "can't do synchronous spawn"
  246.  * problem on Win32s, without resorting to Universal Thunk.
  247.  */
  248. static int old_num_windows;
  249. static int num_windows;
  251.     static BOOL CALLBACK
  252. win32ssynch_cb(HWND hwnd, LPARAM lparam)
  253. {
  254.     num_windows++;
  255.     return TRUE;
  256. }
  257. #endif
  259. #ifndef USE_GUI_WIN32
  261. #define SHIFT  (SHIFT_PRESSED)
  262. #define CTRL   (RIGHT_CTRL_PRESSED | LEFT_CTRL_PRESSED)
  263. #define ALT    (RIGHT_ALT_PRESSED  | LEFT_ALT_PRESSED)
  264. #define ALT_GR (RIGHT_ALT_PRESSED  | LEFT_CTRL_PRESSED)
  267. /* When uChar.AsciiChar is 0, then we need to look at wVirtualKeyCode.
  268.  * We map function keys to their ANSI terminal equivalents, as produced
  269.  * by ANSI.SYS, for compatibility with the MS-DOS version of Vim.  Any
  270.  * ANSI key with a value >= '300' is nonstandard, but provided anyway
  271.  * so that the user can have access to all SHIFT-, CTRL-, and ALT-
  272.  * combinations of function/arrow/etc keys.
  273.  */
  275. const static struct
  276. {
  277.     WORD    wVirtKey;
  278.     BOOL    fAnsiKey;
  279.     int     chAlone;
  280.     int     chShift;
  281.     int     chCtrl;
  282.     int     chAlt;
  283. } VirtKeyMap[] =
  284. {
  286. /*    Key ANSI alone shift ctrl     alt */
  287.     { VK_ESCAPE,FALSE, ESC, ESC, ESC,     ESC,    },
  289.     { VK_F1, TRUE, ';', 'T', '^',     'h', },
  290.     { VK_F2, TRUE, '<', 'U', '_',     'i', },
  291.     { VK_F3, TRUE, '=', 'V', '`',     'j', },
  292.     { VK_F4, TRUE, '>', 'W', 'a',     'k', },
  293.     { VK_F5, TRUE, '?', 'X', 'b',     'l', },
  294.     { VK_F6, TRUE, '@', 'Y', 'c',     'm', },
  295.     { VK_F7, TRUE, 'A', 'Z', 'd',     'n', },
  296.     { VK_F8, TRUE, 'B', '[', 'e',     'o', },
  297.     { VK_F9, TRUE, 'C', '\', 'f',     'p', },
  298.     { VK_F10, TRUE, 'D', ']', 'g',     'q', },
  299.     { VK_F11, TRUE, '205', '207', '211',     '213', },
  300.     { VK_F12, TRUE, '206', '210', '212',     '214', },
  302.     { VK_HOME, TRUE, 'G', '302', 'w',     '303', },
  303.     { VK_UP, TRUE, 'H', '304', '305',     '306', },
  304.     { VK_PRIOR, TRUE, 'I', '307', '204',     '310', }, /*PgUp*/
  305.     { VK_LEFT, TRUE, 'K', '311', 's',     '312', },
  306.     { VK_RIGHT, TRUE, 'M', '313', 't',     '314', },
  307.     { VK_END, TRUE, 'O', '315', 'u',     '316', },
  308.     { VK_DOWN, TRUE, 'P', '317', '320',     '321', },
  309.     { VK_NEXT, TRUE, 'Q', '322', 'v',     '323', }, /*PgDn*/
  310.     { VK_INSERT,TRUE, 'R', '324', '325',     '326', },
  311.     { VK_DELETE,TRUE, 'S', '327', '330',     '331', },
  313.     { VK_SNAPSHOT,TRUE, 0, 0, 0,     'r', }, /*PrtScrn*/
  315.     /* Most people don't have F13-F20, but what the hell... */
  316.     { VK_F13, TRUE, '332', '333', '334',     '335', },
  317.     { VK_F14, TRUE, '336', '337', '340',     '341', },
  318.     { VK_F15, TRUE, '342', '343', '344',     '345', },
  319.     { VK_F16, TRUE, '346', '347', '350',     '351', },
  320.     { VK_F17, TRUE, '352', '353', '354',     '355', },
  321.     { VK_F18, TRUE, '356', '357', '360',     '361', },
  322.     { VK_F19, TRUE, '362', '363', '364',     '365', },
  323.     { VK_F20, TRUE, '366', '367', '370',     '371', },
  324. };
  327. // The ToAscii bug destroys several registers. Need to turn off optimization
  328. // or the GetConsoleKeyboardLayoutName hack will fail in non-debug versions
  330. #pragma optimize("", off)
  333. /* The return code indicates key code size. */
  334.     static int
  335. win32_kbd_patch_key(
  336.     KEY_EVENT_RECORD* pker)
  337. {
  338.     static int s_iIsDead = 0;
  339.     static WORD awAnsiCode[2];
  340.     UINT uMods = pker->dwControlKeyState;
  341.     BYTE abKeystate[256];
  343.     if (s_iIsDead == 2)
  344.     {
  345. #ifdef __GNUC__
  346. pker->AsciiChar = (CHAR) awAnsiCode[1];
  347. #else
  348. pker->uChar.AsciiChar = (CHAR) awAnsiCode[1];
  349. #endif
  350. s_iIsDead = 0;
  351. return 1;
  352.     }
  354. #ifdef __GNUC__
  355.     if (pker->AsciiChar != 0)
  356. #else
  357.     if (pker->uChar.AsciiChar != 0)
  358. #endif
  359. return 1;
  361.     memset(abKeystate, 0, sizeof (abKeystate));
  363.     // Should only be non-NULL on NT 4.0
  364.     if (s_pfnGetConsoleKeyboardLayoutName != NULL)
  365.     {
  366. CHAR szKLID[KL_NAMELENGTH];
  368. if (s_pfnGetConsoleKeyboardLayoutName(szKLID))
  369.     (void)LoadKeyboardLayout(szKLID, KLF_ACTIVATE);
  370.     }
  372.     /* Clear any pending dead keys */
  373.     ToAscii(VK_SPACE, MapVirtualKey(VK_SPACE, 0), abKeystate, awAnsiCode, 0);
  375.     if (uMods & SHIFT_PRESSED)
  376. abKeystate[VK_SHIFT] = 0x80;
  377.     if (uMods & CAPSLOCK_ON)
  378. abKeystate[VK_CAPITAL] = 1;
  380.     if ((uMods & ALT_GR) == ALT_GR)
  381.     {
  382. abKeystate[VK_CONTROL] = abKeystate[VK_LCONTROL] =
  383.     abKeystate[VK_MENU] = abKeystate[VK_RMENU] = 0x80;
  384.     }
  386.     s_iIsDead = ToAscii(pker->wVirtualKeyCode, pker->wVirtualScanCode,
  387. abKeystate, awAnsiCode, 0);
  389.     if (s_iIsDead > 0)
  390. #ifdef __GNUC__
  391. pker->AsciiChar = (CHAR) awAnsiCode[0];
  392. #else
  393. pker->uChar.AsciiChar = (CHAR) awAnsiCode[0];
  394. #endif
  396.     return s_iIsDead;
  397. }
  399. /* MUST switch optimization on again here, otherwise a call to
  400.  * decode_key_event() may crash (e.g. when hitting caps-lock) */
  401. #pragma optimize("", on)
  403. #if (_MSC_VER < 1100)
  404. /* MUST turn off global optimisation for this next function, or
  405.  * pressing ctrl-minus in insert mode crashes Vim when built with
  406.  * VC4.1. -- negri. */
  407. #pragma optimize("g", off)
  408. #endif
  410. static BOOL g_fJustGotFocus = FALSE;
  412. /*
  413.  * Decode a KEY_EVENT into one or two keystrokes
  414.  */
  415.     static BOOL
  416. decode_key_event(
  417.     KEY_EVENT_RECORD *pker,
  418.     char_u *pch,
  419.     char_u *pchPending,
  420.     BOOL fDoPost)
  421. {
  422.     int i;
  423.     const int nModifs = pker->dwControlKeyState & (SHIFT | ALT | CTRL);
  425.     *pch = *pchPending = NUL;
  426.     g_fJustGotFocus = FALSE;
  428.     /* ignore key up events */
  429.     if (!pker->bKeyDown)
  430. return FALSE;
  432.     /* ignore some keystrokes */
  433.     switch (pker->wVirtualKeyCode)
  434.     {
  435.     /* modifiers */
  436.     case VK_SHIFT:
  437.     case VK_CONTROL:
  438.     case VK_MENU:   /* Alt key */
  439. return FALSE;
  441.     default:
  442. break;
  443.     }
  445.     /* special cases */
  446.     if ((nModifs & CTRL) != 0 && (nModifs & ~CTRL) == 0
  447. #ifdef __GNUC__
  448.     && pker->AsciiChar == NUL)
  449. #else
  450.     && pker->uChar.AsciiChar == NUL)
  451. #endif
  452.     {
  453. /* Ctrl-6 is Ctrl-^ */
  454. if (pker->wVirtualKeyCode == '6')
  455. {
  456.     *pch = Ctrl('^');
  457.     return TRUE;
  458. }
  459. /* Ctrl-2 is Ctrl-@ */
  460. else if (pker->wVirtualKeyCode == '2')
  461. {
  462.     *pch = NUL;
  463.     return TRUE;
  464. }
  465.     }
  467.     /* Shift-TAB */
  468.     if (pker->wVirtualKeyCode == VK_TAB && (nModifs & SHIFT_PRESSED))
  469.     {
  470. *pch = K_NUL;
  471. *pchPending = '17';
  472. return TRUE;
  473.     }
  475.     for (i = sizeof(VirtKeyMap) / sizeof(VirtKeyMap[0]);  --i >= 0;  )
  476.     {
  477. if (VirtKeyMap[i].wVirtKey == pker->wVirtualKeyCode)
  478. {
  479.     if (nModifs == 0)
  480. *pch = VirtKeyMap[i].chAlone;
  481.     else if ((nModifs & SHIFT) != 0 && (nModifs & ~SHIFT) == 0)
  482. *pch = VirtKeyMap[i].chShift;
  483.     else if ((nModifs & CTRL) != 0 && (nModifs & ~CTRL) == 0)
  484. *pch = VirtKeyMap[i].chCtrl;
  485.     else if ((nModifs & ALT) != 0 && (nModifs & ~ALT) == 0)
  486. *pch = VirtKeyMap[i].chAlt;
  488.     if (*pch != 0)
  489.     {
  490. if (VirtKeyMap[i].fAnsiKey)
  491. {
  492.     *pchPending = *pch;
  493.     *pch = K_NUL;
  494. }
  496. return TRUE;
  497.     }
  498. }
  499.     }
  501.     i = win32_kbd_patch_key(pker);
  503.     if (i < 0)
  504. *pch = NUL;
  505.     else
  506. #ifdef __GNUC__
  507. *pch = (i > 0) ?  pker->AsciiChar  :  NUL;
  508. #else
  509. *pch = (i > 0) ?  pker->uChar.AsciiChar  :  NUL;
  510. #endif
  512.     return (*pch != NUL);
  513. }
  514. #pragma optimize("", on)
  515. #endif /* USE_GUI_WIN32 */
  518. #ifdef USE_MOUSE
  520. /*
  521.  * For the GUI the mouse handling is in gui_w32.c.
  522.  */
  523. # ifdef USE_GUI_WIN32
  524.     void
  525. mch_setmouse(
  526.     int on)
  527. {
  528. }
  529. # else
  530. static int g_fMouseAvail = FALSE;   /* mouse present */
  531. static int g_fMouseActive = FALSE;  /* mouse enabled */
  532. static int g_nMouseClick = -1;     /* mouse status */
  533. static int g_xMouse;     /* mouse x coordinate */
  534. static int g_yMouse;     /* mouse y coordinate */
  536. /*
  537.  * Enable or disable mouse input
  538.  */
  539.     void
  540. mch_setmouse(
  541.     int on)
  542. {
  543.     DWORD cmodein;
  545.     if (! g_fMouseAvail)
  546. return;
  548.     g_fMouseActive = on;
  549.     GetConsoleMode(g_hConIn, &cmodein);
  551.     if (g_fMouseActive)
  552. cmodein |= ENABLE_MOUSE_INPUT;
  553.     else
  554. cmodein &= ~ENABLE_MOUSE_INPUT;
  556.     SetConsoleMode(g_hConIn, cmodein);
  557. }
  560. /*
  561.  * Decode a MOUSE_EVENT.  If it's a valid event, return MOUSE_LEFT,
  562.  * MOUSE_MIDDLE, or MOUSE_RIGHT for a click; MOUSE_DRAG for a mouse
  563.  * move with a button held down; and MOUSE_RELEASE after a MOUSE_DRAG
  564.  * or a MOUSE_LEFT, _MIDDLE, or _RIGHT.  We encode the button type,
  565.  * the number of clicks, and the Shift/Ctrl/Alt modifiers in g_nMouseClick,
  566.  * and we return the mouse position in g_xMouse and g_yMouse.
  567.  *
  568.  * Every MOUSE_LEFT, _MIDDLE, or _RIGHT will be followed by zero or more
  569.  * MOUSE_DRAGs and one MOUSE_RELEASE.  MOUSE_RELEASE will be followed only
  570.  * by MOUSE_LEFT, _MIDDLE, or _RIGHT.
  571.  *
  572.  * For multiple clicks, we send, say, MOUSE_LEFT/1 click, MOUSE_RELEASE,
  573.  * MOUSE_LEFT/2 clicks, MOUSE_RELEASE, MOUSE_LEFT/3 clicks, MOUSE_RELEASE, ....
  574.  *
  575.  * Windows will send us MOUSE_MOVED notifications whenever the mouse
  576.  * moves, even if it stays within the same character cell.  We ignore
  577.  * all MOUSE_MOVED messages if the position hasn't really changed, and
  578.  * we ignore all MOUSE_MOVED messages where no button is held down (i.e.,
  579.  * we're only interested in MOUSE_DRAG).
  580.  *
  581.  * All of this is complicated by the code that fakes MOUSE_MIDDLE on
  582.  * 2-button mouses by pressing the left & right buttons simultaneously.
  583.  * In practice, it's almost impossible to click both at the same time,
  584.  * so we need to delay a little.  Also, we tend not to get MOUSE_RELEASE
  585.  * in such cases, if the user is clicking quickly.
  586.  */
  587.     static BOOL
  588. decode_mouse_event(
  589.     MOUSE_EVENT_RECORD* pmer)
  590. {
  591.     static int s_nOldButton = -1;
  592.     static int s_nOldMouseClick = -1;
  593.     static int s_xOldMouse = -1;
  594.     static int s_yOldMouse = -1;
  595.     static linenr_t s_old_topline = 0;
  596.     static int s_cClicks = 1;
  597.     static BOOL s_fReleased = TRUE;
  598.     static s_dwLastClickTime = 0;
  599.     static BOOL s_fNextIsMiddle = FALSE;
  601.     const DWORD LEFT = FROM_LEFT_1ST_BUTTON_PRESSED;
  602.     const DWORD MIDDLE = FROM_LEFT_2ND_BUTTON_PRESSED;
  603.     const DWORD RIGHT = RIGHTMOST_BUTTON_PRESSED;
  604.     const DWORD LEFT_RIGHT = LEFT | RIGHT;
  606.     int nButton;
  608.     if (! g_fMouseAvail || !g_fMouseActive)
  609.     {
  610. g_nMouseClick = -1;
  611. return FALSE;
  612.     }
  614.     /* get a spurious MOUSE_EVENT immediately after receiving focus; ignore */
  615.     if (g_fJustGotFocus)
  616.     {
  617. g_fJustGotFocus = FALSE;
  618. return FALSE;
  619.     }
  621.     /* unprocessed mouse click? */
  622.     if (g_nMouseClick != -1)
  623. return TRUE;
  625.     nButton = -1;
  626.     g_xMouse = pmer->dwMousePosition.X;
  627.     g_yMouse = pmer->dwMousePosition.Y;
  629.     if (pmer->dwEventFlags == MOUSE_MOVED)
  630.     {
  631. /* ignore MOUSE_MOVED events if (x, y) hasn't changed. (We get these
  632.  * events even when the mouse moves only within a char cell.) */
  633. if (s_xOldMouse == g_xMouse && s_yOldMouse == g_yMouse)
  634.     return FALSE;
  635.     }
  637.     /* If no buttons are pressed... */
  638.     if (pmer->dwButtonState == 0)
  639.     {
  640. /* If the last thing returned was MOUSE_RELEASE, ignore this */
  641. if (s_fReleased)
  642.     return FALSE;
  644. nButton = MOUSE_RELEASE;
  645. s_fReleased = TRUE;
  646.     }
  647.     else    /* one or more buttons pressed */
  648.     {
  649. const int cButtons = GetSystemMetrics(SM_CMOUSEBUTTONS);
  651. /* on a 2-button mouse, hold down left and right buttons
  652.  * simultaneously to get MIDDLE. */
  654. if (cButtons == 2 && s_nOldButton != MOUSE_DRAG)
  655. {
  656.     DWORD dwLR = (pmer->dwButtonState & LEFT_RIGHT);
  658.     /* if either left or right button only is pressed, see if the
  659.      * the next mouse event has both of them pressed */
  660.     if (dwLR == LEFT || dwLR == RIGHT)
  661.     {
  662. for (;;)
  663. {
  664.     /* wait a short time for next input event */
  665.     if (WaitForSingleObject(g_hConIn, p_mouset / 3)
  666. != WAIT_OBJECT_0)
  667. break;
  668.     else
  669.     {
  670. DWORD cRecords = 0;
  671. INPUT_RECORD ir;
  672. MOUSE_EVENT_RECORD* pmer2 = &ir.Event.MouseEvent;
  674. PeekConsoleInput(g_hConIn, &ir, 1, &cRecords);
  676. if (cRecords == 0 || ir.EventType != MOUSE_EVENT
  677. || !(pmer2->dwButtonState & LEFT_RIGHT))
  678.     break;
  679. else
  680. {
  681.     if (pmer2->dwEventFlags != MOUSE_MOVED)
  682.     {
  683. ReadConsoleInput(g_hConIn, &ir, 1, &cRecords);
  685. return decode_mouse_event(pmer2);
  686.     }
  687.     else if (s_xOldMouse == pmer2->dwMousePosition.X &&
  688.      s_yOldMouse == pmer2->dwMousePosition.Y)
  689.     {
  690. /* throw away spurious mouse move */
  691. ReadConsoleInput(g_hConIn, &ir, 1, &cRecords);
  693. /* are there any more mouse events in queue? */
  694. PeekConsoleInput(g_hConIn, &ir, 1, &cRecords);
  696. if (cRecords==0 || ir.EventType != MOUSE_EVENT)
  697.     break;
  698.     }
  699.     else
  700. break;
  701. }
  702.     }
  703. }
  704.     }
  705. }
  707. if (s_fNextIsMiddle)
  708. {
  709.     nButton = (pmer->dwEventFlags == MOUSE_MOVED)
  710. ? MOUSE_DRAG : MOUSE_MIDDLE;
  711.     s_fNextIsMiddle = FALSE;
  712. }
  713. else if (cButtons == 2 &&
  714.     ((pmer->dwButtonState & LEFT_RIGHT) == LEFT_RIGHT))
  715. {
  716.     nButton = MOUSE_MIDDLE;
  718.     if (! s_fReleased && pmer->dwEventFlags != MOUSE_MOVED)
  719.     {
  720. s_fNextIsMiddle = TRUE;
  721. nButton = MOUSE_RELEASE;
  722.     }
  723. }
  724. else if ((pmer->dwButtonState & LEFT) == LEFT)
  725.     nButton = MOUSE_LEFT;
  726. else if ((pmer->dwButtonState & MIDDLE) == MIDDLE)
  727.     nButton = MOUSE_MIDDLE;
  728. else if ((pmer->dwButtonState & RIGHT) == RIGHT)
  729.     nButton = MOUSE_RIGHT;
  731. if (! s_fReleased && ! s_fNextIsMiddle
  732. && nButton != s_nOldButton && s_nOldButton != MOUSE_DRAG)
  733.     return FALSE;
  735. s_fReleased = s_fNextIsMiddle;
  736.     }
  738.     if (pmer->dwEventFlags == 0 || pmer->dwEventFlags == DOUBLE_CLICK)
  739.     {
  740. /* button pressed or released, without mouse moving */
  741. if (nButton != -1 && nButton != MOUSE_RELEASE)
  742. {
  743.     DWORD dwCurrentTime = GetTickCount();
  745.     if (s_xOldMouse != g_xMouse
  746.     || s_yOldMouse != g_yMouse
  747.     || s_nOldButton != nButton
  748.     || s_old_topline != curwin->w_topline
  749.     || (int)(dwCurrentTime - s_dwLastClickTime) > p_mouset)
  750.     {
  751. s_cClicks = 1;
  752.     }
  753.     else if (++s_cClicks > 4)
  754.     {
  755. s_cClicks = 1;
  756.     }
  758.     s_dwLastClickTime = dwCurrentTime;
  759. }
  760.     }
  761.     else if (pmer->dwEventFlags == MOUSE_MOVED)
  762.     {
  763. if (nButton != -1 && nButton != MOUSE_RELEASE)
  764.     nButton = MOUSE_DRAG;
  766. s_cClicks = 1;
  767.     }
  769.     if (nButton == -1)
  770. return FALSE;
  772.     if (nButton != MOUSE_RELEASE)
  773. s_nOldButton = nButton;
  775.     g_nMouseClick = nButton;
  777.     if (pmer->dwControlKeyState & SHIFT_PRESSED)
  778. g_nMouseClick |= MOUSE_SHIFT;
  779.     if (pmer->dwControlKeyState & (RIGHT_CTRL_PRESSED | LEFT_CTRL_PRESSED))
  780. g_nMouseClick |= MOUSE_CTRL;
  781.     if (pmer->dwControlKeyState & (RIGHT_ALT_PRESSED  | LEFT_ALT_PRESSED))
  782. g_nMouseClick |= MOUSE_ALT;
  784.     /* only pass on interesting (i.e., different) mouse events */
  785.     if (s_xOldMouse == g_xMouse
  786.     && s_yOldMouse == g_yMouse
  787.     && s_nOldMouseClick == g_nMouseClick)
  788.     {
  789. g_nMouseClick = -1;
  790. return FALSE;
  791.     }
  793.     g_nMouseClick |= 0x20;
  795.     s_xOldMouse = g_xMouse;
  796.     s_yOldMouse = g_yMouse;
  797.     s_old_topline = curwin->w_topline;
  798.     s_nOldMouseClick = g_nMouseClick;
  800.     if (nButton != MOUSE_DRAG && nButton != MOUSE_RELEASE)
  801. SET_NUM_MOUSE_CLICKS(g_nMouseClick, s_cClicks);
  803.     return TRUE;
  804. }
  806. # endif /* USE_GUI_WIN32 */
  807. #endif /* USE_MOUSE */
  810. #ifndef USE_GUI_WIN32     /* this isn't used for the GUI */
  811. /*
  812.  * Set the shape of the cursor.
  813.  * 'thickness' can be from 1 (thin) to 99 (block)
  814.  */
  815.     static void
  816. mch_set_cursor_shape(int thickness)
  817. {
  818.     CONSOLE_CURSOR_INFO ConsoleCursorInfo;
  819.     ConsoleCursorInfo.dwSize = thickness;
  820.     ConsoleCursorInfo.bVisible = s_cursor_visible;
  822.     SetConsoleCursorInfo(g_hCurOut, &ConsoleCursorInfo);
  823. }
  825.     void
  826. mch_update_cursor(void)
  827. {
  828.     int idx;
  829.     int thickness;
  831.     /*
  832.      * How the cursor is drawn depends on the current mode.
  833.      */
  834.     idx = get_cursor_idx();
  836.     if (cursor_table[idx].shape == SHAPE_BLOCK)
  837. thickness = 99; /* 100 doesn't work on W95 */
  838.     else
  839. thickness = cursor_table[idx].percentage;
  840.     mch_set_cursor_shape(thickness);
  841. }
  843. /*
  844.  * Wait until console input from keyboard or mouse is available,
  845.  * or the time is up.
  846.  * Return TRUE if something is available FALSE if not.
  847.  */
  848.     static int
  849. WaitForChar(long msec)
  850. {
  851.     DWORD     dwNow, dwEndTime;
  852.     INPUT_RECORD    ir;
  853.     DWORD     cRecords;
  854.     char_u     ch, ch2;
  857.     if (msec > 0)
  858. dwEndTime = GetTickCount() + msec;
  860.     /* We need to loop until the end of the time period, because
  861.      * we might get multiple unusable mouse events in that time.
  862.      */
  863.     for (;;)
  864.     {
  865. if (g_chPending != NUL
  866. #ifdef USE_MOUSE
  867. || g_nMouseClick != -1
  868. #endif
  869.     )
  870.     return TRUE;
  872. if (msec > 0)
  873. {
  874.     dwNow = GetTickCount();
  875.     if (dwNow >= dwEndTime)
  876. break;
  877.     if (WaitForSingleObject(g_hConIn, dwEndTime - dwNow)
  878.      != WAIT_OBJECT_0)
  879. continue;
  880. }
  882. cRecords = 0;
  883. PeekConsoleInput(g_hConIn, &ir, 1, &cRecords);
  885. if (cRecords > 0)
  886. {
  887. #ifdef MULTI_BYTE_IME
  888.     /* Windows IME sends two 'n's with only one 'ENTER'.
  889.        first, wVirtualKeyCode == 13. second, wVirtualKeyCode == 0 */
  890.     if (ir.EventType == KEY_EVENT && ir.Event.KeyEvent.bKeyDown)
  891.     {
  892. if (ir.Event.KeyEvent.uChar.UnicodeChar == 0
  893. && ir.Event.KeyEvent.wVirtualKeyCode == 13)
  894. {
  895.     ReadConsoleInput(g_hConIn, &ir, 1, &cRecords);
  896.     continue;
  897. }
  898. return decode_key_event(&ir.Event.KeyEvent, &ch, &ch2, FALSE);
  899.     }
  900. #else
  901.     if (ir.EventType == KEY_EVENT && ir.Event.KeyEvent.bKeyDown
  902.     && decode_key_event(&ir.Event.KeyEvent, &ch, &ch2, FALSE))
  903. return TRUE;
  904. #endif
  906.     ReadConsoleInput(g_hConIn, &ir, 1, &cRecords);
  907. #ifdef USE_CLIPBOARD
  908.     if (ir.EventType == FOCUS_EVENT)
  909. g_fJustGotFocus = ir.Event.FocusEvent.bSetFocus;
  910. #endif
  911.     else if (ir.EventType == WINDOW_BUFFER_SIZE_EVENT)
  912. set_winsize(Rows, Columns, FALSE);
  913. #ifdef USE_MOUSE
  914.     else if (ir.EventType == MOUSE_EVENT
  915.     && decode_mouse_event(&ir.Event.MouseEvent))
  916. return TRUE;
  917. #endif
  918. }
  919. else if (msec == 0)
  920.     break;
  921.     }
  923.     return FALSE;
  924. }
  926. /*
  927.  * Create the console input.  Used when reading stdin doesn't work.
  928.  */
  929.     static void
  930. create_conin(void)
  931. {
  932.     g_hConIn = CreateFile("CONIN$", GENERIC_READ|GENERIC_WRITE,
  933. FILE_SHARE_READ|FILE_SHARE_WRITE,
  934. (LPSECURITY_ATTRIBUTES) NULL,
  935. OPEN_EXISTING, (DWORD)NULL, (HANDLE)NULL);
  936.     did_create_conin = TRUE;
  937. }
  939. /*
  940.  * Get a keystroke or a mouse event
  941.  */
  942.     static char_u
  943. tgetch(void)
  944. {
  945.     char_u ch;
  947.     if (g_chPending != NUL)
  948.     {
  949. ch = g_chPending;
  950. g_chPending = NUL;
  951. return ch;
  952.     }
  954.     for ( ; ; )
  955.     {
  956. INPUT_RECORD ir;
  957. DWORD cRecords = 0;
  959. if (ReadConsoleInput(g_hConIn, &ir, 1, &cRecords) == 0)
  960. {
  961.     if (did_create_conin)
  962. read_error_exit();
  963.     create_conin();
  964.     continue;
  965. }
  967. if (ir.EventType == KEY_EVENT)
  968. {
  969.     if (decode_key_event(&ir.Event.KeyEvent, &ch, &g_chPending, TRUE))
  970. return ch;
  971. }
  972. #ifdef USE_CLIPBOARD
  973. else if (ir.EventType == FOCUS_EVENT)
  974. {
  975.     g_fJustGotFocus = ir.Event.FocusEvent.bSetFocus;
  976.     /* TRACE("tgetch: Focus %dn", g_fJustGotFocus); */
  977. }
  978. #endif
  979. else if (ir.EventType == WINDOW_BUFFER_SIZE_EVENT)
  980. {
  981.     set_winsize(Rows, Columns, FALSE);
  982. }
  983. #ifdef USE_MOUSE
  984. else if (ir.EventType == MOUSE_EVENT)
  985. {
  986.     if (decode_mouse_event(&ir.Event.MouseEvent))
  987. return 0;
  988. }
  989. #endif
  990.     }
  991. }
  992. #endif /* !USE_GUI_WIN32 */
  995. /*
  996.  * mch_inchar(): low-level input funcion.
  997.  * Get one or more characters from the keyboard or the mouse.
  998.  * If time == 0, do not wait for characters.
  999.  * If time == n, wait a short time for characters.
  1000.  * If time == -1, wait forever for characters.
  1001.  * Returns the number of characters read into buf.
  1002.  */
  1003.     int
  1004. mch_inchar(
  1005.     char_u *buf,
  1006.     int maxlen,
  1007.     long time)
  1008. {
  1009. #ifndef USE_GUI_WIN32     /* this isn't used for the GUI */
  1010.     int len = 0;
  1011.     int c;
  1013.     if (time >= 0)
  1014.     {
  1015. if (!WaitForChar(time))     /* no character available */
  1016.     return 0;
  1017.     }
  1018.     else    /* time == -1, wait forever */
  1019.     {
  1020. /* If there is no character available within 2 seconds (default),
  1021.  * write the autoscript file to disk */
  1022. if (!WaitForChar(p_ut))
  1023.     updatescript(0);
  1024.     }
  1026.     /*
  1027.      * Try to read as many characters as there are, until the buffer is full.
  1028.      */
  1030.     /* we will get at least one key. Get more if they are available. */
  1031.     g_fCBrkPressed = FALSE;
  1033. #ifdef MCH_WRITE_DUMP
  1034.     if (fdDump)
  1035. fputc('[', fdDump);
  1036. #endif
  1038.     while ((len == 0 || WaitForChar(0)) && len < maxlen)
  1039.     {
  1040. #ifdef USE_MOUSE
  1041. if (g_nMouseClick != -1 && maxlen - len >= 5)
  1042. {
  1043. # ifdef MCH_WRITE_DUMP
  1044.     if (fdDump)
  1045. fprintf(fdDump, "{%02x @ %d, %d}",
  1046. g_nMouseClick, g_xMouse, g_yMouse);
  1047. # endif
  1049.     len += 5;
  1050.     *buf++ = ESC + 128;
  1051.     *buf++ = 'M';
  1052.     *buf++ = g_nMouseClick;
  1053.     *buf++ = g_xMouse + '!';
  1054.     *buf++ = g_yMouse + '!';
  1055.     g_nMouseClick = -1;
  1057. }
  1058. else
  1059. #endif /* USE_MOUSE */
  1060. {
  1061.     if ((c = tgetch()) == Ctrl('C'))
  1062. g_fCBrkPressed = TRUE;
  1064. #ifdef USE_MOUSE
  1065.     if (g_nMouseClick == -1)
  1066. #endif
  1067.     {
  1068. *buf++ = c;
  1069. len++;
  1071. #ifdef MCH_WRITE_DUMP
  1072. if (fdDump)
  1073.     fputc(c, fdDump);
  1074. #endif
  1075.     }
  1076. }
  1077.     }
  1079. #ifdef MCH_WRITE_DUMP
  1080.     if (fdDump)
  1081.     {
  1082. fputs("]n", fdDump);
  1083. fflush(fdDump);
  1084.     }
  1085. #endif
  1087.     return len;
  1088. #else /* USE_GUI_WIN32 */
  1089.     return 0;
  1090. #endif /* USE_GUI_WIN32 */
  1091. }
  1093. #ifdef USE_GUI_WIN32
  1095. #include <shellapi.h> /* required for FindExecutable() */
  1097. /*
  1098.  * GUI version of mch_windinit().
  1099.  */
  1100.     void
  1101. mch_windinit()
  1102. {
  1103.     extern int _fmode;
  1105.     PlatformId();
  1107.     /* Specify window size.  Is there a place to get the default from? */
  1108.     Rows = 25;
  1109.     Columns = 80;
  1111.     _fmode = O_BINARY; /* we do our own CR-LF translation */
  1113.     /* Look for 'vimrun' */
  1114.     if (!gui_is_win32s())
  1115.     {
  1116. char_u vimrun_location[2 * _MAX_PATH + 2];
  1117. char_u widename[40];
  1119. /* First try in same directory as gvim.exe */
  1120. STRCPY(vimrun_location, exe_name);
  1121. STRCPY(gettail(vimrun_location), "vimrun.exe");
  1122. if (mch_getperm(vimrun_location) >= 0)
  1123. {
  1124.     STRCPY(gettail(vimrun_location), "vimrun ");
  1125.     vimrun_path = (char *)vim_strsave(vimrun_location);
  1126.     s_dont_use_vimrun = FALSE;
  1127. }
  1128. else
  1129. {
  1130.     /* There appears to be a bug in FindExecutableA() on Windows NT.
  1131.      * Use FindExecutableW() instead... */
  1132.     if (g_PlatformId == VER_PLATFORM_WIN32_NT)
  1133.     {
  1134. MultiByteToWideChar(CP_ACP, 0, (LPCTSTR)"vimrun.exe", -1,
  1135. (LPWSTR)widename, 20);
  1136. if (FindExecutableW((LPCWSTR)widename, (LPCWSTR)"",
  1137.     (LPWSTR)vimrun_location) > (HINSTANCE)32)
  1138.     s_dont_use_vimrun = FALSE;
  1139.     }
  1140.     else
  1141.     {
  1142. if (FindExecutableA((LPCTSTR)"vimrun.exe", (LPCTSTR)"",
  1143.     (LPTSTR)vimrun_location) > (HINSTANCE)32)
  1144.     s_dont_use_vimrun = FALSE;
  1145.     }
  1146. }
  1148. if (s_dont_use_vimrun)
  1149.     MessageBox(NULL,
  1150. "VIMRUN.EXE not found in your $PATH.n"
  1151. "External commands will not pause after completion.n"
  1152. "See  :help win32-vimrun  for more information.",
  1153. "Vim Warning",
  1154. MB_ICONWARNING);
  1155.     }
  1157. #ifdef USE_CLIPBOARD
  1158.     clip_init(TRUE);
  1160.     /*
  1161.      * Vim's own clipboard format recognises whether the text is char, line, or
  1162.      * rectangular block.  Only useful for copying between two Vims.
  1163.      */
  1164.     clipboard.format = RegisterClipboardFormat("VimClipboard");
  1165. #endif
  1166. }
  1168. /*
  1169.  * GUI version of mch_windexit().
  1170.  * Shut down and exit with status `r'
  1171.  * Careful: mch_windexit() may be called before mch_windinit()!
  1172.  */
  1173.     void
  1174. mch_windexit(
  1175.     int r)
  1176. {
  1177.     mch_display_error();
  1179.     ml_close_all(TRUE); /* remove all memfiles */
  1181. # ifdef HAVE_OLE
  1182.     UninitOLE();
  1183. # endif
  1185.     if (gui.in_use)
  1186. gui_exit(r);
  1187.     exit(r);
  1188. }
  1190. #else /* USE_GUI_WIN32 */
  1192. static char g_szOrigTitle[256];
  1193. static int  g_fWindInitCalled = FALSE;
  1194. static CONSOLE_CURSOR_INFO g_cci;
  1195. static DWORD g_cmodein = 0;
  1196. static DWORD g_cmodeout = 0;
  1198. /*
  1199.  * Because of a bug in the Windows 95 Console, we need to set the screen size
  1200.  * back when switching screens.
  1201.  */
  1202. static int g_nOldRows = 0;
  1203. static int g_nOldColumns = 0;
  1205. /*
  1206.  * non-GUI version of mch_windinit().
  1207.  */
  1208.     void
  1209. mch_windinit()
  1210. {
  1211.     CONSOLE_SCREEN_BUFFER_INFO csbi;
  1212.     extern int _fmode;
  1214.     PlatformId();
  1216.     _fmode = O_BINARY; /* we do our own CR-LF translation */
  1217.     out_flush();
  1219.     /* Obtain handles for the standard Console I/O devices */
  1220.     if (read_cmd_fd == 0)
  1221. g_hConIn =  GetStdHandle(STD_INPUT_HANDLE);
  1222.     else
  1223. create_conin();
  1224.     g_hSavOut = GetStdHandle(STD_OUTPUT_HANDLE);
  1225.     g_hCurOut = g_hSavOut;
  1227.     /* Get current text attributes */
  1228.     GetConsoleScreenBufferInfo(g_hSavOut, &csbi);
  1229.     g_attrCurrent = g_attrDefault = csbi.wAttributes;
  1230.     GetConsoleCursorInfo(g_hSavOut, &g_cci);
  1232.     /* set termcap codes to current text attributes */
  1233.     update_tcap(csbi.wAttributes);
  1235.     GetConsoleMode(g_hConIn,  &g_cmodein);
  1236.     GetConsoleMode(g_hSavOut, &g_cmodeout);
  1238.     GetConsoleTitle(g_szOrigTitle, sizeof(g_szOrigTitle));
  1239.     ui_get_winsize();
  1241.     g_nOldRows = Rows;
  1242.     g_nOldColumns = Columns;
  1244. #ifdef MCH_WRITE_DUMP
  1245.     fdDump = fopen("dump", "wt");
  1247.     if (fdDump)
  1248.     {
  1249. time_t t;
  1251. time(&t);
  1252. fputs(ctime(&t), fdDump);
  1253. fflush(fdDump);
  1254.     }
  1255. #endif
  1257.     g_fWindInitCalled = TRUE;
  1259. #ifdef USE_MOUSE
  1260.     g_fMouseAvail = GetSystemMetrics(SM_MOUSEPRESENT);
  1261. #endif
  1263. #ifdef USE_CLIPBOARD
  1264.     clip_init(TRUE);
  1266.     /*
  1267.      * Vim's own clipboard format recognises whether the text is char, line, or
  1268.      * rectangular block.  Only useful for copying between two Vims.
  1269.      */
  1270.     clipboard.format = RegisterClipboardFormat("VimClipboard");
  1271. #endif
  1273.     /* This will be NULL on anything but NT 4.0 */
  1274.     s_pfnGetConsoleKeyboardLayoutName =
  1275. (PFNGCKLN) GetProcAddress(GetModuleHandle("kernel32.dll"),
  1276.   "GetConsoleKeyboardLayoutNameA");
  1277.     /*
  1278.      * We don't really want to jump to our own screen yet; do that after
  1279.      * starttermcap(). This flashes the window, sorry about that, but
  1280.      * otherwise "vim -r" doesn't work.
  1281.      */
  1282.     g_hCurOut = g_hSavOut;
  1283.     SetConsoleActiveScreenBuffer(g_hCurOut);
  1284. }
  1287. /*
  1288.  * non-GUI version of mch_windexit().
  1289.  * Shut down and exit with status `r'
  1290.  * Careful: mch_windexit() may be called before mch_windinit()!
  1291.  */
  1292.     void
  1293. mch_windexit(
  1294.     int r)
  1295. {
  1296.     stoptermcap();
  1297.     out_char('r');
  1298.     out_char('n');
  1299.     out_flush();
  1301.     if (g_fWindInitCalled)
  1302. settmode(TMODE_COOK);
  1304.     if (g_hConOut != INVALID_HANDLE_VALUE)
  1305.     {
  1306. (void)CloseHandle(g_hConOut);
  1308. if (g_hSavOut != INVALID_HANDLE_VALUE)
  1309. {
  1310.     SetConsoleTextAttribute(g_hSavOut, g_attrDefault);
  1311.     SetConsoleCursorInfo(g_hSavOut, &g_cci);
  1312. }
  1313.     }
  1315.     ml_close_all(TRUE); /* remove all memfiles */
  1317.     if (g_fWindInitCalled)
  1318.     {
  1319. mch_restore_title(3);
  1321. #ifdef MCH_WRITE_DUMP
  1322. if (fdDump)
  1323. {
  1324.     time_t t;
  1326.     time(&t);
  1327.     fputs(ctime(&t), fdDump);
  1328.     fclose(fdDump);
  1329. }
  1330. fdDump = NULL;
  1331. #endif
  1332.     }
  1334.     exit(r);
  1335. }
  1336. #endif /* USE_GUI_WIN32 */
  1339. /*
  1340.  * Do we have an interactive window?
  1341.  */
  1342.     int
  1343. mch_check_win(
  1344.     int argc,
  1345.     char **argv)
  1346. {
  1347.     char temp[256];
  1348.     int i;
  1350.     /* store the name of the executable, may be used for $VIM */
  1351.     GetModuleFileName(NULL, temp, 255);
  1352.     if (*temp != NUL)
  1353. exe_name = FullName_save((char_u *)temp, FALSE);
  1355.     /* Init the tables for toupper() and tolower() */
  1356.     for (i = 0; i < 256; ++i)
  1357. toupper_tab[i] = tolower_tab[i] = i;
  1358.     CharUpperBuff(toupper_tab, 256);
  1359.     CharLowerBuff(tolower_tab, 256);
  1361. #ifdef USE_GUI_WIN32
  1362.     return OK;     /* GUI always has a tty */
  1363. #else
  1364.     if (isatty(1))
  1365. return OK;
  1366.     return FAIL;
  1367. #endif
  1368. }
  1371. /*
  1372.  * Return TRUE if the input comes from a terminal, FALSE otherwise.
  1373.  */
  1374.     int
  1375. mch_input_isatty()
  1376. {
  1377. #ifdef USE_GUI_WIN32
  1378.     return OK;     /* GUI always has a tty */
  1379. #else
  1380.     if (isatty(read_cmd_fd))
  1381. return TRUE;
  1382.     return FALSE;
  1383. #endif
  1384. }
  1387. /*
  1388.  * Turn a file name into its canonical form.  Replace slashes with backslashes.
  1389.  * This used to replace backslashes with slashes, but that caused problems
  1390.  * when using the file name as a command.  We can't have a mix of slashes and
  1391.  * backslashes, because comparing file names will not work correctly.  The
  1392.  * commands that use file names should be prepared to handle the backslashes.
  1393.  */
  1394.     static void
  1395. canonicalize_filename(
  1396.     char *pszName)
  1397. {
  1398.     if (pszName == NULL)
  1399. return;
  1401.     for ( ; *pszName;  pszName++)
  1402.     {
  1403. if (*pszName == '/')
  1404.     *pszName = '\';
  1405.     }
  1406. }
  1409. /*
  1410.  * fname_case(): Set the case of the file name, if it already exists.
  1411.  */
  1412.     void
  1413. fname_case(
  1414.     char_u *name)
  1415. {
  1416.     char szTrueName[_MAX_PATH + 2];
  1417.     char *psz, *pszPrev;
  1418.     const int len = (name != NULL)  ?  STRLEN(name)  : 0;
  1420.     if (len == 0)
  1421. return;
  1423.     STRNCPY(szTrueName, name, _MAX_PATH);
  1424.     szTrueName[_MAX_PATH] = '';   /* ensure it's sealed off! */
  1425.     STRCAT(szTrueName, "\"); /* sentinel */
  1427.     for (psz = szTrueName;  *psz != NUL;  psz++)
  1428. if (*psz == '/')
  1429.     *psz = '\';
  1431.     psz = pszPrev = szTrueName;
  1433.     /* Skip leading \ in UNC name or drive letter */
  1434.     if (len > 2 && ((psz[0] == '\' && psz[1] == '\')
  1435.        || (isalpha(psz[0]) && psz[1] == ':')))
  1436.     {
  1437. psz = pszPrev = szTrueName + 2;
  1438.     }
  1440.     while (*psz != NUL)
  1441.     {
  1442. WIN32_FIND_DATA fb;
  1443. HANDLE hFind;
  1445. while (*psz != '\')
  1446.     psz++;
  1447. *psz = NUL;
  1449. if ((hFind = FindFirstFile(szTrueName, &fb)) != INVALID_HANDLE_VALUE)
  1450. {
  1451.     /* avoid ".." and ".", etc */
  1452.     if (_stricoll(pszPrev, fb.cFileName) == 0)
  1453. STRCPY(pszPrev, fb.cFileName);
  1454.     FindClose(hFind);
  1455. }
  1457. *psz++ = '\';
  1458. pszPrev = psz;
  1459.     }
  1461.     *--psz = NUL;   /* remove sentinel */
  1463.     STRCPY(name, szTrueName);
  1464. }
  1467. /*
  1468.  * mch_settitle(): set titlebar of our window
  1469.  * Can the icon also be set?
  1470.  */
  1471.     void
  1472. mch_settitle(
  1473.     char_u *title,
  1474.     char_u *icon)
  1475. {
  1476. #ifdef USE_GUI_WIN32
  1477.     gui_mch_settitle(title, icon);
  1478. #else
  1479.     if (title != NULL)
  1480. SetConsoleTitle(title);
  1481. #endif
  1482. }
  1485. /*
  1486.  * Restore the window/icon title.
  1487.  * which is one of:
  1488.  *  1: Just restore title
  1489.  *  2: Just restore icon (which we don't have)
  1490.  *  3: Restore title and icon (which we don't have)
  1491.  */
  1492.     void
  1493. mch_restore_title(
  1494.     int which)
  1495. {
  1496. #ifndef USE_GUI_WIN32
  1497.     mch_settitle((which & 1) ? g_szOrigTitle : NULL, NULL);
  1498. #endif
  1499. }
  1502. /*
  1503.  * Return TRUE if we can restore the title (we can)
  1504.  */
  1505.     int
  1506. mch_can_restore_title()
  1507. {
  1508.     return TRUE;
  1509. }
  1512. /*
  1513.  * Return TRUE if we can restore the icon (we can't)
  1514.  */
  1515.     int
  1516. mch_can_restore_icon()
  1517. {
  1518.     return FALSE;
  1519. }
  1522. /*
  1523.  * Insert user name in s[len].
  1524.  */
  1525.     int
  1526. mch_get_user_name(
  1527.     char_u *s,
  1528.     int len)
  1529. {
  1530.     char szUserName[MAX_COMPUTERNAME_LENGTH + 1];
  1531.     DWORD cch = sizeof szUserName;
  1533.     if (GetUserName(szUserName, &cch))
  1534.     {
  1535. STRNCPY(s, szUserName, len);
  1536. return OK;
  1537.     }
  1538.     s[0] = NUL;
  1539.     return FAIL;
  1540. }
  1543. /*
  1544.  * Insert host name in s[len].
  1545.  */
  1546.     void
  1547. mch_get_host_name(
  1548.     char_u *s,
  1549.     int len)
  1550. {
  1551.     char szHostName[MAX_COMPUTERNAME_LENGTH + 1];
  1552.     DWORD cch = sizeof szHostName;
  1554.     if (GetComputerName(szHostName, &cch))
  1555.     {
  1556. STRCPY(s, "PC ");
  1557. STRNCPY(s + 3, szHostName, len - 3);
  1558.     }
  1559.     else
  1560. STRNCPY(s, "PC (Win32 Vim)", len);
  1561. }
  1564. /*
  1565.  * return process ID
  1566.  */
  1567.     long
  1568. mch_get_pid()
  1569. {
  1570.     return (long)GetCurrentProcessId();
  1571. }
  1574. /*
  1575.  * Get name of current directory into buffer 'buf' of length 'len' bytes.
  1576.  * Return OK for success, FAIL for failure.
  1577.  */
  1578.     int
  1579. mch_dirname(
  1580.     char_u *buf,
  1581.     int len)
  1582. {
  1583.     /*
  1584.      * Originally this was:
  1585.      *    return (getcwd(buf, len) != NULL ? OK : FAIL);
  1586.      * But the Win32s known bug list says that getcwd() doesn't work
  1587.      * so use the Win32 system call instead. <Negri>
  1588.      */
  1589.     return (GetCurrentDirectory(len,buf) != 0 ? OK : FAIL);
  1590. }
  1593. /*
  1594.  * Get absolute file name into buffer 'buf' of length 'len' bytes,
  1595.  * turning all '/'s into '\'s and getting the correct case of each
  1596.  * component of the file name. Return OK or FAIL.
  1597.  */
  1598.     int
  1599. mch_FullName(
  1600.     char_u *fname,
  1601.     char_u *buf,
  1602.     int len,
  1603.     int force)
  1604. {
  1605.     int nResult = FAIL;
  1607.     if (fname == NULL) /* always fail */
  1608. return FAIL;
  1610.     if (_fullpath(buf, fname, len - 1) == NULL)
  1611. STRNCPY(buf, fname, len);   /* failed, use the relative path name */
  1612.     else
  1613.     {
  1614. if (mch_isdir(fname))
  1615.     STRCAT(buf, "\");
  1616. nResult = OK;
  1617.     }
  1619.     fname_case(buf);
  1621.     return nResult;
  1622. }
  1625. /*
  1626.  * return TRUE if `fname' is an absolute path name
  1627.  */
  1628.     int
  1629. mch_isFullName(
  1630.     char_u *fname)
  1631. {
  1632.     char szName[_MAX_PATH+1];
  1634.     mch_FullName(fname, szName, _MAX_PATH, FALSE);
  1636.     return strcoll(fname, szName) == 0;
  1637. }
  1639. /*
  1640.  * Replace all slashes by backslashes.
  1641.  * This used to be the other way around, but MS-DOS sometimes has problems
  1642.  * with slashes (e.g. in a command name).  We can't have mixed slashes and
  1643.  * backslashes, because comparing file names will not work correctly.  The
  1644.  * commands that use a file name should try to avoid the need to type a
  1645.  * backslash twice.
  1646.  */
  1647.     void
  1648. slash_adjust(p)
  1649.     char_u  *p;
  1650. {
  1651.     while (*p)
  1652.     {
  1653. if (*p == '/')
  1654.     *p = '\';
  1655. ++p;
  1656.     }
  1657. }
  1660. /*
  1661.  * get file permissions for `name'
  1662.  * -1 : error
  1663.  * else FILE_ATTRIBUTE_* defined in winnt.h
  1664.  */
  1665.     long
  1666. mch_getperm(
  1667.     char_u *name)
  1668. {
  1669.     return (long)GetFileAttributes((char *)name);
  1670. }
  1673. /*
  1674.  * set file permission for `name' to `perm'
  1675.  */
  1676.     int
  1677. mch_setperm(
  1678.     char_u *name,
  1679.     long perm)
  1680. {
  1681.     perm |= FILE_ATTRIBUTE_ARCHIVE; /* file has changed, set archive bit */
  1682.     return SetFileAttributes((char *)name, perm) ? OK : FAIL;
  1683. }
  1686. /*
  1687.  * Set hidden flag for "name".
  1688.  */
  1689.     void
  1690. mch_hide(char_u *name)
  1691. {
  1692.     int perm;
  1694.     perm = GetFileAttributes((char *)name);
  1695.     if (perm >= 0)
  1696.     {
  1697. perm |= FILE_ATTRIBUTE_HIDDEN;
  1698. SetFileAttributes((char *)name, perm);
  1699.     }
  1700. }
  1702. /*
  1703.  * return TRUE if "name" is a directory
  1704.  * return FALSE if "name" is not a directory or upon error
  1705.  */
  1706.     int
  1707. mch_isdir(char_u *name)
  1708. {
  1709.     int f = mch_getperm(name);
  1711.     if (f == -1)
  1712. return FALSE;     /* file does not exist at all */
  1714.     return (f & FILE_ATTRIBUTE_DIRECTORY) != 0;
  1715. }
  1718. #ifdef USE_GUI_WIN32
  1719.     void
  1720. mch_settmode(int tmode)
  1721. {
  1722.     /* nothing to do */
  1723. }
  1725.     int
  1726. mch_get_winsize()
  1727. {
  1728.     /* never used */
  1729.     return OK;
  1730. }
  1732.     void
  1733. mch_set_winsize()
  1734. {
  1735.     /* never used */
  1736. }
  1737. #else
  1739. /*
  1740.  * handler for ctrl-break, ctrl-c interrupts, and fatal events.
  1741.  */
  1742.     static BOOL WINAPI
  1743. handler_routine(
  1744.     DWORD dwCtrlType)
  1745. {
  1746.     switch (dwCtrlType)
  1747.     {
  1748.     case CTRL_C_EVENT:
  1749. g_fCtrlCPressed = TRUE;
  1750. return TRUE;
  1752.     case CTRL_BREAK_EVENT:
  1753. g_fCBrkPressed = TRUE;
  1754. return TRUE;
  1756.     /* fatal events: shut down gracefully */
  1757.     case CTRL_CLOSE_EVENT:
  1758.     case CTRL_LOGOFF_EVENT:
  1759.     case CTRL_SHUTDOWN_EVENT:
  1760. windgoto((int)Rows - 1, 0);
  1761. sprintf((char *)IObuff, "Vim: Caught %s eventn",
  1762. (dwCtrlType == CTRL_CLOSE_EVENT ? "close"
  1763.  : dwCtrlType == CTRL_LOGOFF_EVENT ? "logoff" : "shutdown"));
  1765. #ifdef DEBUG
  1766. OutputDebugString(IObuff);
  1767. #endif
  1769. preserve_exit(); /* output IObuff, preserve files and exit */
  1771. return TRUE; /* not reached */
  1773.     default:
  1774. return FALSE;
  1775.     }
  1776. }
  1779. /*
  1780.  * set the tty in (raw) ? "raw" : "cooked" mode
  1781.  */
  1782.     void
  1783. mch_settmode(
  1784.     int tmode)
  1785. {
  1786.     DWORD cmodein;
  1787.     DWORD cmodeout;
  1789.     GetConsoleMode(g_hConIn,  &cmodein);
  1790.     GetConsoleMode(g_hCurOut, &cmodeout);
  1792.     if (tmode == TMODE_RAW)
  1793.     {
  1794. cmodein &= ~(ENABLE_LINE_INPUT | ENABLE_PROCESSED_INPUT |
  1795.      ENABLE_ECHO_INPUT);
  1796. cmodein |= (
  1797. #ifdef USE_MOUSE
  1798.     (g_fMouseActive ? ENABLE_MOUSE_INPUT : 0) |
  1799. #endif
  1800.     ENABLE_WINDOW_INPUT);
  1802. SetConsoleMode(g_hConIn, cmodein);
  1804. cmodeout &= ~(ENABLE_PROCESSED_OUTPUT | ENABLE_WRAP_AT_EOL_OUTPUT);
  1805. SetConsoleMode(g_hCurOut, cmodeout);
  1806. SetConsoleCtrlHandler(handler_routine, TRUE);
  1807.     }
  1808.     else /* cooked */
  1809.     {
  1810. cmodein =  g_cmodein;
  1811. cmodeout = g_cmodeout;
  1812. SetConsoleMode(g_hConIn,  g_cmodein);
  1813. SetConsoleMode(g_hCurOut, g_cmodeout);
  1815. SetConsoleCtrlHandler(handler_routine, FALSE);
  1816.     }
  1818. #ifdef MCH_WRITE_DUMP
  1819.     if (fdDump)
  1820.     {
  1821. fprintf(fdDump, "mch_settmode(%s, CurOut = %s, in = %x, out = %x)n",
  1822. tmode == TMODE_RAW ? "raw" :
  1823.     tmode == TMODE_COOK ? "cooked" : "normal",
  1824. (g_hCurOut == g_hSavOut ? "Sav" : "Con"),
  1825. cmodein, cmodeout);
  1826. fflush(fdDump);
  1827.     }
  1828. #endif
  1829. }
  1832. /*
  1833.  * Get the size of the current window in `Rows' and `Columns'
  1834.  * Return OK when size could be determined, FAIL otherwise.
  1835.  */
  1836.     int
  1837. mch_get_winsize()
  1838. {
  1839.     CONSOLE_SCREEN_BUFFER_INFO csbi;
  1841.     if (GetConsoleScreenBufferInfo(g_hCurOut, &csbi))
  1842.     {
  1843. Rows = csbi.srWindow.Bottom - csbi.srWindow.Top + 1;
  1844. Columns = csbi.srWindow.Right - csbi.srWindow.Left + 1;
  1845.     }
  1846.     else
  1847.     {
  1848. Rows = 25;
  1849. Columns = 80;
  1850.     }
  1852.     if (Columns < MIN_COLUMNS || Rows < MIN_LINES)
  1853.     {
  1854. /* these values are overwritten by termcap size or default */
  1855. Rows = 25;
  1856. Columns = 80;
  1857.     }
  1859.     check_winsize();
  1860.     set_scroll_region(0, 0, Columns - 1, Rows - 1);
  1862.     return OK;
  1863. }
  1866. /*
  1867.  * Set a console window to `xSize' * `ySize'
  1868.  */
  1869.     static void
  1870. ResizeConBufAndWindow(
  1871.     HANDLE hConsole,
  1872.     int xSize,
  1873.     int ySize)
  1874. {
  1875.     CONSOLE_SCREEN_BUFFER_INFO csbi; /* hold current console buffer info */
  1876.     SMALL_RECT     srWindowRect; /* hold the new console size */
  1877.     COORD     coordScreen;
  1878.     int     did_start_termcap = FALSE;
  1880. #ifdef MCH_WRITE_DUMP
  1881.     if (fdDump)
  1882.     {
  1883. fprintf(fdDump, "ResizeConBufAndWindow(%d, %d)n", xSize, ySize);
  1884. fflush(fdDump);
  1885.     }
  1886. #endif
  1888.     /*
  1889.      * The resizing MUST be done while in our own console buffer, otherwise it
  1890.      * will never be possible to restore the old one, and we will crash on
  1891.      * exit in Windows 95.
  1892.      */
  1893.     if (g_hCurOut != g_hConOut)
  1894.     {
  1895. termcap_mode_start();
  1896. did_start_termcap = TRUE;
  1897.     }
  1899.     /* get the largest size we can size the console window to */
  1900.     coordScreen = GetLargestConsoleWindowSize(hConsole);
  1902.     /* define the new console window size and scroll position */
  1903.     srWindowRect.Left = srWindowRect.Top = (SHORT) 0;
  1904.     srWindowRect.Right =  (SHORT) (min(xSize, coordScreen.X) - 1);
  1905.     srWindowRect.Bottom = (SHORT) (min(ySize, coordScreen.Y) - 1);
  1907.     if (GetConsoleScreenBufferInfo(g_hCurOut, &csbi))
  1908.     {
  1909. int sx, sy;
  1911. sx = csbi.srWindow.Right - csbi.srWindow.Left + 1;
  1912. sy = csbi.srWindow.Bottom - csbi.srWindow.Top + 1;
  1913. if (sy < ySize || sx < xSize)
  1914. {
  1915.     /*
  1916.      * Increasing number of lines/columns, do buffer first.
  1917.      * Use the maximal size in x and y direction.
  1918.      */
  1919.     if (sy < ySize)
  1920. coordScreen.Y = ySize;
  1921.     else
  1922. coordScreen.Y = sy;
  1923.     if (sx < xSize)
  1924. coordScreen.X = xSize;
  1925.     else
  1926. coordScreen.X = sx;
  1927.     SetConsoleScreenBufferSize(hConsole, coordScreen);
  1928. }
  1929.     }
  1931.     if (!SetConsoleWindowInfo(hConsole, TRUE, &srWindowRect))
  1932.     {
  1933. #ifdef MCH_WRITE_DUMP
  1934. if (fdDump)
  1935. {
  1936.     fprintf(fdDump, "SetConsoleWindowInfo failed: %lxn",
  1937.     GetLastError());
  1938.     fflush(fdDump);
  1939. }
  1940. #endif
  1941.     }
  1943.     /* define the new console buffer size */
  1944.     coordScreen.X = xSize;
  1945.     coordScreen.Y = ySize;
  1947.     if (!SetConsoleScreenBufferSize(hConsole, coordScreen))
  1948.     {
  1949. #ifdef MCH_WRITE_DUMP
  1950. if (fdDump)
  1951. {
  1952.     fprintf(fdDump, "SetConsoleScreenBufferSize failed: %lxn",
  1953.     GetLastError());
  1954.     fflush(fdDump);
  1955. }
  1956. #endif
  1957.     }
  1959.     if (did_start_termcap)
  1960. termcap_mode_end();
  1961. }
  1964. /*
  1965.  * Set the console window to `Rows' * `Columns'
  1966.  */
  1967.     void
  1968. mch_set_winsize()
  1969. {
  1970.     COORD coordScreen;
  1972.     /* Don't change window size while still starting up */
  1973.     if (suppress_winsize)
  1974.     {
  1975. suppress_winsize = 2;
  1976. return;
  1977.     }
  1979.     coordScreen = GetLargestConsoleWindowSize(g_hCurOut);
  1981.     /* Clamp Rows and Columns to reasonable values */
  1982.     if (Rows > coordScreen.Y)
  1983. Rows = coordScreen.Y;
  1984.     if (Columns > coordScreen.X)
  1985. Columns = coordScreen.X;
  1987.     ResizeConBufAndWindow(g_hCurOut, Columns, Rows);
  1988.     set_scroll_region(0, 0, Columns - 1, Rows - 1);
  1989. }
  1991. /*
  1992.  * Called when started up, to set the winsize that was delayed.
  1993.  */
  1994.     void
  1995. mch_set_winsize_now()
  1996. {
  1997.     if (suppress_winsize == 2)
  1998.     {
  1999. suppress_winsize = 0;
  2000. mch_set_winsize();
  2001. check_winsize();     /* in case 'columns' changed */
  2002.     }
  2003.     suppress_winsize = 0;
  2004. }
  2005. #endif /* USE_GUI_WIN32 */
  2008. /*
  2009.  * We have no job control, so fake it by starting a new shell.
  2010.  */
  2011.     void
  2012. mch_suspend()
  2013. {
  2014.     suspend_shell();
  2015. }
  2017. #if defined(USE_GUI_WIN32) || defined(PROTO)
  2019. #ifdef OLD_CONSOLE_STUFF
  2020. /*
  2021.  * Functions to open and close a console window.
  2022.  * The open function sets the size of the window to 25x80, to avoid problems
  2023.  * with Windows 95.  In the long term should make sure that the "close" icon
  2024.  * cannot crash vim (it doesn't do so at the moment!).
  2025.  * The close function waits for the user to press a key before closing the
  2026.  * window.
  2027.  */
  2029.     static BOOL
  2030. ConsoleCtrlHandler(DWORD what)
  2031. {
  2032.     return TRUE;
  2033. }
  2035.     static void
  2036. mch_open_console(void)
  2037. {
  2038.     COORD size;
  2039.     SMALL_RECT window_size;
  2040.     HANDLE console_handle;
  2042.     AllocConsole();
  2044.     /* On windows 95, we must use a 25x80 console size, to avoid trouble with
  2045.      * some DOS commands */
  2046.     if (g_PlatformId != VER_PLATFORM_WIN32_NT)
  2047.     {
  2048. console_handle = GetStdHandle(STD_OUTPUT_HANDLE);
  2050. size.X = 80;
  2051. size.Y = 25;
  2052. window_size.Left = 0;
  2053. window_size.Top = 0;
  2054. window_size.Right = 79;
  2055. window_size.Bottom = 24;
  2057. /* First set the window size, then also resize the screen buffer, to
  2058.  * avoid a scrollbar */
  2059. SetConsoleWindowInfo(console_handle, TRUE, &window_size);
  2060. SetConsoleScreenBufferSize(console_handle, size);
  2061.     }
  2063.     SetConsoleCtrlHandler((PHANDLER_ROUTINE)ConsoleCtrlHandler, TRUE);
  2064. }
  2066.     static void
  2067. mch_close_console(int wait_key, DWORD ret)
  2068. {
  2069.     if (wait_key)
  2070.     {
  2071. HANDLE hStdin = GetStdHandle(STD_INPUT_HANDLE);
  2072. HANDLE hStderr = GetStdHandle(STD_ERROR_HANDLE);
  2073. DWORD number;
  2074. static char message[] = "nPress any key to close this window...";
  2075. static char err_buf[80];
  2076. char buffer[1];
  2078. if (ret)
  2079. {
  2080.     sprintf(err_buf, "n%ld returned.", ret);
  2081.     WriteConsole(hStderr, err_buf, strlen(err_buf), &number, NULL);
  2082. }
  2083. /* Write a message to the user */
  2084. WriteConsole(hStderr, message, sizeof(message)-1, &number, NULL);
  2086. /* Clear the console input buffer, and set the input to "raw" mode */
  2087. FlushConsoleInputBuffer(hStdin);
  2088. SetConsoleMode(hStdin, 0);
  2090. /* Wait for a keypress */
  2091. ReadConsole(hStdin, buffer, 1, &number, NULL);
  2092.     }
  2094.     /* Close the console window */
  2095.     FreeConsole();
  2096. }
  2097. #endif
  2099. #ifdef mch_errmsg
  2100. # undef mch_errmsg
  2101. # undef mch_display_error
  2102. #endif
  2104. /*
  2105.  * Record an error message for later display.
  2106.  */
  2107.     void
  2108. mch_errmsg(char *str)
  2109. {
  2110.     int len = STRLEN(str) + 1;
  2112.     if (error_ga.ga_growsize == 0)
  2113.     {
  2114. error_ga.ga_growsize = 80;
  2115. error_ga.ga_itemsize = 1;
  2116.     }
  2117.     if (ga_grow(&error_ga, len) == OK)
  2118.     {
  2119. mch_memmove((char_u *)error_ga.ga_data + error_ga.ga_len,
  2120.   (char_u *)str, len);
  2121. --len; /* don't count the NUL at the end */
  2122. error_ga.ga_len += len;
  2123. error_ga.ga_room -= len;
  2124.     }
  2125. }
  2127. /*
  2128.  * Display the saved error message(s).
  2129.  */
  2130.     void
  2131. mch_display_error()
  2132. {
  2133.     char *p;
  2135.     if (error_ga.ga_data != NULL)
  2136.     {
  2137. /* avoid putting up a message box with blanks only */
  2138. for (p = (char *)error_ga.ga_data; *p; ++p)
  2139.     if (!isspace(*p))
  2140.     {
  2141. MessageBox(0, p, "Vim", MB_TASKMODAL|MB_SETFOREGROUND);
  2142. break;
  2143.     }
  2144. ga_clear(&error_ga);
  2145.     }
  2146. }
  2148. /*
  2149.  * Specialised version of system() for Win32 GUI mode.
  2150.  * This version proceeds as follows:
  2151.  *    1. Create a console window for use by the subprocess
  2152.  *    2. Run the subprocess (it gets the allocated console by default)
  2153.  *    3. Wait for the subprocess to terminate and get its exit code
  2154.  *    4. Prompt the user to press a key to close the console window
  2155.  */
  2156. static BOOL fUseConsole = TRUE;
  2158.     static int
  2159. mch_system(char *cmd, int options)
  2160. {
  2161.     STARTUPINFO si;
  2162.     PROCESS_INFORMATION pi;
  2163.     DWORD ret = 0;
  2165.     si.cb = sizeof(si);
  2166.     si.lpReserved = NULL;
  2167.     si.lpDesktop = NULL;
  2168.     si.lpTitle = NULL;
  2169.     si.dwFlags = STARTF_USESHOWWINDOW;
  2170.     /*
  2171.      * It's nicer to run a filter command in a minimized window, but in
  2172.      * Windows 95 this makes the command MUCH slower.
  2173.      */
  2174.     if ((options & SHELL_DOOUT) && !mch_windows95())
  2175. si.wShowWindow = SW_SHOWMINIMIZED;
  2176.     else
  2177. si.wShowWindow = SW_SHOWNORMAL;
  2178.     si.cbReserved2 = 0;
  2179.     si.lpReserved2 = NULL;
  2181. #ifdef OLD_CONSOLE_STUFF
  2182.     /* Create a console for the process. This lets us write a termination
  2183.      * message at the end, and wait for the user to close the console
  2184.      * window manually...
  2185.      */
  2186.     if (fUseConsole)
  2187.     {
  2188. mch_open_console();
  2190. /*
  2191.  * Write the command to the console, so the user can see what is going
  2192.  * on.
  2193.  */
  2194. {
  2195.     HANDLE hStderr = GetStdHandle(STD_ERROR_HANDLE);
  2196.     DWORD number;
  2198.     WriteConsole(hStderr, cmd, STRLEN(cmd), &number, NULL);
  2199.     WriteConsole(hStderr, "n", 1, &number, NULL);
  2200. }
  2201.     }
  2202. #else
  2203.     /* There is a strange error on Windows 95 when using "c:\command.com".
  2204.      * When the "c:\" is left out it works OK...? */
  2205.     if (mch_windows95()
  2206.     && (STRNICMP(cmd, "c:/command.com", 14) == 0
  2207. || STRNICMP(cmd, "c:\command.com", 14) == 0))
  2208. cmd += 3;
  2209. #endif
  2211.     /* Now, run the command */
  2212.     CreateProcess(NULL, /* Executable name */
  2213.   cmd, /* Command to execute */
  2214.   NULL, /* Process security attributes */
  2215.   NULL, /* Thread security attributes */
  2216.   FALSE, /* Inherit handles */
  2217.   CREATE_DEFAULT_ERROR_MODE | /* Creation flags */
  2218. #ifdef OLD_CONSOLE_STUFF
  2219.   0,
  2220. #else
  2221.   CREATE_NEW_CONSOLE,
  2222. #endif
  2223.   NULL, /* Environment */
  2224.   NULL, /* Current directory */
  2225.   &si, /* Startup information */
  2226.   &pi); /* Process information */
  2229.     /* Wait for the command to terminate before continuing */
  2230.     if (fUseConsole)
  2231.     {
  2232. if (g_PlatformId != VER_PLATFORM_WIN32s)
  2233. {
  2234.     WaitForSingleObject(pi.hProcess, INFINITE);
  2236.     /* Get the command exit code */
  2237.     GetExitCodeProcess(pi.hProcess, &ret);
  2238. }
  2239. else
  2240. {
  2241.     /*
  2242.      * This ugly code is the only quick way of performing
  2243.      * a synchronous spawn under Win32s. Yuk.
  2244.      */
  2245.     num_windows = 0;
  2246.     EnumWindows(win32ssynch_cb, 0);
  2247.     old_num_windows = num_windows;
  2248.     do
  2249.     {
  2250. Sleep(1000);
  2251. num_windows = 0;
  2252. EnumWindows(win32ssynch_cb, 0);
  2253.     } while (num_windows == old_num_windows);
  2254.     ret = 0;
  2255. }
  2256.     }
  2258.     /* Close the handles to the subprocess, so that it goes away */
  2259.     CloseHandle(pi.hThread);
  2260.     CloseHandle(pi.hProcess);
  2262.     /* Close the console window. If we are not redirecting output, wait for
  2263.      * the user to press a key.
  2264.      */
  2265. #ifdef OLD_CONSOLE_STUFF
  2266.     if (fUseConsole)
  2267. mch_close_console(!(options & SHELL_DOOUT), ret);
  2268. #endif
  2270.     return ret;
  2271. }
  2272. #else
  2274. # define mch_system(c, o) system(c)
  2276. #endif
  2278. /*
  2279.  * Either execute a command by calling the shell or start a new shell
  2280.  */
  2281.     int
  2282. mch_call_shell(
  2283.     char_u *cmd,
  2284.     int options)     /* SHELL_FILTER if called by do_filter() */
  2285.     /* SHELL_COOKED if term needs cooked mode */
  2286. {
  2287.     int     x;
  2288. #ifndef USE_GUI_WIN32
  2289.     int     stopped_termcap_mode = FALSE;
  2290. #endif
  2292.     out_flush();
  2294. #ifndef USE_GUI_WIN32
  2295.     /*
  2296.      * ALWAYS switch to non-termcap mode, otherwise ":r !ls" may crash.
  2297.      */
  2298.     if (g_hCurOut == g_hConOut &&
  2299.     ((cmd == NULL) || STRNICMP(cmd, "start ", 6) != 0))
  2300.     {
  2301. termcap_mode_end();
  2302. stopped_termcap_mode = TRUE;
  2303.     }
  2304. #endif
  2306. #ifdef MCH_WRITE_DUMP
  2307.     if (fdDump)
  2308.     {
  2309. fprintf(fdDump, "mch_call_shell("%s", %d)n", cmd, options);
  2310. fflush(fdDump);
  2311.     }
  2312. #endif
  2314.     /*
  2315.      * Catch all deadly signals while running the external command, because a
  2316.      * CTRL-C, Ctrl-Break or illegal instruction  might otherwise kill us.
  2317.      */
  2318.     signal(SIGINT, SIG_IGN);
  2319. #ifdef __GNUC__
  2320.     signal(SIGKILL, SIG_IGN);
  2321. #else
  2322.     signal(SIGBREAK, SIG_IGN);
  2323. #endif
  2324.     signal(SIGILL, SIG_IGN);
  2325.     signal(SIGFPE, SIG_IGN);
  2326.     signal(SIGSEGV, SIG_IGN);
  2327.     signal(SIGTERM, SIG_IGN);
  2328.     signal(SIGABRT, SIG_IGN);
  2330.     if (options & SHELL_COOKED)
  2331. settmode(TMODE_COOK); /* set to normal mode */
  2333.     if (cmd == NULL)
  2334.     {
  2335. x = mch_system(p_sh, options);
  2336.     }
  2337.     else
  2338.     {
  2339. /* we use "command" or "cmd" to start the shell; slow but easy */
  2340. char_u *newcmd;
  2342. newcmd = lalloc(
  2343. #ifdef USE_GUI_WIN32
  2344. STRLEN(vimrun_path) +
  2345. #endif
  2346. STRLEN(p_sh) + STRLEN(p_shcf) + STRLEN(cmd) + 10, TRUE);
  2347. if (newcmd != NULL)
  2348. {
  2349.     if (STRNICMP(cmd, "start ", 6) == 0)
  2350.     {
  2351. STARTUPINFO si;
  2352. PROCESS_INFORMATION pi;
  2354. si.cb = sizeof(si);
  2355. si.lpReserved = NULL;
  2356. si.lpDesktop = NULL;
  2357. si.lpTitle = NULL;
  2358. si.dwFlags = 0;
  2359. si.cbReserved2 = 0;
  2360. si.lpReserved2 = NULL;
  2361. sprintf((char *)newcmd, "%s", cmd+6);
  2362. /*
  2363.  * Now, start the command as a process, so that it doesn't
  2364.  * inherit our handles which causes unpleasant dangling swap
  2365.  * files if we exit before the spawned process
  2366.  */
  2367. if (CreateProcess (NULL, // Executable name
  2368. newcmd, // Command to execute
  2369. NULL, // Process security attributes
  2370. NULL, // Thread security attributes
  2371. FALSE, // Inherit handles
  2372. CREATE_NEW_CONSOLE, // Creation flags
  2373. NULL, // Environment
  2374. NULL, // Current directory
  2375. &si, // Startup information
  2376. &pi)) // Process information
  2377.     x = 0;
  2378. else
  2379.     x = -1;
  2380. /* Close the handles to the subprocess, so that it goes away */
  2381. CloseHandle(pi.hThread);
  2382. CloseHandle(pi.hProcess);
  2383.     }
  2384.     else
  2385.     {
  2386. sprintf((char *)newcmd, "%s%s %s %s",
  2387. #if defined(OLD_CONSOLE_STUFF) || !defined(USE_GUI_WIN32)
  2388. "",
  2389. #else
  2390. /*
  2391.  * Do we need to use "vimrun"?
  2392.  */
  2393. ((options & SHELL_DOOUT) || s_dont_use_vimrun) ?
  2394.     "" : vimrun_path,
  2395. #endif
  2396. p_sh,
  2397. p_shcf,
  2398. cmd);
  2399. x = mch_system((char *)newcmd, options);
  2400.     }
  2401.     vim_free(newcmd);
  2402. }
  2403.     }
  2405.     settmode(TMODE_RAW);     /* set to raw mode */
  2407. #ifdef USE_GUI_WIN32
  2408.     if (x && !expand_interactively && !fUseConsole)
  2409. #else
  2410.     if (x && !expand_interactively)
  2411. #endif
  2412.     {
  2413. smsg("%d returned", x);
  2414. msg_putchar('n');
  2415.     }
  2416.     resettitle();
  2418.     signal(SIGINT, SIG_DFL);
  2419. #ifdef __GNUC__
  2420.     signal(SIGKILL, SIG_DFL);
  2421. #else
  2422.     signal(SIGBREAK, SIG_DFL);
  2423. #endif
  2424.     signal(SIGILL, SIG_DFL);
  2425.     signal(SIGFPE, SIG_DFL);
  2426.     signal(SIGSEGV, SIG_DFL);
  2427.     signal(SIGTERM, SIG_DFL);
  2428.     signal(SIGABRT, SIG_DFL);
  2430. #ifndef USE_GUI_WIN32
  2431.     if (stopped_termcap_mode)
  2432. termcap_mode_start();
  2433. #endif
  2435.     return x;
  2436. }
  2439. /*
  2440.  * Does `s' contain a wildcard?
  2441.  */
  2442.     int
  2443. mch_has_wildcard(
  2444.     char_u *s)
  2445. {
  2446.     return (vim_strpbrk(s, (char_u *)"?*$~") != NULL);
  2447. }
  2450. /*
  2451.  * comparison function for qsort in expandpath
  2452.  */
  2453.     static int
  2454. #ifdef __BORLANDC__
  2455. _RTLENTRYF
  2456. #endif
  2457. pstrcmp(
  2458.     const void *a,
  2459.     const void *b)
  2460. {
  2461.     return (_stricoll(* (char **)a, * (char **)b));
  2462. }
  2465. /*
  2466.  * Recursively build up a list of files in "gap" matching the first wildcard
  2467.  * in `path'.  Called by expand_wildcards().
  2468.  */
  2469.     int
  2470. mch_expandpath(
  2471.     struct growarray *gap,
  2472.     char_u *path,
  2473.     int flags)
  2474. {
  2475.     char buf[_MAX_PATH+1];
  2476.     char *p, *s, *e;
  2477.     int start_len, c = 1;
  2478.     WIN32_FIND_DATA fb;
  2479.     HANDLE hFind;
  2480.     int matches;
  2481.     int start_dot_ok;
  2483.     start_len = gap->ga_len;
  2485.     /*
  2486.      * Find the first part in the path name that contains a wildcard.
  2487.      * Copy it into `buf', including the preceding characters.
  2488.      */
  2489.     p = buf;
  2490.     s = NULL;
  2491.     e = NULL;
  2492.     while (*path)
  2493.     {
  2494. if (*path == '\' || *path == ':' || *path == '/')
  2495. {
  2496.     if (e)
  2497. break;
  2498.     else
  2499. s = p;
  2500. }
  2501. if (*path == '*' || *path == '?')
  2502.     e = p;
  2503. *p++ = *path++;
  2504.     }
  2505.     e = p;
  2506.     if (s)
  2507. s++;
  2508.     else
  2509. s = buf;
  2511. #ifdef USE_GUI_WIN32
  2512.     if (gui_is_win32s())
  2513.     {
  2514. /* It appears the Win32s FindFirstFile() call doesn't like a pattern
  2515.  * such as swrel1.0cod* because of the dot in the directory name.
  2516.  * It doesn't match files with extensions.
  2517.  * if the file name ends in "*" and does not contain a "." after the
  2518.  * last  , add ".*"
  2519.  */
  2520. if (e[-1] == '*' && vim_strchr(s, '.') == NULL)
  2521. {
  2522.     *e++ = '.';
  2523.     *e++ = '*';
  2524. }
  2525.     }
  2526. #endif
  2528.     /* now we have one wildcard component between `s' and `e' */
  2529.     *e = NUL;
  2531.     start_dot_ok = (buf[0] == '.' || buf[0] == '*');
  2533.     /* If we are expanding wildcards, we try both files and directories */
  2534.     if ((hFind = FindFirstFile(buf, &fb)) != INVALID_HANDLE_VALUE)
  2535. while (c)
  2536. {
  2537.     STRCPY(s, fb.cFileName);
  2539.     /*
  2540.      * Ignore "." and "..".  When more follows, this must be a
  2541.      * directory.
  2542.      * Find*File() returns matches that start with a '.', even though
  2543.      * the pattern doesn't start with '.'.  Filter them out manually.
  2544.      */
  2545.     if ((s[0] != '.'
  2546. || (start_dot_ok
  2547.     && s[1] != NUL
  2548.     && (s[1] != '.' || s[2] != NUL)))
  2549.     && (*path == NUL || mch_isdir(buf)))
  2550.     {
  2551. STRCAT(buf, path);
  2552. if (mch_has_wildcard(path))     /* handle more wildcards */
  2553.     (void)mch_expandpath(gap, buf, flags);
  2554. else if (mch_getperm(buf) >= 0)     /* add existing file */
  2555.     addfile(gap, buf, flags);
  2556.     }
  2558.     c = FindNextFile(hFind, &fb);
  2559. }
  2560.     FindClose(hFind);
  2562.     matches = gap->ga_len - start_len;
  2563.     if (matches)
  2564. qsort(((char_u **)gap->ga_data) + start_len, matches,
  2565.      sizeof(char *), pstrcmp);
  2566.     return matches;
  2567. }
  2570. /*
  2571.  * The normal _chdir() does not change the default drive.  This one does.
  2572.  * Returning 0 implies success; -1 implies failure.
  2573.  */
  2574.     int
  2575. mch_chdir(char *path)
  2576. {
  2577.     if (path[0] == NUL) /* just checking... */
  2578. return -1;
  2580.     if (isalpha(path[0]) && path[1] == ':') /* has a drive name */
  2581.     {
  2582. if (_chdrive(TO_LOWER(path[0]) - 'a' + 1) != 0)
  2583.     return -1; /* invalid drive name */
  2584. path += 2;
  2585.     }
  2587.     if (*path == NUL) /* drive name only */
  2588. return 0;
  2590.     return chdir(path);        /* let the normal chdir() do the rest */
  2591. }
  2594. #ifndef USE_GUI_WIN32
  2595. /*
  2596.  * Copy the contents of screen buffer hSrc to the bottom-left corner
  2597.  * of screen buffer hDst.
  2598.  */
  2599.     static void
  2600. copy_screen_buffer_text(
  2601.     HANDLE hSrc,
  2602.     HANDLE hDst)
  2603. {
  2604.     int     i, j, nSrcWidth, nSrcHeight, nDstWidth, nDstHeight;
  2605.     COORD   coordOrigin;
  2606.     DWORD   dwDummy;
  2607.     LPSTR   pszOldText;
  2608.     CONSOLE_SCREEN_BUFFER_INFO csbiSrc, csbiDst;
  2610. #ifdef MCH_WRITE_DUMP
  2611.     if (fdDump)
  2612.     {
  2613. fprintf(fdDump, "copy_screen_buffer_text(%s, %s)n",
  2614. (hSrc == g_hSavOut ? "Sav" : "Con"),
  2615. (hDst == g_hSavOut ? "Sav" : "Con"));
  2616. fflush(fdDump);
  2617.     }
  2618. #endif
  2620.     GetConsoleScreenBufferInfo(hSrc, &csbiSrc);
  2621.     nSrcWidth =  csbiSrc.srWindow.Right  - csbiSrc.srWindow.Left + 1;
  2622.     nSrcHeight = csbiSrc.srWindow.Bottom - csbiSrc.srWindow.Top  + 1;
  2624.     GetConsoleScreenBufferInfo(hDst, &csbiDst);
  2625.     nDstWidth =  csbiDst.srWindow.Right  - csbiDst.srWindow.Left + 1;
  2626.     nDstHeight = csbiDst.srWindow.Bottom - csbiDst.srWindow.Top  + 1;
  2628.     pszOldText = (LPSTR) alloc(nDstHeight * nDstWidth);
  2630.     /* clear the top few lines if Src shorter than Dst */
  2631.     for (i = 0;  i < nDstHeight - nSrcHeight;  i++)
  2632.     {
  2633. for (j = 0;  j < nDstWidth;  j++)
  2634.     pszOldText[i * nDstWidth + j] = ' ';
  2635.     }
  2637.     /* Grab text off source screen. */
  2638.     coordOrigin.X = 0;
  2639.     coordOrigin.Y = (SHORT) max(0, csbiSrc.srWindow.Bottom + 1 - nDstHeight);
  2641.     for (i = 0;  i < min(nSrcHeight, nDstHeight);  i++)
  2642.     {
  2643. LPSTR psz = pszOldText
  2644.      + (i + max(0, nDstHeight - nSrcHeight)) * nDstWidth;
  2646. ReadConsoleOutputCharacter(hSrc, psz, min(nDstWidth, nSrcWidth),
  2647.    coordOrigin, &dwDummy);
  2648. coordOrigin.Y++;
  2650. /* clear the last few columns if Src narrower than Dst */
  2651. for (j = nSrcWidth;  j < nDstWidth;  j++)
  2652.     psz[j] = ' ';
  2653.     }
  2655.     /* paste Src's text onto Dst */
  2656.     coordOrigin.Y = csbiDst.srWindow.Top;
  2657.     WriteConsoleOutputCharacter(hDst, pszOldText, nDstHeight * nDstWidth,
  2658. coordOrigin, &dwDummy);
  2659.     vim_free(pszOldText);
  2660. }
  2663. /* keep track of state of original console window */
  2664. static SMALL_RECT   g_srOrigWindowRect;
  2665. static COORD     g_coordOrig;
  2666. static WORD     g_attrSave = 0;
  2669. /*
  2670.  * Start termcap mode by switching to our allocated screen buffer
  2671.  */
  2672.     static void
  2673. termcap_mode_start(void)
  2674. {
  2675.     CONSOLE_SCREEN_BUFFER_INFO csbi;
  2676.     DWORD dwDummy;
  2677.     COORD coord;
  2678.     WORD wAttr = (WORD) (g_attrSave ? g_attrSave : g_attrCurrent);
  2680.     GetConsoleScreenBufferInfo(g_hSavOut, &csbi);
  2681.     g_srOrigWindowRect = csbi.srWindow;
  2683.     g_coordOrig.X = 0;
  2684.     g_coordOrig.Y = csbi.dwCursorPosition.Y;
  2686.     if (g_hConOut == INVALID_HANDLE_VALUE)
  2687. /* Create a new screen buffer in which we do all of our editing.
  2688.  * This means we can restore the original screen when we finish. */
  2689. g_hConOut = CreateConsoleScreenBuffer(GENERIC_WRITE | GENERIC_READ,
  2690.       0, (LPSECURITY_ATTRIBUTES) NULL,
  2691.       CONSOLE_TEXTMODE_BUFFER,
  2692.       (LPVOID) NULL);
  2694.     coord.X = coord.Y = 0;
  2695.     FillConsoleOutputCharacter(g_hConOut, ' ', Rows * Columns, coord, &dwDummy);
  2696.     FillConsoleOutputAttribute(g_hConOut, wAttr, Rows*Columns, coord, &dwDummy);
  2698.     copy_screen_buffer_text(g_hSavOut, g_hConOut);
  2700.     g_hCurOut = g_hConOut;
  2701.     SetConsoleActiveScreenBuffer(g_hCurOut);
  2703.     ResizeConBufAndWindow(g_hCurOut, Columns, Rows);
  2704.     set_scroll_region(0, 0, Columns - 1, Rows - 1);
  2705.     check_winsize();
  2707.     resettitle();
  2709.     textattr(wAttr);
  2710. }
  2713. /*
  2714.  * Turn off termcap mode by restoring the screen buffer we had upon startup
  2715.  */
  2716.     static void
  2717. termcap_mode_end()
  2718. {
  2719.     g_attrSave = g_attrCurrent;
  2721.     ResizeConBufAndWindow(g_hCurOut, g_nOldColumns, g_nOldRows);
  2723.     /* This weird Sleep(0) is required to allow Windows to really resize the
  2724.      * console window.  Apparently it's done asynchronously, which may cause
  2725.      * the following screenbuffer switch to go wrong */
  2726.     Sleep(0);
  2728.     check_winsize();
  2730.     g_hCurOut = g_hSavOut;
  2731.     SetConsoleActiveScreenBuffer(g_hCurOut);
  2732.     SetConsoleCursorInfo(g_hCurOut, &g_cci);
  2734.     normvideo();
  2736.     if (!p_rs)
  2737. g_coordOrig.Y = g_srOrigWindowRect.Bottom;
  2739.     SetConsoleCursorPosition(g_hCurOut, g_coordOrig);
  2741.     if (!p_rs)
  2742. copy_screen_buffer_text(g_hConOut, g_hSavOut);
  2744.     clear_chars(g_coordOrig,
  2745. g_srOrigWindowRect.Right - g_srOrigWindowRect.Left + 1);
  2747.     mch_restore_title(3);
  2749.     SetConsoleMode(g_hConIn,  g_cmodein);
  2750.     SetConsoleMode(g_hSavOut, g_cmodeout);
  2751. }
  2752. #endif /* USE_GUI_WIN32 */
  2754. /*
  2755.  * Switching off termcap mode is only allowed when Columns is 80, otherwise a
  2756.  * crash may result.  It's always allowed on NT or when running the GUI.
  2757.  */
  2758.     int
  2759. can_end_termcap_mode(
  2760.     int give_msg)
  2761. {
  2762. #ifdef USE_GUI_WIN32
  2763.     return TRUE; /* GUI starts a new console anyway */
  2764. #else
  2765.     if (g_PlatformId == VER_PLATFORM_WIN32_NT || Columns == 80)
  2766. return TRUE;
  2767.     if (give_msg)
  2768. msg("'columns' is not 80, cannot execute external commands");
  2769.     return FALSE;
  2770. #endif
  2771. }
  2773. #ifdef USE_GUI_WIN32
  2774.     void
  2775. mch_write(
  2776.     char_u  *s,
  2777.     int     len)
  2778. {
  2779.     /* never used */
  2780. }
  2782. #else
  2784. /*
  2785.  * clear `n' chars, starting from `coord'
  2786.  */
  2787.     static void
  2788. clear_chars(
  2789.     COORD coord,
  2790.     DWORD n)
  2791. {
  2792.     DWORD dwDummy;
  2794.     FillConsoleOutputCharacter(g_hCurOut, ' ', n, coord, &dwDummy);
  2795.     FillConsoleOutputAttribute(g_hCurOut, g_attrCurrent, n, coord, &dwDummy);
  2796. }
  2799. /*
  2800.  * Clear the screen
  2801.  */
  2802.     static void
  2803. clear_screen(void)
  2804. {
  2805.     g_coord.X = g_coord.Y = 0;
  2806.     clear_chars(g_coord, Rows * Columns);
  2807. }
  2810. /*
  2811.  * Clear to end of display
  2812.  */
  2813.     static void
  2814. clear_to_end_of_display(void)
  2815. {
  2816.     clear_chars(g_coord, (Rows-g_coord.Y-1) * Columns + (Columns-g_coord.X));
  2817. }
  2820. /*
  2821.  * Clear to end of line
  2822.  */
  2823.     static void
  2824. clear_to_end_of_line(void)
  2825. {
  2826.     clear_chars(g_coord, Columns - g_coord.X);
  2827. }
  2830. /*
  2831.  * Scroll the scroll region up by `cLines' lines
  2832.  */
  2833.     static void
  2834. scroll(
  2835.     unsigned cLines)
  2836. {
  2837.     COORD oldcoord = g_coord;
  2839.     gotoxy(g_srScrollRegion.Left + 1, g_srScrollRegion.Top + 1);
  2840.     delete_lines(cLines);
  2842.     g_coord = oldcoord;
  2843. }
  2846. /*
  2847.  * Set the scroll region
  2848.  */
  2849.     static void
  2850. set_scroll_region(
  2851.     unsigned left,
  2852.     unsigned top,
  2853.     unsigned right,
  2854.     unsigned bottom)
  2855. {
  2856.     if (left >= right
  2857.     || top >= bottom
  2858.     || right > (unsigned) Columns - 1
  2859.     || bottom > (unsigned) Rows - 1)
  2860. return;
  2862.     g_srScrollRegion.Left =   left;
  2863.     g_srScrollRegion.Top =    top;
  2864.     g_srScrollRegion.Right =  right;
  2865.     g_srScrollRegion.Bottom = bottom;
  2866. }
  2869. /*
  2870.  * Insert `cLines' lines at the current cursor position
  2871.  */
  2872.     static void
  2873. insert_lines(
  2874.     unsigned cLines)
  2875. {
  2876.     SMALL_RECT     source;
  2877.     COORD     dest;
  2878.     CHAR_INFO     fill;
  2880.     dest.X = 0;
  2881.     dest.Y = g_coord.Y + cLines;
  2883.     source.Left   = 0;
  2884.     source.Top   = g_coord.Y;
  2885.     source.Right  = g_srScrollRegion.Right;
  2886.     source.Bottom = g_srScrollRegion.Bottom - cLines;
  2888.     fill.Char.AsciiChar = ' ';
  2889.     fill.Attributes = g_attrCurrent;
  2891.     ScrollConsoleScreenBuffer(g_hCurOut, &source, NULL, dest, &fill);
  2893.     /* Here we have to deal with a win32 console flake: If the scroll
  2894.      * region looks like abc and we scroll c to a and fill with d we get
  2895.      * cbd... if we scroll block c one line at a time to a, we get cdd...
  2896.      * vim expects cdd consistently... So we have to deal with that
  2897.      * here... (this also occurs scrolling the same way in the other
  2898.      * direction).  */
  2900.     if (source.Bottom < dest.Y)
  2901.     {
  2902. COORD coord;
  2904. coord.X = 0;
  2905. coord.Y = source.Bottom;
  2906. clear_chars(coord, Columns * (dest.Y - source.Bottom));
  2907.     }
  2908. }
  2911. /*
  2912.  * Delete `cLines' lines at the current cursor position
  2913.  */
  2914.     static void
  2915. delete_lines(
  2916.     unsigned cLines)
  2917. {
  2918.     SMALL_RECT     source;
  2919.     COORD     dest;
  2920.     CHAR_INFO     fill;
  2921.     int     nb;
  2923.     dest.X = 0;
  2924.     dest.Y = g_coord.Y;
  2926.     source.Left   = 0;
  2927.     source.Top   = g_coord.Y + cLines;
  2928.     source.Right  = g_srScrollRegion.Right;
  2929.     source.Bottom = g_srScrollRegion.Bottom;
  2931.     fill.Char.AsciiChar = ' ';
  2932.     fill.Attributes = g_attrCurrent;
  2934.     ScrollConsoleScreenBuffer(g_hCurOut, &source, NULL, dest, &fill);
  2936.     /* Here we have to deal with a win32 console flake: If the scroll
  2937.      * region looks like abc and we scroll c to a and fill with d we get
  2938.      * cbd... if we scroll block c one line at a time to a, we get cdd...
  2939.      * vim expects cdd consistently... So we have to deal with that
  2940.      * here... (this also occurs scrolling the same way in the other
  2941.      * direction).  */
  2943.     nb = dest.Y + (source.Bottom - source.Top) + 1;
  2945.     if (nb < source.Top)
  2946.     {
  2947. COORD coord;
  2949. coord.X = 0;
  2950. coord.Y = nb;
  2951. clear_chars(coord, Columns * (source.Top - nb));
  2952.     }
  2953. }
  2956. /*
  2957.  * Set the cursor position
  2958.  */
  2959.     static void
  2960. gotoxy(
  2961.     unsigned x,
  2962.     unsigned y)
  2963. {
  2964.     COORD coord2;
  2966.     if (x < 1 || x > (unsigned) Columns || y < 1 || y > (unsigned) Rows)
  2967. return;
  2969.     /* Should we check against g_srScrollRegion? */
  2971.     /* external cursor coords are 1-based; internal are 0-based */
  2972.     g_coord.X = coord2.X = x - 1;
  2973.     g_coord.Y = coord2.Y = y - 1;
  2975.     /* If we are using the window buffer that we had upon startup, make
  2976.      * sure to position cursor relative to the window upon that buffer */
  2977.     if (g_hCurOut == g_hSavOut)
  2978.     {
  2979. CONSOLE_SCREEN_BUFFER_INFO csbi;
  2981. GetConsoleScreenBufferInfo(g_hCurOut, &csbi);
  2982. g_srOrigWindowRect = csbi.srWindow;
  2984. coord2.X += (SHORT) (g_srOrigWindowRect.Left);
  2985. coord2.Y += (SHORT) (g_srOrigWindowRect.Bottom + 1 - Rows);
  2986.     }
  2988.     SetConsoleCursorPosition(g_hCurOut, coord2);
  2989. }
  2992. /*
  2993.  * Set the current text attribute = (foreground | background)
  2994.  * See ../doc/os_win32.txt for the numbers.
  2995.  */
  2996.     static void
  2997. textattr(
  2998.     WORD wAttr)
  2999. {
  3000.     g_attrCurrent = wAttr;
  3002.     SetConsoleTextAttribute(g_hCurOut, wAttr);
  3003. }
  3006.     static void
  3007. textcolor(
  3008.     WORD wAttr)
  3009. {
  3010.     g_attrCurrent = (g_attrCurrent & 0xf0) + wAttr;
  3012.     SetConsoleTextAttribute(g_hCurOut, g_attrCurrent);
  3013. }
  3016.     static void
  3017. textbackground(
  3018.     WORD wAttr)
  3019. {
  3020.     g_attrCurrent = (g_attrCurrent & 0x0f) + (wAttr << 4);
  3022.     SetConsoleTextAttribute(g_hCurOut, g_attrCurrent);
  3023. }
  3026. /*
  3027.  * restore the default text attribute (whatever we started with)
  3028.  */
  3029.     static void
  3030. normvideo()
  3031. {
  3032.     textattr(g_attrDefault);
  3033. }
  3036. static WORD g_attrPreStandout = 0;
  3038. /*
  3039.  * Make the text standout, by brightening it
  3040.  */
  3041.     static void
  3042. standout(void)
  3043. {
  3044.     g_attrPreStandout = g_attrCurrent;
  3045.     textattr((WORD) (g_attrCurrent|FOREGROUND_INTENSITY|BACKGROUND_INTENSITY));
  3046. }
  3049. /*
  3050.  * Turn off standout mode
  3051.  */
  3052.     static void
  3053. standend()
  3054. {
  3055.     if (g_attrPreStandout)
  3056.     {
  3057. textattr(g_attrPreStandout);
  3058. g_attrPreStandout = 0;
  3059.     }
  3060. }
  3063. /*
  3064.  * visual bell: flash the screen
  3065.  */
  3066.     static void
  3067. visual_bell()
  3068. {
  3069.     COORD   coordOrigin = {0, 0};
  3070.     WORD    attrFlash = ~g_attrCurrent & 0xff;
  3072.     DWORD   dwDummy;
  3073.     LPWORD  oldattrs = (LPWORD) alloc(Rows * Columns * sizeof(WORD));
  3075.     ReadConsoleOutputAttribute(g_hCurOut, oldattrs, Rows * Columns,
  3076.        coordOrigin, &dwDummy);
  3077.     FillConsoleOutputAttribute(g_hCurOut, attrFlash, Rows * Columns,
  3078.        coordOrigin, &dwDummy);
  3080.     Sleep(15);     /* wait for 15 msec */
  3081.     WriteConsoleOutputAttribute(g_hCurOut, oldattrs, Rows * Columns,
  3082. coordOrigin, &dwDummy);
  3083.     vim_free(oldattrs);
  3084. }
  3087. /*
  3088.  * Make the cursor visible or invisible
  3089.  */
  3090.     static void
  3091. cursor_visible(
  3092.     BOOL fVisible)
  3093. {
  3094.     s_cursor_visible = fVisible;
  3095.     mch_update_cursor();
  3096. }
  3099. /*
  3100.  * write `cchToWrite' characters in `pchBuf' to the screen
  3101.  */
  3102.     static BOOL
  3103. write_chars(
  3104.     LPCSTR pchBuf,
  3105.     DWORD  cchToWrite,
  3106.     DWORD* pcchWritten)
  3107. {
  3108.     BOOL f;
  3109.     COORD coord2 = g_coord;
  3111.     if (g_hCurOut == g_hSavOut)
  3112.     {
  3113. CONSOLE_SCREEN_BUFFER_INFO csbi;
  3115. GetConsoleScreenBufferInfo(g_hCurOut, &csbi);
  3117. coord2.X += (SHORT) (csbi.srWindow.Left);
  3118. coord2.Y += (SHORT) (csbi.srWindow.Bottom + 1 - Rows);
  3119.     }
  3121.     FillConsoleOutputAttribute(g_hCurOut, g_attrCurrent, cchToWrite,
  3122.        coord2, pcchWritten);
  3123.     f = WriteConsoleOutputCharacter(g_hCurOut, pchBuf, cchToWrite,
  3124.     coord2, pcchWritten);
  3126.     g_coord.X += (SHORT) *pcchWritten;
  3128.     while (g_coord.X > g_srScrollRegion.Right)
  3129.     {
  3130. g_coord.X -= (SHORT) Columns;
  3131. if (g_coord.Y < g_srScrollRegion.Bottom)
  3132.     g_coord.Y++;
  3133.     }
  3135.     gotoxy(g_coord.X + 1, g_coord.Y + 1);
  3137.     return f;
  3138. }
  3141. /*
  3142.  * mch_write(): write the output buffer to the screen, translating ESC
  3143.  * sequences into calls to console output routines.
  3144.  */
  3145.     void
  3146. mch_write(
  3147.     char_u  *s,
  3148.     int     len)
  3149. {
  3150.     s[len] = NUL;
  3152.     if (!term_console)
  3153.     {
  3154. write(1, s, (unsigned) len);
  3155. return;
  3156.     }
  3158.     /* translate ESC | sequences into faked bios calls */
  3159.     while (len--)
  3160.     {
  3161. /* optimization: use one single write_chars for runs of text,
  3162.  * rather than once per character  It ain't curses, but it helps. */
  3164. DWORD  prefix = strcspn(s, "nrba33");
  3166. if (p_wd)
  3167. {
  3168.     WaitForChar(p_wd);
  3169.     if (prefix)
  3170. prefix = 1;
  3171. }
  3173. if (prefix)
  3174. {
  3175.     DWORD nWritten;
  3177.     if (write_chars(s, prefix, &nWritten))
  3178.     {
  3179. #ifdef MCH_WRITE_DUMP
  3180. if (fdDump)
  3181. {
  3182.     fputc('>', fdDump);
  3183.     fwrite(s, sizeof(char_u), nWritten, fdDump);
  3184.     fputs("<n", fdDump);
  3185. }
  3186. #endif
  3187. len -= (nWritten - 1);
  3188. s += nWritten;
  3189.     }
  3190. }
  3191. else if (s[0] == 'n')
  3192. {
  3193.     /* n, newline: go to the beginning of the next line or scroll */
  3194.     if (g_coord.Y == g_srScrollRegion.Bottom)
  3195.     {
  3196. scroll(1);
  3197. gotoxy(g_srScrollRegion.Left + 1, g_srScrollRegion.Bottom + 1);
  3198.     }
  3199.     else
  3200.     {
  3201. gotoxy(g_srScrollRegion.Left + 1, g_coord.Y + 2);
  3202.     }
  3203. #ifdef MCH_WRITE_DUMP
  3204.     if (fdDump)
  3205. fputs("\nn", fdDump);
  3206. #endif
  3207.     s++;
  3208. }
  3209. else if (s[0] == 'r')
  3210. {
  3211.     /* r, carriage return: go to beginning of line */
  3212.     gotoxy(g_srScrollRegion.Left+1, g_coord.Y + 1);
  3213. #ifdef MCH_WRITE_DUMP
  3214.     if (fdDump)
  3215. fputs("\rn", fdDump);
  3216. #endif
  3217.     s++;
  3218. }
  3219. else if (s[0] == 'b')
  3220. {
  3221.     /* b, backspace: move cursor one position left */
  3222.     if (g_coord.X > g_srScrollRegion.Left)
  3223. g_coord.X--;
  3224.     else if (g_coord.Y > g_srScrollRegion.Top)
  3225.     {
  3226. g_coord.X = g_srScrollRegion.Right;
  3227. g_coord.Y--;
  3228.     }
  3229.     gotoxy(g_coord.X + 1, g_coord.Y + 1);
  3230. #ifdef MCH_WRITE_DUMP
  3231.     if (fdDump)
  3232. fputs("\bn", fdDump);
  3233. #endif
  3234.     s++;
  3235. }
  3236. else if (s[0] == 'a')
  3237. {
  3238.     /* a, bell */
  3239.     MessageBeep(0xFFFFFFFF);
  3240. #ifdef MCH_WRITE_DUMP
  3241.     if (fdDump)
  3242. fputs("\an", fdDump);
  3243. #endif
  3244.     s++;
  3245. }
  3246. else if (s[0] == ESC && len >= 3-1 && s[1] == '|')
  3247. {
  3248. #ifdef MCH_WRITE_DUMP
  3249.     char_u* old_s = s;
  3250. #endif
  3251.     char_u* p;
  3252.     int arg1 = 0, arg2 = 0;
  3254.     switch (s[2])
  3255.     {
  3256.     /* one or two numeric arguments, separated by ';' */
  3258.     case '0': case '1': case '2': case '3': case '4':
  3259.     case '5': case '6': case '7': case '8': case '9':
  3260. p = s + 2;
  3261. arg1 = getdigits(&p);     /* no check for length! */
  3262. if (p > s + len)
  3263.     break;
  3265. if (*p == ';')
  3266. {
  3267.     ++p;
  3268.     arg2 = getdigits(&p);   /* no check for length! */
  3269.     if (p > s + len)
  3270. break;
  3272.     if (*p == 'H')
  3273. gotoxy(arg2, arg1);
  3274.     else if (*p == 'r')
  3275. set_scroll_region(0, arg1 - 1, Columns - 1, arg2 - 1);
  3276. }
  3277. else if (*p == 'A')
  3278. {
  3279.     /* move cursor up arg1 lines in same column */
  3280.     gotoxy(g_coord.X + 1,
  3281.    max(g_srScrollRegion.Top, g_coord.Y - arg1) + 1);
  3282. }
  3283. else if (*p == 'C')
  3284. {
  3285.     /* move cursor right arg1 columns in same line */
  3286.     gotoxy(min(g_srScrollRegion.Right, g_coord.X + arg1) + 1,
  3287.    g_coord.Y + 1);
  3288. }
  3289. else if (*p == 'H')
  3290. {
  3291.     gotoxy(1, arg1);
  3292. }
  3293. else if (*p == 'L')
  3294. {
  3295.     insert_lines(arg1);
  3296. }
  3297. else if (*p == 'm')
  3298. {
  3299.     if (arg1 == 0)
  3300. normvideo();
  3301.     else
  3302. textattr((WORD) arg1);
  3303. }
  3304. else if (*p == 'f')
  3305. {
  3306.     textcolor((WORD) arg1);
  3307. }
  3308. else if (*p == 'b')
  3309. {
  3310.     textbackground((WORD) arg1);
  3311. }
  3312. else if (*p == 'M')
  3313. {
  3314.     delete_lines(arg1);
  3315. }
  3317. len -= p - s;
  3318. s = p + 1;
  3319. break;
  3322.     /* Three-character escape sequences */
  3324.     case 'A':
  3325. /* move cursor up one line in same column */
  3326. gotoxy(g_coord.X + 1,
  3327.        max(g_srScrollRegion.Top, g_coord.Y - 1) + 1);
  3328. goto got3;
  3330.     case 'B':
  3331. visual_bell();
  3332. goto got3;
  3334.     case 'C':
  3335. /* move cursor right one column in same line */
  3336. gotoxy(min(g_srScrollRegion.Right, g_coord.X + 1) + 1,
  3337.        g_coord.Y + 1);
  3338. goto got3;
  3340.     case 'E':
  3341. termcap_mode_end();
  3342. goto got3;
  3344.     case 'F':
  3345. standout();
  3346. goto got3;
  3348.     case 'f':
  3349. standend();
  3350. goto got3;
  3352.     case 'H':
  3353. gotoxy(1, 1);
  3354. goto got3;
  3356.     case 'j':
  3357. clear_to_end_of_display();
  3358. goto got3;
  3360.     case 'J':
  3361. clear_screen();
  3362. goto got3;
  3364.     case 'K':
  3365. clear_to_end_of_line();
  3366. goto got3;
  3368.     case 'L':
  3369. insert_lines(1);
  3370. goto got3;
  3372.     case 'M':
  3373. delete_lines(1);
  3374. goto got3;
  3376.     case 'S':
  3377. termcap_mode_start();
  3378. goto got3;
  3380.     case 'V':
  3381. cursor_visible(TRUE);
  3382. goto got3;
  3384.     case 'v':
  3385. cursor_visible(FALSE);
  3386. goto got3;
  3388.     got3:
  3389. s += 3;
  3390. len -= 2;
  3391.     }
  3393. #ifdef MCH_WRITE_DUMP
  3394.     if (fdDump)
  3395.     {
  3396. fputs("ESC | ", fdDump);
  3397. fwrite(old_s + 2, sizeof(char_u), s - old_s - 2, fdDump);
  3398. fputc('n', fdDump);
  3399.     }
  3400. #endif
  3401. }
  3402. else
  3403. {
  3404.     /* Write a single character */
  3405.     DWORD nWritten;
  3407.     if (write_chars(s, 1, &nWritten))
  3408.     {
  3409. #ifdef MCH_WRITE_DUMP
  3410. if (fdDump)
  3411. {
  3412.     fputc('>', fdDump);
  3413.     fwrite(s, sizeof(char_u), nWritten, fdDump);
  3414.     fputs("<n", fdDump);
  3415. }
  3416. #endif
  3418. len -= (nWritten - 1);
  3419. s += nWritten;
  3420.     }
  3421. }
  3422.     }
  3424. #ifdef MCH_WRITE_DUMP
  3425.     if (fdDump)
  3426. fflush(fdDump);
  3427. #endif
  3428. }
  3430. #endif /* USE_GUI_WIN32 */
  3433. /*
  3434.  * Delay for half a second.
  3435.  */
  3436.     void
  3437. mch_delay(
  3438.     long    msec,
  3439.     int     ignoreinput)
  3440. {
  3441. #ifdef USE_GUI_WIN32
  3442.     Sleep((int)msec);     /* never wait for input */
  3443. #else
  3444.     if (ignoreinput)
  3445. Sleep((int)msec);
  3446.     else
  3447. WaitForChar(msec);
  3448. #endif
  3449. }
  3452. /*
  3453.  * this version of remove is not scared by a readonly (backup) file
  3454.  */
  3455.     int
  3456. mch_remove(char_u *name)
  3457. {
  3458.     SetFileAttributes(name, FILE_ATTRIBUTE_NORMAL);
  3459.     return DeleteFile(name) ? 0 : -1;
  3460. }
  3463. /*
  3464.  * check for an "interrupt signal": CTRL-break or CTRL-C
  3465.  */
  3466.     void
  3467. mch_breakcheck()
  3468. {
  3469. #ifndef USE_GUI_WIN32     /* never used */
  3470.     if (g_fCtrlCPressed || g_fCBrkPressed)
  3471.     {
  3472. g_fCtrlCPressed = g_fCBrkPressed = FALSE;
  3473. got_int = TRUE;
  3474.     }
  3475. #endif
  3476. }
  3479. /*
  3480.  * How much memory is available?
  3481.  */
  3482.     long_u
  3483. mch_avail_mem(
  3484.     int special)
  3485. {
  3486.     return LONG_MAX;     /* virtual memory, eh? */
  3487. }
  3490. /*
  3491.  * return non-zero if a character is available
  3492.  */
  3493.     int
  3494. mch_char_avail()
  3495. {
  3496. #ifdef USE_GUI_WIN32
  3497.     /* never used */
  3498.     return TRUE;
  3499. #else
  3500.     return WaitForChar(0L);
  3501. #endif
  3502. }
  3505. /*
  3506.  * set screen mode, always fails.
  3507.  */
  3508.     int
  3509. mch_screenmode(
  3510.     char_u *arg)
  3511. {
  3512.     EMSG("Screen mode setting not supported");
  3513.     return FAIL;
  3514. }
  3517. /*
  3518.  * mch_rename() works around a bug in rename (aka MoveFile) in
  3519.  * Windows 95: rename("foo.bar", "foo.bar~") will generate a
  3520.  * file whose short file name is "FOO.BAR" (its long file name will
  3521.  * be correct: "foo.bar~").  Because a file can be accessed by
  3522.  * either its SFN or its LFN, "foo.bar" has effectively been
  3523.  * renamed to "foo.bar", which is not at all what was wanted.  This
  3524.  * seems to happen only when renaming files with three-character
  3525.  * extensions by appending a suffix that does not include ".".
  3526.  * Windows NT gets it right, however, with an SFN of "FOO~1.BAR".
  3527.  *
  3528.  * Like rename(), returns 0 upon success, non-zero upon failure.
  3529.  * Should probably set errno appropriately when errors occur.
  3530.  */
  3531.     int
  3532. mch_rename(
  3533.     const char *pszOldFile,
  3534.     const char *pszNewFile)
  3535. {
  3536.     char szTempFile[_MAX_PATH+1];
  3537.     char szNewPath[_MAX_PATH+1];
  3538.     char *pszFilePart;
  3539.     HANDLE hf;
  3541.     /*
  3542.      * No need to play tricks if not running Windows 95
  3543.      */
  3544.     if (!mch_windows95())
  3545. return rename(pszOldFile, pszNewFile);
  3547.     /* get base path of new file name */
  3548.     if (GetFullPathName(pszNewFile, _MAX_PATH, szNewPath, &pszFilePart) == 0)
  3549. return -1;
  3550.     else
  3551. *pszFilePart = NUL;
  3553.     /* Get (and create) a unique temporary file name in directory of new file */
  3554.     if (GetTempFileName(szNewPath, "VIM", 0, szTempFile) == 0)
  3555. return -2;
  3557.     /* blow the temp file away */
  3558.     if (!DeleteFile(szTempFile))
  3559. return -3;
  3561.     /* rename old file to the temp file */
  3562.     if (!MoveFile(pszOldFile, szTempFile))
  3563. return -4;
  3565.     /* now create an empty file called pszOldFile; this prevents the operating
  3566.      * system using pszOldFile as an alias (SFN) if we're renaming within the
  3567.      * same directory.  For example, we're editing a file called
  3568.      * filename.asc.txt by its SFN, filena~1.txt.  If we rename filena~1.txt
  3569.      * to filena~1.txt~ (i.e., we're making a backup while writing it), the
  3570.      * SFN for filena~1.txt~ will be filena~1.txt, by default, which will
  3571.      * cause all sorts of problems later in buf_write.  So, we create an empty
  3572.      * file called filena~1.txt and the system will have to find some other
  3573.      * SFN for filena~1.txt~, such as filena~2.txt
  3574.      */
  3575.     if ((hf = CreateFile(pszOldFile, GENERIC_WRITE, 0, NULL, CREATE_NEW,
  3576.     FILE_ATTRIBUTE_NORMAL, NULL)) == INVALID_HANDLE_VALUE)
  3577. return -5;
  3578.     if (!CloseHandle(hf))
  3579. return -6;
  3581.     /* rename the temp file to the new file */
  3582.     if (!MoveFile(szTempFile, pszNewFile))
  3583. return -7;
  3585.     /* Seems to be left around on Novell filesystems */
  3586.     DeleteFile(szTempFile);
  3588.     /* finally, remove the empty old file */
  3589.     if (!DeleteFile(pszOldFile))
  3590. return -8;
  3592.     return 0; /* success */
  3593. }
  3595. /*
  3596.  * Special version of getenv(): use $HOME when $VIM not defined.
  3597.  */
  3598.     char_u *
  3599. mch_getenv(char_u *var)
  3600. {
  3601.     char_u  *retval;
  3602.     retval = (char_u *)getenv((char *)var);
  3604.     if (retval == NULL && STRCMP(var, "VIM") == 0)
  3605. retval = (char_u *)getenv("HOME");
  3607. #ifdef MCH_WRITE_DUMP
  3608.     if (fdDump)
  3609.     {
  3610. fprintf(fdDump, "$%s = "%s"n", var, retval);
  3611. fflush(fdDump);
  3612.     }
  3613. #endif
  3615.     return retval;
  3616. }
  3619. /*
  3620.  * Get the default shell for the current hardware platform
  3621.  */
  3622.     char*
  3623. default_shell()
  3624. {
  3625.     char* psz = NULL;
  3627.     PlatformId();
  3629.     if (g_PlatformId == VER_PLATFORM_WIN32_NT) /* Windows NT */
  3630. psz = "cmd.exe";
  3631.     else if (g_PlatformId == VER_PLATFORM_WIN32_WINDOWS) /* Windows 95 */
  3632. psz = "command.com";
  3634.     return psz;
  3635. }
  3638. #ifdef USE_CLIPBOARD
  3639. /*
  3640.  * Clipboard stuff, for cutting and pasting text to other windows.
  3641.  */
  3643. /*
  3644.  * Get the current selection and put it in the clipboard register.
  3645.  *
  3646.  * NOTE: Must use GlobalLock/Unlock here to ensure Win32s compatibility.
  3647.  * On NT/W95 the clipboard data is a fixed global memory object and
  3648.  * so its handle = its pointer.
  3649.  * On Win32s, however, co-operation with the Win16 system means that
  3650.  * the clipboard data is moveable and its handle is not a pointer at all,
  3651.  * so we can't just cast the return value of GetClipboardData to (char_u*).
  3652.  * <VN>
  3653.  */
  3654.     void
  3655. clip_mch_request_selection()
  3656. {
  3657.     int     type;
  3658.     HGLOBAL hMem;
  3659.     char_u  *str = NULL;
  3661.     /*
  3662.      * Don't pass GetActiveWindow() as an argument to OpenClipboard() because
  3663.      * then we can't paste back into the same window for some reason - webb.
  3664.      */
  3665.     if (OpenClipboard(NULL))
  3666.     {
  3667. /* Check for vim's own clipboard format first */
  3668. if ((hMem = GetClipboardData(clipboard.format)) != NULL)
  3669. {
  3670.     str = (char_u *)GlobalLock(hMem);
  3671.     if (str != NULL)
  3672. switch (*str++)
  3673. {
  3674.     default:
  3675.     case 'L': type = MLINE; break;
  3676.     case 'C': type = MCHAR; break;
  3677.     case 'B': type = MBLOCK; break;
  3678. }
  3679. /* TRACE("Got '%c' typen", str[-1]); */
  3680. }
  3681. /* Otherwise, check for the normal text format */
  3682. else if ((hMem = GetClipboardData(CF_TEXT)) != NULL)
  3683. {
  3684.     str = (char_u *)GlobalLock(hMem);
  3685.     if (str != NULL)
  3686. type = (vim_strchr((char*) str, 'r') != NULL) ? MLINE : MCHAR;
  3687.     /* TRACE("TEXTn"); */
  3688. }
  3690. if (hMem != NULL && str != NULL)
  3691. {
  3692.     /*successful lock - must unlock when finished*/
  3693.     if (*str != NUL)
  3694.     {
  3695. LPCSTR psz = (LPCSTR)str;
  3696. char_u *temp_clipboard = (char_u *)lalloc(STRLEN(psz) + 1, TRUE);
  3697. char_u *pszTemp = temp_clipboard;
  3699. if (temp_clipboard != NULL)
  3700. {
  3701.     while (*psz != NUL)
  3702.     {
  3703. const char* pszNL = strchr(psz, 'r');
  3704. const int len = (pszNL != NULL) ?
  3705.     pszNL - psz : STRLEN(psz);
  3706. STRNCPY(pszTemp, psz, len);
  3707. pszTemp += len;
  3708. if (pszNL != NULL)
  3709.     *pszTemp++ = 'n';
  3710. psz += len + ((pszNL != NULL) ? 2 : 0);
  3711.     }
  3712.     *pszTemp = NUL;
  3713.     clip_yank_selection(type, temp_clipboard,
  3714. (long)(pszTemp - temp_clipboard));
  3715.     vim_free(temp_clipboard);
  3716. }
  3717.     }
  3718.     /*unlock the global object*/
  3719.     (void)GlobalUnlock(hMem);
  3720. }
  3721. CloseClipboard();
  3722.     }
  3723. }
  3725. /*
  3726.  * Make vim the owner of the current selection.
  3727.  */
  3728.     void
  3729. clip_mch_lose_selection()
  3730. {
  3731.     /* Nothing needs to be done here */
  3732. }
  3734. /*
  3735.  * Make vim the owner of the current selection.  Return OK upon success.
  3736.  */
  3737.     int
  3738. clip_mch_own_selection()
  3739. {
  3740.     /*
  3741.      * Never actually own the clipboard.  If another application sets the
  3742.      * clipboard, we don't want to think that we still own it.
  3743.      */
  3744.     return FAIL;
  3745. }
  3747. /*
  3748.  * Send the current selection to the clipboard.
  3749.  */
  3750.     void
  3751. clip_mch_set_selection()
  3752. {
  3753.     char_u  *str = NULL;
  3754.     long_u  cch;
  3755.     int     type;
  3756.     HGLOBAL hMem = NULL;
  3757.     HGLOBAL hMemVim = NULL;
  3758.     LPSTR   lpszMem = NULL;
  3759.     LPSTR   lpszMemVim = NULL;
  3761.     /* If the '*' register isn't already filled in, fill it in now */
  3762.     clipboard.owned = TRUE;
  3763.     clip_get_selection();
  3764.     clipboard.owned = FALSE;
  3766.     type = clip_convert_selection(&str, &cch);
  3768.     if (type < 0)
  3769. return;
  3771.     if ((hMem = GlobalAlloc(GMEM_MOVEABLE | GMEM_DDESHARE, cch+1)) != NULL
  3772. && (lpszMem = (LPSTR)GlobalLock(hMem)) != NULL
  3773. && (hMemVim = GlobalAlloc(GMEM_MOVEABLE|GMEM_DDESHARE, cch+2)) != NULL
  3774. && (lpszMemVim = (LPSTR)GlobalLock(hMemVim)) != NULL)
  3775.     {
  3776. switch (type)
  3777. {
  3778.     default:
  3779.     case MLINE:     *lpszMemVim++ = 'L';    break;
  3780.     case MCHAR:     *lpszMemVim++ = 'C';    break;
  3781.     case MBLOCK:    *lpszMemVim++ = 'B';    break;
  3782. }
  3784. STRNCPY(lpszMem, str, cch);
  3785. lpszMem[cch] = NUL;
  3787. STRNCPY(lpszMemVim, str, cch);
  3788. lpszMemVim[cch] = NUL;
  3790. /*
  3791.  * Don't pass GetActiveWindow() as an argument to OpenClipboard()
  3792.  * because then we can't paste back into the same window for some
  3793.  * reason - webb.
  3794.  */
  3795. if (OpenClipboard(NULL))
  3796. {
  3797.     if (EmptyClipboard())
  3798.     {
  3799. SetClipboardData(clipboard.format, hMemVim);
  3800. SetClipboardData(CF_TEXT, hMem);
  3801.     }
  3803.     CloseClipboard();
  3804. }
  3805.     }
  3806.     if (lpszMem != NULL)
  3807. GlobalUnlock(hMem);
  3808.     if (lpszMemVim != NULL)
  3809. GlobalUnlock(hMemVim);
  3811.     vim_free(str);
  3812. }
  3814. #endif /* USE_CLIPBOARD */
  3817. /*
  3818.  * Debugging helper: expose the MCH_WRITE_DUMP stuff to other modules
  3819.  */
  3820.     void
  3821. DumpPutS(
  3822.     const char* psz)
  3823. {
  3824. # ifdef MCH_WRITE_DUMP
  3825.     if (fdDump)
  3826.     {
  3827. fputs(psz, fdDump);
  3828. if (psz[strlen(psz) - 1] != 'n')
  3829.     fputc('n', fdDump);
  3830. fflush(fdDump);
  3831.     }
  3832. # endif
  3833. }
  3835. #ifdef _DEBUG
  3837. void __cdecl
  3838. Trace(
  3839.     char *pszFormat,
  3840.     ...)
  3841. {
  3842.     CHAR szBuff[2048];
  3843.     va_list args;
  3845.     va_start(args, pszFormat);
  3846.     vsprintf(szBuff, pszFormat, args);
  3847.     va_end(args);
  3849.     OutputDebugString(szBuff);
  3850. }
  3852. #endif //_DEBUG