[vim] - patchlevel 240
Karsten Hopp
karsten at fedoraproject.org
Mon Jul 11 14:21:23 UTC 2011
commit 2ea7b0d285d69a7c510b9d30a2fe5b80a90cc927
Author: Karsten Hopp <karsten at redhat.com>
Date: Mon Jul 11 16:20:32 2011 +0200
- patchlevel 240
7.3.240 | 795 +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
1 files changed, 795 insertions(+), 0 deletions(-)
---
diff --git a/7.3.240 b/7.3.240
new file mode 100644
index 0000000..7048ac1
--- /dev/null
+++ b/7.3.240
@@ -0,0 +1,795 @@
+To: vim_dev at googlegroups.com
+Subject: Patch 7.3.240
+Fcc: outbox
+From: Bram Moolenaar <Bram at moolenaar.net>
+Mime-Version: 1.0
+Content-Type: text/plain; charset=UTF-8
+Content-Transfer-Encoding: 8bit
+------------
+
+Note: I haven't verified this works or even compiles. Please send me a
+patch if you see a problem and can fix it.
+
+Patch 7.3.240
+Problem: External commands can't use pipes on MS-Windows.
+Solution: Implement pipes and use them when 'shelltemp' isn't set. (Vincent
+ Berthoux)
+Files: src/eval.c, src/ex_cmds.c, src/misc2.c, src/os_unix.c,
+ src/os_win32.c, src/proto/misc2.pro, src/ui.c
+
+
+*** ../vim-7.3.239/src/eval.c 2011-06-19 02:55:32.000000000 +0200
+--- src/eval.c 2011-07-07 15:44:56.000000000 +0200
+***************
+*** 11931,11937 ****
+ #ifdef FEAT_SEARCHPATH
+ "file_in_path",
+ #endif
+! #if defined(UNIX) && !defined(USE_SYSTEM)
+ "filterpipe",
+ #endif
+ #ifdef FEAT_FIND_ID
+--- 11931,11937 ----
+ #ifdef FEAT_SEARCHPATH
+ "file_in_path",
+ #endif
+! #if (defined(UNIX) && !defined(USE_SYSTEM)) || defined(WIN3264)
+ "filterpipe",
+ #endif
+ #ifdef FEAT_FIND_ID
+*** ../vim-7.3.239/src/ex_cmds.c 2011-06-12 22:03:15.000000000 +0200
+--- src/ex_cmds.c 2011-07-07 15:44:56.000000000 +0200
+***************
+*** 1107,1113 ****
+ if (do_out)
+ shell_flags |= SHELL_DOOUT;
+
+! #if !defined(USE_SYSTEM) && defined(UNIX)
+ if (!do_in && do_out && !p_stmp)
+ {
+ /* Use a pipe to fetch stdout of the command, do not use a temp file. */
+--- 1107,1113 ----
+ if (do_out)
+ shell_flags |= SHELL_DOOUT;
+
+! #if (!defined(USE_SYSTEM) && defined(UNIX)) || defined(WIN3264)
+ if (!do_in && do_out && !p_stmp)
+ {
+ /* Use a pipe to fetch stdout of the command, do not use a temp file. */
+*** ../vim-7.3.239/src/misc2.c 2011-07-07 15:08:53.000000000 +0200
+--- src/misc2.c 2011-07-07 15:55:42.000000000 +0200
+***************
+*** 2146,2151 ****
+--- 2146,2170 ----
+ }
+ }
+
++ #if (defined(UNIX) && !defined(USE_SYSTEM)) || defined(WIN3264)
++ /*
++ * Append the text in "gap" below the cursor line and clear "gap".
++ */
++ void
++ append_ga_line(gap)
++ garray_T *gap;
++ {
++ /* Remove trailing CR. */
++ if (gap->ga_len > 0
++ && !curbuf->b_p_bin
++ && ((char_u *)gap->ga_data)[gap->ga_len - 1] == CAR)
++ --gap->ga_len;
++ ga_append(gap, NUL);
++ ml_append(curwin->w_cursor.lnum++, gap->ga_data, 0, FALSE);
++ gap->ga_len = 0;
++ }
++ #endif
++
+ /************************************************************************
+ * functions that use lookup tables for various things, generally to do with
+ * special key codes.
+*** ../vim-7.3.239/src/os_unix.c 2011-04-11 16:56:29.000000000 +0200
+--- src/os_unix.c 2011-07-07 15:54:58.000000000 +0200
+***************
+*** 3660,3686 ****
+ /* Nothing to do. */
+ }
+
+- #ifndef USE_SYSTEM
+- static void append_ga_line __ARGS((garray_T *gap));
+-
+- /*
+- * Append the text in "gap" below the cursor line and clear "gap".
+- */
+- static void
+- append_ga_line(gap)
+- garray_T *gap;
+- {
+- /* Remove trailing CR. */
+- if (gap->ga_len > 0
+- && !curbuf->b_p_bin
+- && ((char_u *)gap->ga_data)[gap->ga_len - 1] == CAR)
+- --gap->ga_len;
+- ga_append(gap, NUL);
+- ml_append(curwin->w_cursor.lnum++, gap->ga_data, 0, FALSE);
+- gap->ga_len = 0;
+- }
+- #endif
+-
+ int
+ mch_call_shell(cmd, options)
+ char_u *cmd;
+--- 3660,3665 ----
+*** ../vim-7.3.239/src/os_win32.c 2011-05-25 17:06:16.000000000 +0200
+--- src/os_win32.c 2011-07-07 16:08:30.000000000 +0200
+***************
+*** 417,422 ****
+--- 417,427 ----
+ static PGNSECINFO pGetNamedSecurityInfo;
+ #endif
+
++ typedef BOOL (WINAPI *PSETHANDLEINFORMATION)(HANDLE, DWORD, DWORD);
++
++ static BOOL allowPiping = FALSE;
++ static PSETHANDLEINFORMATION pSetHandleInformation;
++
+ /*
+ * Set g_PlatformId to VER_PLATFORM_WIN32_NT (NT) or
+ * VER_PLATFORM_WIN32_WINDOWS (Win95).
+***************
+*** 467,472 ****
+--- 472,489 ----
+ }
+ }
+ #endif
++ /*
++ * If we are on windows NT, try to load the pipe functions, only
++ * available from Win2K.
++ */
++ if (g_PlatformId == VER_PLATFORM_WIN32_NT)
++ {
++ HANDLE kernel32 = GetModuleHandle("kernel32");
++ pSetHandleInformation = (PSETHANDLEINFORMATION)GetProcAddress(
++ kernel32, "SetHandleInformation");
++
++ allowPiping = pSetHandleInformation != NULL;
++ }
+ done = TRUE;
+ }
+ }
+***************
+*** 1635,1641 ****
+ }
+
+ #if ((defined(__MINGW32__) || defined (__CYGWIN32__)) && \
+! __MSVCRT_VERSION__ >= 0x800) || (defined(_MSC_VER) && _MSC_VER >= 1400)
+ /*
+ * Bad parameter handler.
+ *
+--- 1652,1658 ----
+ }
+
+ #if ((defined(__MINGW32__) || defined (__CYGWIN32__)) && \
+! __MSVCRT_VERSION__ >= 0x800) || (defined(_MSC_VER) && _MSC_VER >= 1400)
+ /*
+ * Bad parameter handler.
+ *
+***************
+*** 3210,3216 ****
+ * 4. Prompt the user to press a key to close the console window
+ */
+ static int
+! mch_system(char *cmd, int options)
+ {
+ STARTUPINFO si;
+ PROCESS_INFORMATION pi;
+--- 3227,3233 ----
+ * 4. Prompt the user to press a key to close the console window
+ */
+ static int
+! mch_system_classic(char *cmd, int options)
+ {
+ STARTUPINFO si;
+ PROCESS_INFORMATION pi;
+***************
+*** 3315,3320 ****
+--- 3332,3829 ----
+
+ return ret;
+ }
++
++ /*
++ * Thread launched by the gui to send the current buffer data to the
++ * process. This way avoid to hang up vim totally if the children
++ * process take a long time to process the lines.
++ */
++ static DWORD WINAPI
++ sub_process_writer(LPVOID param)
++ {
++ HANDLE g_hChildStd_IN_Wr = param;
++ linenr_T lnum = curbuf->b_op_start.lnum;
++ DWORD len = 0;
++ DWORD l;
++ char_u *lp = ml_get(lnum);
++ char_u *s;
++ int written = 0;
++
++ for (;;)
++ {
++ l = (DWORD)STRLEN(lp + written);
++ if (l == 0)
++ len = 0;
++ else if (lp[written] == NL)
++ {
++ /* NL -> NUL translation */
++ WriteFile(g_hChildStd_IN_Wr, "", 1, &len, NULL);
++ }
++ else
++ {
++ s = vim_strchr(lp + written, NL);
++ WriteFile(g_hChildStd_IN_Wr, (char *)lp + written,
++ s == NULL ? l : (DWORD)(s - (lp + written)),
++ &len, NULL);
++ }
++ if (len == (int)l)
++ {
++ /* Finished a line, add a NL, unless this line should not have
++ * one. */
++ if (lnum != curbuf->b_op_end.lnum
++ || !curbuf->b_p_bin
++ || (lnum != curbuf->b_no_eol_lnum
++ && (lnum != curbuf->b_ml.ml_line_count
++ || curbuf->b_p_eol)))
++ {
++ WriteFile(g_hChildStd_IN_Wr, "\n", 1, &ignored, NULL);
++ }
++
++ ++lnum;
++ if (lnum > curbuf->b_op_end.lnum)
++ break;
++
++ lp = ml_get(lnum);
++ written = 0;
++ }
++ else if (len > 0)
++ written += len;
++ }
++
++ /* finished all the lines, close pipe */
++ CloseHandle(g_hChildStd_IN_Wr);
++ ExitThread(0);
++ }
++
++
++ # define BUFLEN 100 /* length for buffer, stolen from unix version */
++
++ /*
++ * This function read from the children's stdout and write the
++ * data on screen or in the buffer accordingly.
++ */
++ static void
++ dump_pipe(int options,
++ HANDLE g_hChildStd_OUT_Rd,
++ garray_T *ga,
++ char_u buffer[],
++ DWORD *buffer_off)
++ {
++ DWORD availableBytes = 0;
++ DWORD i;
++ int c;
++ char_u *p;
++ int ret;
++ DWORD len;
++ DWORD toRead;
++ int repeatCount;
++
++ /* we query the pipe to see if there is any data to read
++ * to avoid to perform a blocking read */
++ ret = PeekNamedPipe(g_hChildStd_OUT_Rd, /* pipe to query */
++ NULL, /* optional buffer */
++ 0, /* buffe size */
++ NULL, /* number of read bytes */
++ &availableBytes, /* available bytes total */
++ NULL); /* byteLeft */
++
++ repeatCount = 0;
++ /* We got real data in the pipe, read it */
++ while (ret != 0 && availableBytes > 0 && availableBytes > 0)
++ {
++ repeatCount++;
++ toRead =
++ # ifdef FEAT_MBYTE
++ (DWORD)(BUFLEN - *buffer_off);
++ # else
++ (DWORD)BUFLEN;
++ # endif
++ toRead = availableBytes < toRead ? availableBytes : toRead;
++ ReadFile(g_hChildStd_OUT_Rd, buffer
++ # ifdef FEAT_MBYTE
++ + *buffer_off, toRead
++ # else
++ , toRead
++ # endif
++ , &len, NULL);
++
++ /* If we haven't read anything, there is a problem */
++ if (len == 0)
++ break;
++
++ availableBytes -= len;
++
++ if (options & SHELL_READ)
++ {
++ /* Do NUL -> NL translation, append NL separated
++ * lines to the current buffer. */
++ for (i = 0; i < len; ++i)
++ {
++ if (buffer[i] == NL)
++ append_ga_line(ga);
++ else if (buffer[i] == NUL)
++ ga_append(ga, NL);
++ else
++ ga_append(ga, buffer[i]);
++ }
++ }
++ # ifdef FEAT_MBYTE
++ else if (has_mbyte)
++ {
++ int l;
++
++ len += *buffer_off;
++ buffer[len] = NUL;
++
++ /* Check if the last character in buffer[] is
++ * incomplete, keep these bytes for the next
++ * round. */
++ for (p = buffer; p < buffer + len; p += l)
++ {
++ l = mb_cptr2len(p);
++ if (l == 0)
++ l = 1; /* NUL byte? */
++ else if (MB_BYTE2LEN(*p) != l)
++ break;
++ }
++ if (p == buffer) /* no complete character */
++ {
++ /* avoid getting stuck at an illegal byte */
++ if (len >= 12)
++ ++p;
++ else
++ {
++ *buffer_off = len;
++ return;
++ }
++ }
++ c = *p;
++ *p = NUL;
++ msg_puts(buffer);
++ if (p < buffer + len)
++ {
++ *p = c;
++ *buffer_off = (DWORD)((buffer + len) - p);
++ mch_memmove(buffer, p, *buffer_off);
++ return;
++ }
++ *buffer_off = 0;
++ }
++ # endif /* FEAT_MBYTE */
++ else
++ {
++ buffer[len] = NUL;
++ msg_puts(buffer);
++ }
++
++ windgoto(msg_row, msg_col);
++ cursor_on();
++ out_flush();
++ }
++ }
++
++ /*
++ * Version of system to use for windows NT > 5.0 (Win2K), use pipe
++ * for communication and doesn't open any new window.
++ */
++ static int
++ mch_system_piped(char *cmd, int options)
++ {
++ STARTUPINFO si;
++ PROCESS_INFORMATION pi;
++ DWORD ret = 0;
++
++ HANDLE g_hChildStd_IN_Rd = NULL;
++ HANDLE g_hChildStd_IN_Wr = NULL;
++ HANDLE g_hChildStd_OUT_Rd = NULL;
++ HANDLE g_hChildStd_OUT_Wr = NULL;
++
++ char_u buffer[BUFLEN + 1]; /* reading buffer + size */
++ DWORD len;
++
++ /* buffer used to receive keys */
++ char_u ta_buf[BUFLEN + 1]; /* TypeAHead */
++ int ta_len = 0; /* valid bytes in ta_buf[] */
++
++ DWORD i;
++ int c;
++ int noread_cnt = 0;
++ garray_T ga;
++ int delay = 1;
++ # ifdef FEAT_MBYTE
++ DWORD buffer_off = 0; /* valid bytes in buffer[] */
++ # endif
++
++ SECURITY_ATTRIBUTES saAttr;
++
++ /* Set the bInheritHandle flag so pipe handles are inherited. */
++ saAttr.nLength = sizeof(SECURITY_ATTRIBUTES);
++ saAttr.bInheritHandle = TRUE;
++ saAttr.lpSecurityDescriptor = NULL;
++
++ if ( ! CreatePipe(&g_hChildStd_OUT_Rd, &g_hChildStd_OUT_Wr, &saAttr, 0)
++ /* Ensure the read handle to the pipe for STDOUT is not inherited. */
++ || ! pSetHandleInformation(g_hChildStd_OUT_Rd, HANDLE_FLAG_INHERIT, 0)
++ /* Create a pipe for the child process's STDIN. */
++ || ! CreatePipe(&g_hChildStd_IN_Rd, &g_hChildStd_IN_Wr, &saAttr, 0)
++ /* Ensure the write handle to the pipe for STDIN is not inherited. */
++ || ! pSetHandleInformation(g_hChildStd_IN_Wr, HANDLE_FLAG_INHERIT, 0) )
++ {
++ CloseHandle(g_hChildStd_IN_Rd);
++ CloseHandle(g_hChildStd_IN_Wr);
++ CloseHandle(g_hChildStd_OUT_Rd);
++ CloseHandle(g_hChildStd_OUT_Wr);
++ MSG_PUTS(_("\nCannot create pipes\n"));
++ }
++
++ si.cb = sizeof(si);
++ si.lpReserved = NULL;
++ si.lpDesktop = NULL;
++ si.lpTitle = NULL;
++ si.dwFlags = STARTF_USESHOWWINDOW | STARTF_USESTDHANDLES;
++
++ /* set-up our file redirection */
++ si.hStdError = g_hChildStd_OUT_Wr;
++ si.hStdOutput = g_hChildStd_OUT_Wr;
++ si.hStdInput = g_hChildStd_IN_Rd;
++ si.wShowWindow = SW_HIDE;
++ si.cbReserved2 = 0;
++ si.lpReserved2 = NULL;
++
++ if (options & SHELL_READ)
++ ga_init2(&ga, 1, BUFLEN);
++
++ /* Now, run the command */
++ CreateProcess(NULL, /* Executable name */
++ cmd, /* Command to execute */
++ NULL, /* Process security attributes */
++ NULL, /* Thread security attributes */
++
++ // this command can be litigeous, handle inheritence was
++ // deactivated for pending temp file, but, if we deactivate
++ // it, the pipes don't work for some reason.
++ TRUE, /* Inherit handles, first deactivated,
++ * but needed */
++ CREATE_DEFAULT_ERROR_MODE, /* Creation flags */
++ NULL, /* Environment */
++ NULL, /* Current directory */
++ &si, /* Startup information */
++ &pi); /* Process information */
++
++
++ /* Close our unused side of the pipes */
++ CloseHandle(g_hChildStd_IN_Rd);
++ CloseHandle(g_hChildStd_OUT_Wr);
++
++ if (options & SHELL_WRITE)
++ {
++ HANDLE thread =
++ CreateThread(NULL, /* security attributes */
++ 0, /* default stack size */
++ sub_process_writer, /* function to be executed */
++ g_hChildStd_IN_Wr, /* parameter */
++ 0, /* creation flag, start immediately */
++ NULL); /* we don't care about thread id */
++ CloseHandle(thread);
++ g_hChildStd_IN_Wr = NULL;
++ }
++
++ /* Keep updating the window while waiting for the shell to finish. */
++ for (;;)
++ {
++ MSG msg;
++
++ if (PeekMessage(&msg, (HWND)NULL, 0, 0, PM_REMOVE))
++ {
++ TranslateMessage(&msg);
++ DispatchMessage(&msg);
++ }
++
++ /* write pipe information in the window */
++ if ((options & (SHELL_READ|SHELL_WRITE))
++ # ifdef FEAT_GUI
++ || gui.in_use
++ # endif
++ )
++ {
++ len = 0;
++ if (!(options & SHELL_EXPAND)
++ && ((options &
++ (SHELL_READ|SHELL_WRITE|SHELL_COOKED))
++ != (SHELL_READ|SHELL_WRITE|SHELL_COOKED)
++ # ifdef FEAT_GUI
++ || gui.in_use
++ # endif
++ )
++ && (ta_len > 0 || noread_cnt > 4))
++ {
++ if (ta_len == 0)
++ {
++ /* Get extra characters when we don't have any. Reset the
++ * counter and timer. */
++ noread_cnt = 0;
++ # if defined(HAVE_GETTIMEOFDAY) && defined(HAVE_SYS_TIME_H)
++ gettimeofday(&start_tv, NULL);
++ # endif
++ len = ui_inchar(ta_buf, BUFLEN, 10L, 0);
++ }
++ if (ta_len > 0 || len > 0)
++ {
++ /*
++ * For pipes: Check for CTRL-C: send interrupt signal to
++ * child. Check for CTRL-D: EOF, close pipe to child.
++ */
++ if (len == 1 && cmd != NULL)
++ {
++ if (ta_buf[ta_len] == Ctrl_C)
++ {
++ /* Learn what exit code is expected, for
++ * now put 9 as SIGKILL */
++ TerminateProcess(pi.hProcess, 9);
++ }
++ if (ta_buf[ta_len] == Ctrl_D)
++ {
++ CloseHandle(g_hChildStd_IN_Wr);
++ g_hChildStd_IN_Wr = NULL;
++ }
++ }
++
++ /* replace K_BS by <BS> and K_DEL by <DEL> */
++ for (i = ta_len; i < ta_len + len; ++i)
++ {
++ if (ta_buf[i] == CSI && len - i > 2)
++ {
++ c = TERMCAP2KEY(ta_buf[i + 1], ta_buf[i + 2]);
++ if (c == K_DEL || c == K_KDEL || c == K_BS)
++ {
++ mch_memmove(ta_buf + i + 1, ta_buf + i + 3,
++ (size_t)(len - i - 2));
++ if (c == K_DEL || c == K_KDEL)
++ ta_buf[i] = DEL;
++ else
++ ta_buf[i] = Ctrl_H;
++ len -= 2;
++ }
++ }
++ else if (ta_buf[i] == '\r')
++ ta_buf[i] = '\n';
++ # ifdef FEAT_MBYTE
++ if (has_mbyte)
++ i += (*mb_ptr2len_len)(ta_buf + i,
++ ta_len + len - i) - 1;
++ # endif
++ }
++
++ /*
++ * For pipes: echo the typed characters. For a pty this
++ * does not seem to work.
++ */
++ for (i = ta_len; i < ta_len + len; ++i)
++ {
++ if (ta_buf[i] == '\n' || ta_buf[i] == '\b')
++ msg_putchar(ta_buf[i]);
++ # ifdef FEAT_MBYTE
++ else if (has_mbyte)
++ {
++ int l = (*mb_ptr2len)(ta_buf + i);
++
++ msg_outtrans_len(ta_buf + i, l);
++ i += l - 1;
++ }
++ # endif
++ else
++ msg_outtrans_len(ta_buf + i, 1);
++ }
++ windgoto(msg_row, msg_col);
++ out_flush();
++
++ ta_len += len;
++
++ /*
++ * Write the characters to the child, unless EOF has been
++ * typed for pipes. Write one character at a time, to
++ * avoid losing too much typeahead. When writing buffer
++ * lines, drop the typed characters (only check for
++ * CTRL-C).
++ */
++ if (options & SHELL_WRITE)
++ ta_len = 0;
++ else if (g_hChildStd_IN_Wr != NULL)
++ {
++ WriteFile(g_hChildStd_IN_Wr, (char*)ta_buf,
++ 1, &len, NULL);
++ // if we are typing in, we want to keep things reactive
++ delay = 1;
++ if (len > 0)
++ {
++ ta_len -= len;
++ mch_memmove(ta_buf, ta_buf + len, ta_len);
++ }
++ }
++ }
++ }
++ }
++
++ if (ta_len)
++ ui_inchar_undo(ta_buf, ta_len);
++
++ if (WaitForSingleObject(pi.hProcess, delay) != WAIT_TIMEOUT)
++ {
++ dump_pipe(options, g_hChildStd_OUT_Rd,
++ &ga, buffer, &buffer_off);
++ break;
++ }
++
++ ++noread_cnt;
++ dump_pipe(options, g_hChildStd_OUT_Rd,
++ &ga, buffer, &buffer_off);
++
++ /* We start waiting for a very short time and then increase it, so
++ * that we respond quickly when the process is quick, and don't
++ * consume too much overhead when it's slow. */
++ if (delay < 50)
++ delay += 10;
++ }
++
++ /* Close the pipe */
++ CloseHandle(g_hChildStd_OUT_Rd);
++ if (g_hChildStd_IN_Wr != NULL)
++ CloseHandle(g_hChildStd_IN_Wr);
++
++ WaitForSingleObject(pi.hProcess, INFINITE);
++
++ /* Get the command exit code */
++ GetExitCodeProcess(pi.hProcess, &ret);
++
++ if (options & SHELL_READ)
++ {
++ if (ga.ga_len > 0)
++ {
++ append_ga_line(&ga);
++ /* remember that the NL was missing */
++ curbuf->b_no_eol_lnum = curwin->w_cursor.lnum;
++ }
++ else
++ curbuf->b_no_eol_lnum = 0;
++ ga_clear(&ga);
++ }
++
++ /* Close the handles to the subprocess, so that it goes away */
++ CloseHandle(pi.hThread);
++ CloseHandle(pi.hProcess);
++
++ return ret;
++ }
++
++ static int
++ mch_system(char *cmd, int options)
++ {
++ /* if we can pipe and the shelltemp option is off */
++ if (allowPiping && !p_stmp)
++ return mch_system_piped(cmd, options);
++ else
++ return mch_system_classic(cmd, options);
++ }
+ #else
+
+ # define mch_system(c, o) system(c)
+***************
+*** 3388,3394 ****
+ char_u *newcmd;
+ long_u cmdlen = (
+ #ifdef FEAT_GUI_W32
+! STRLEN(vimrun_path) +
+ #endif
+ STRLEN(p_sh) + STRLEN(p_shcf) + STRLEN(cmd) + 10);
+
+--- 3897,3903 ----
+ char_u *newcmd;
+ long_u cmdlen = (
+ #ifdef FEAT_GUI_W32
+! (allowPiping && !p_stmp ? 0 : STRLEN(vimrun_path)) +
+ #endif
+ STRLEN(p_sh) + STRLEN(p_shcf) + STRLEN(cmd) + 10);
+
+***************
+*** 3497,3503 ****
+ MB_ICONWARNING);
+ need_vimrun_warning = FALSE;
+ }
+! if (!s_dont_use_vimrun)
+ /* Use vimrun to execute the command. It opens a console
+ * window, which can be closed without killing Vim. */
+ vim_snprintf((char *)newcmd, cmdlen, "%s%s%s %s %s",
+--- 4006,4012 ----
+ MB_ICONWARNING);
+ need_vimrun_warning = FALSE;
+ }
+! if (!s_dont_use_vimrun && (!allowPiping || p_stmp))
+ /* Use vimrun to execute the command. It opens a console
+ * window, which can be closed without killing Vim. */
+ vim_snprintf((char *)newcmd, cmdlen, "%s%s%s %s %s",
+***************
+*** 3521,3527 ****
+ /* Print the return value, unless "vimrun" was used. */
+ if (x != 0 && !(options & SHELL_SILENT) && !emsg_silent
+ #if defined(FEAT_GUI_W32)
+! && ((options & SHELL_DOOUT) || s_dont_use_vimrun)
+ #endif
+ )
+ {
+--- 4030,4037 ----
+ /* Print the return value, unless "vimrun" was used. */
+ if (x != 0 && !(options & SHELL_SILENT) && !emsg_silent
+ #if defined(FEAT_GUI_W32)
+! && ((options & SHELL_DOOUT) || s_dont_use_vimrun
+! || (allowPiping && !p_stmp))
+ #endif
+ )
+ {
+*** ../vim-7.3.239/src/proto/misc2.pro 2011-07-07 15:08:53.000000000 +0200
+--- src/proto/misc2.pro 2011-07-07 15:56:16.000000000 +0200
+***************
+*** 58,63 ****
+--- 58,64 ----
+ char_u *ga_concat_strings __ARGS((garray_T *gap));
+ void ga_concat __ARGS((garray_T *gap, char_u *s));
+ void ga_append __ARGS((garray_T *gap, int c));
++ void append_ga_line __ARGS((garray_T *gap));
+ int name_to_mod_mask __ARGS((int c));
+ int simplify_key __ARGS((int key, int *modifiers));
+ int handle_x_keys __ARGS((int key));
+*** ../vim-7.3.239/src/ui.c 2011-06-19 01:14:23.000000000 +0200
+--- src/ui.c 2011-07-07 15:44:56.000000000 +0200
+***************
+*** 58,64 ****
+ #endif
+ }
+
+! #if defined(UNIX) || defined(VMS) || defined(PROTO)
+ /*
+ * When executing an external program, there may be some typed characters that
+ * are not consumed by it. Give them back to ui_inchar() and they are stored
+--- 58,64 ----
+ #endif
+ }
+
+! #if defined(UNIX) || defined(VMS) || defined(PROTO) || defined(WIN3264)
+ /*
+ * When executing an external program, there may be some typed characters that
+ * are not consumed by it. Give them back to ui_inchar() and they are stored
+*** ../vim-7.3.239/src/version.c 2011-07-07 15:08:53.000000000 +0200
+--- src/version.c 2011-07-07 16:14:20.000000000 +0200
+***************
+*** 711,712 ****
+--- 711,714 ----
+ { /* Add new patch number below this line */
++ /**/
++ 240,
+ /**/
+
+--
+hundred-and-one symptoms of being an internet addict:
+257. Your "hundred-and-one" lists include well over 101 items, since you
+ automatically interpret all numbers in hexadecimal notation.
+ (hex 101 = decimal 257)
+
+ /// Bram Moolenaar -- Bram at Moolenaar.net -- http://www.Moolenaar.net \\\
+/// sponsor Vim, vote for features -- http://www.Vim.org/sponsor/ \\\
+\\\ an exciting new programming language -- http://www.Zimbu.org ///
+ \\\ help me help AIDS victims -- http://ICCF-Holland.org ///
More information about the scm-commits
mailing list