vim: src/os_unix.c comparison

comparison src/os_unix.c @ 167:c93c9cad9618

updated for version 7.0051

author	vimboss
date	Tue, 22 Feb 2005 08:39:57 +0000
parents	8b0ee9d57d7f
children	84c21eb4fc40

comparison

equal deleted inserted replaced

-:3a28ed993bbe
+:c93c9cad9618
 static RETSIGTYPE sig_alarm __ARGS(SIGPROTOARG);
 static int sig_alarm_called;
 #endif
 static RETSIGTYPE deathtrap __ARGS(SIGPROTOARG);
+static void catch_int_signal __ARGS((void));
 static void set_signals __ARGS((void));
 static void catch_signals __ARGS((RETSIGTYPE (*func_deadly)(), RETSIGTYPE (*func_other)()));
 #ifndef __EMX__
 static int  have_wildcard __ARGS((int, char_u **));
 static int  have_dollars __ARGS((int, char_u **));
 #endif
 #ifndef NO_EXPANDPATH
 static int	pstrcmp __ARGS((const void *, const void *));
 static int	unix_expandpath __ARGS((garray_T *gap, char_u *path, int wildoff, int flags));
+# if defined(MACOS_X) && defined(FEAT_MBYTE)
+extern char_u	*mac_precompose_path __ARGS((char_u *decompPath, size_t decompLen, size_t *precompLen));
+# endif
+#endif
+#if defined(MACOS_X) && defined(FEAT_MBYTE)
+extern void	mac_conv_init __ARGS((void));
+extern void	mac_conv_cleanup __ARGS((void));
 #endif
 #ifndef __EMX__
 static int save_patterns __ARGS((int num_pat, char_u **pat, int *num_file, char_u ***file));
 #endif
 Columns = 80;
 Rows = 24;
 out_flush();
 set_signals();
+#if defined(MACOS_X) && defined(FEAT_MBYTE)
+mac_conv_init();
+#endif
 }
 static void
 set_signals()
 {
 */
 #ifdef SIGPIPE
 signal(SIGPIPE, SIG_IGN);
 #endif
-/*
-* We want to catch CTRL-C (only works while in Cooked mode).
-*/
 #ifdef SIGINT
-signal(SIGINT, (RETSIGTYPE (*)())catch_sigint);
+catch_int_signal();
 #endif
 /*
 * Ignore alarm signals (Perl's alarm() generates it).
 */
 */
 if (gui.in_use)
 	signal(SIGHUP, SIG_IGN);
 #endif
 }
+#if defined(SIGINT) || defined(PROTO)
+/*
+* Catch CTRL-C (only works while in Cooked mode).
+*/
+static void
+catch_int_signal()
+{
+signal(SIGINT, (RETSIGTYPE (*)())catch_sigint);
+}
+#endif
 void
 reset_signals()
 {
 catch_signals(SIG_DFL, SIG_DFL);
 * Make sure the newline goes to the same stream as the text.
 */
 static void
 exit_scroll()
 {
+if (silent_mode)
+	return;
 if (newline_on_exit || msg_didout)
 {
 	if (msg_use_printf())
 	{
 	    if (info_message)
 may_core_dump();
 #ifdef FEAT_GUI
 if (gui.in_use)
 	gui_exit(r);
 #endif
+#if defined(MACOS_X) && defined(FEAT_MBYTE)
+mac_conv_cleanup();
+#endif
 #ifdef __QNX__
 /* A core dump won't be created if the signal handler
 * doesn't return, so we can't call exit() */
 if (deadly_signal != 0)
 	return;
 mch_new_shellsize()
 {
 /* 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;
 int		options;	/* SHELL_*, see vim.h */
 {
 # endif
 return x;
 #else /* USE_SYSTEM */	    /* don't use system(), use fork()/exec() */
-#define EXEC_FAILED 122	    /* Exit code when shell didn't execute.  Don't use
+# define EXEC_FAILED 122    /* Exit code when shell didn't execute.  Don't use
-			       127, some shell use that already */
+			       127, some shells use that already */
 char_u	*newcmd = NULL;
 pid_t	pid;
+pid_t	wpid = 0;
 pid_t	wait_pid = 0;
 # ifdef HAVE_UNION_WAIT
 union wait	status;
 # else
 int		status = -1;
 char	**argv = NULL;
 int		argc;
 int		i;
 char_u	*p;
 int		inquote;
+int		pty_master_fd = -1;	    /* for pty's */
 # ifdef FEAT_GUI
-int		pty_master_fd = -1;	    /* for pty's */
 int		pty_slave_fd = -1;
 char	*tty_name;
+# endif
 int		fd_toshell[2];	    /* for pipes */
 int		fd_fromshell[2];
 int		pipe_error = FALSE;
-#  ifdef HAVE_SETENV
+# ifdef HAVE_SETENV
 char	envbuf[50];
-#  else
+# else
 static char	envbuf_Rows[20];
 static char	envbuf_Columns[20];
-#  endif
 # endif
 int		did_settmode = FALSE; /* TRUE when settmode(TMODE_RAW) called */
 out_flush();
 if (options & SHELL_COOKED)
 	argv[argc++] = (char *)p_shcf;
 	argv[argc++] = (char *)cmd;
 }
 argv[argc] = NULL;
+/*
+* For the GUI, when writing the output into the buffer and when reading
+* input from the buffer: Try using a pseudo-tty to get the stdin/stdout
+* of the executed command into the Vim window.  Or use a pipe.
+*/
+if ((options & (SHELL_READ|SHELL_WRITE))
 # ifdef FEAT_GUI
-/*
+	    || (gui.in_use && show_shell_mess)
-* For the GUI: Try using a pseudo-tty to get the stdin/stdout of the
+# endif
-* executed command into the Vim window.  Or use a pipe.
+		    )
-*/
+{
-if (gui.in_use && show_shell_mess)
+# ifdef FEAT_GUI
-{
 	/*
 	 * Try to open a master pty.
 	 * If this works, open the slave pty.
 	 * If the slave can't be opened, close the master pty.
 	 */
-	if (p_guipty)
+	if (p_guipty && !(options & (SHELL_READ|SHELL_WRITE)))
 	{
 	    pty_master_fd = OpenPTY(&tty_name);	    /* open pty */
 	    if (pty_master_fd >= 0 && ((pty_slave_fd =
 				    open(tty_name, O_RDWR | O_EXTRA, 0)) < 0))
 	    {
 	}
 	/*
 	 * If not opening a pty or it didn't work, try using pipes.
 	 */
 	if (pty_master_fd < 0)
+# endif
 	{
 	    pipe_error = (pipe(fd_toshell) < 0);
 	    if (!pipe_error)			    /* pipe create OK */
 	    {
 		pipe_error = (pipe(fd_fromshell) < 0);
 	    }
 	}
 }
 if (!pipe_error)			/* pty or pipe opened or not used */
-# endif
 {
 # ifdef __BEOS__
 	beos_cleanup_read_thread();
 # endif
 	if ((pid = fork()) == -1)	/* maybe we should use vfork() */
 	{
 	    MSG_PUTS(_("\nCannot fork\n"));
+	    if ((options & (SHELL_READ|SHELL_WRITE))
 # ifdef FEAT_GUI
-	    if (gui.in_use && show_shell_mess)
+		|| (gui.in_use && show_shell_mess)
+# endif
+		    )
 	    {
+# ifdef FEAT_GUI
 		if (pty_master_fd >= 0)		/* close the pseudo tty */
 		{
 		    close(pty_master_fd);
 		    close(pty_slave_fd);
 		}
 		else				/* close the pipes */
+# endif
 		{
 		    close(fd_toshell[0]);
 		    close(fd_toshell[1]);
 		    close(fd_fromshell[0]);
 		    close(fd_fromshell[1]);
 		}
 	    }
-# endif
 	}
 	else if (pid == 0)	/* child */
 	{
 	    reset_signals();		/* handle signals normally */
 		    /* Don't need this now that we've duplicated it */
 		    close(fd);
 		}
 	    }
+	    else if ((options & (SHELL_READ|SHELL_WRITE))
 # ifdef FEAT_GUI
-	    else if (gui.in_use)
+		    || gui.in_use
+# endif
+		    )
 	    {
-#  ifdef HAVE_SETSID
+# ifdef HAVE_SETSID
 		(void)setsid();
-#  endif
+# endif
+# ifdef FEAT_GUI
 		/* push stream discipline modules */
 		if (options & SHELL_COOKED)
 		    SetupSlavePTY(pty_slave_fd);
 #  ifdef TIOCSCTTY
 		/* try to become controlling tty (probably doesn't work,
 		 * unless run by root) */
 		ioctl(pty_slave_fd, TIOCSCTTY, (char *)NULL);
 #  endif
+# endif
 		/* Simulate to have a dumb terminal (for now) */
-#  ifdef HAVE_SETENV
+# ifdef HAVE_SETENV
 		setenv("TERM", "dumb", 1);
 		sprintf((char *)envbuf, "%ld", Rows);
 		setenv("ROWS", (char *)envbuf, 1);
 		sprintf((char *)envbuf, "%ld", Rows);
 		setenv("LINES", (char *)envbuf, 1);
 		sprintf((char *)envbuf, "%ld", Columns);
 		setenv("COLUMNS", (char *)envbuf, 1);
-#  else
+# else
 		/*
 		 * Putenv does not copy the string, it has to remain valid.
 		 * Use a static array to avoid loosing allocated memory.
 		 */
 		putenv("TERM=dumb");
 		putenv(envbuf_Rows);
 		sprintf(envbuf_Rows, "LINES=%ld", Rows);
 		putenv(envbuf_Rows);
 		sprintf(envbuf_Columns, "COLUMNS=%ld", Columns);
 		putenv(envbuf_Columns);
-#  endif
+# endif
+# ifdef FEAT_GUI
 		if (pty_master_fd >= 0)
 		{
 		    close(pty_master_fd);   /* close master side of pty */
 		    /* set up stdin/stdout/stderr for the child */
 		    dup(pty_slave_fd);
 		    close(pty_slave_fd);    /* has been dupped, close it now */
 		}
 		else
+# endif
 		{
 		    /* set up stdin for the child */
 		    close(fd_toshell[1]);
 		    close(0);
 		    dup(fd_toshell[0]);
 		    /* set up stderr for the child */
 		    close(2);
 		    dup(1);
 		}
 	    }
-# endif /* FEAT_GUI */
 	    /*
 	     * There is no type cast for the argv, because the type may be
 	     * different on different machines. This may cause a warning
 	     * message with strict compilers, don't worry about it.
 	     * Call _exit() instead of exit() to avoid closing the connection
 	}
 	else			/* parent */
 	{
 	    /*
 	     * While child is running, ignore terminating signals.
+	     * Do catch CTRL-C, so that "got_int" is set.
 	     */
 	    catch_signals(SIG_IGN, SIG_ERR);
+	    catch_int_signal();
-# ifdef FEAT_GUI
 	    /*
 	     * For the GUI we redirect stdin, stdout and stderr to our window.
+	     * This is also used to pipe stdin/stdout to/from the external
+	     * command.
 	     */
-	    if (gui.in_use && show_shell_mess)
+	    if ((options & (SHELL_READ|SHELL_WRITE))
+# ifdef FEAT_GUI
+		    || (gui.in_use && show_shell_mess)
+# endif
+	       )
 	    {
-#  define BUFLEN 100		/* length for buffer, pseudo tty limit is 128 */
+# define BUFLEN 100		/* length for buffer, pseudo tty limit is 128 */
 		char_u	    buffer[BUFLEN + 1];
-#  ifdef FEAT_MBYTE
+# ifdef FEAT_MBYTE
 		int	    buffer_off = 0;	/* valid bytes in buffer[] */
-#  endif
+# endif
 		char_u	    ta_buf[BUFLEN + 1];	/* TypeAHead */
 		int	    ta_len = 0;		/* valid bytes in ta_buf[] */
 		int	    len;
 		int	    p_more_save;
 		int	    old_State;
 		int	    c;
 		int	    toshell_fd;
 		int	    fromshell_fd;
+		garray_T    ga;
+		int	    noread_cnt;
+# ifdef FEAT_GUI
 		if (pty_master_fd >= 0)
 		{
 		    close(pty_slave_fd);	/* close slave side of pty */
 		    fromshell_fd = pty_master_fd;
 		    toshell_fd = dup(pty_master_fd);
 		}
 		else
+# endif
 		{
 		    close(fd_toshell[0]);
 		    close(fd_fromshell[1]);
 		    toshell_fd = fd_toshell[1];
 		    fromshell_fd = fd_fromshell[0];
 		p_more_save = p_more;
 		p_more = FALSE;
 		old_State = State;
 		State = EXTERNCMD;	/* don't redraw at window resize */
+		if (options & SHELL_WRITE && toshell_fd >= 0)
+		{
+		    /* Fork a process that will write the lines to the
+		     * external program. */
+		    if ((wpid = fork()) == -1)
+		    {
+			MSG_PUTS(_("\nCannot fork\n"));
+		    }
+		    else if (wpid == 0)
+		    {
+			linenr_T    lnum = curbuf->b_op_start.lnum;
+			int	    written = 0;
+			char_u	    *p = ml_get(lnum);
+			char_u	    *s;
+			size_t	    l;
+			/* child */
+			for (;;)
+			{
+			    l = STRLEN(p + written);
+			    if (l == 0)
+				len = 0;
+			    else if (p[written] == NL)
+				/* NL -> NUL translation */
+				len = write(toshell_fd, "", (size_t)1);
+			    else
+			    {
+				s = vim_strchr(p + written, NL);
+				len = write(toshell_fd, (char *)p + written,
+					   s == NULL ? l : s - (p + written));
+			    }
+			    if (len == 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 != write_no_eol_lnum
+					    && (lnum !=
+						    curbuf->b_ml.ml_line_count
+						    || curbuf->b_p_eol)))
+				    write(toshell_fd, "\n", (size_t)1);
+				++lnum;
+				if (lnum > curbuf->b_op_end.lnum)
+				{
+				    /* finished all the lines, close pipe */
+				    close(toshell_fd);
+				    toshell_fd = -1;
+				    break;
+				}
+				p = ml_get(lnum);
+				written = 0;
+			    }
+			    else if (len > 0)
+				written += len;
+			}
+			_exit(0);
+		    }
+		    else
+		    {
+			close(toshell_fd);
+			toshell_fd = -1;
+		    }
+		}
+		if (options & SHELL_READ)
+		    ga_init2(&ga, 1, BUFLEN);
+		noread_cnt = 0;
 		for (;;)
 		{
 		    /*
 		     * Check if keys have been typed, write them to the child
 		     * if there are any.  Don't do this if we are expanding
 		     * wild cards (would eat typeahead).  Don't get extra
 		     * characters when we already have one.
+		     * Don't read characters unless we didn't get output for a
+		     * while, avoids that ":r !ls" eats typeahead.
 		     */
 		    len = 0;
 		    if (!(options & SHELL_EXPAND)
 			    && (ta_len > 0
-				|| (len = ui_inchar(ta_buf, BUFLEN, 10L,
+				|| (noread_cnt > 4
-								     0)) > 0))
+				    && (len = ui_inchar(ta_buf,
+						       BUFLEN, 10L, 0)) > 0)))
 		    {
 			/*
 			 * For pipes:
 			 * Check for CTRL-C: send interrupt signal to child.
 			 * Check for CTRL-D: EOF, close pipe to child.
 			 */
 			if (len == 1 && (pty_master_fd < 0 || cmd != NULL))
 			{
-#  ifdef SIGINT
+# ifdef SIGINT
 			    /*
 			     * Send SIGINT to the child's group or all
 			     * processes in our group.
 			     */
 			    if (ta_buf[ta_len] == Ctrl_C
 					       || ta_buf[ta_len] == intr_char)
-#   ifdef HAVE_SETSID
+			    {
+#  ifdef HAVE_SETSID
 				kill(-pid, SIGINT);
-#   else
+#  else
 				kill(0, SIGINT);
-#   endif
 #  endif
+				if (wpid > 0)
+				    kill(wpid, SIGINT);
+			    }
+# endif
 			    if (pty_master_fd < 0 && toshell_fd >= 0
 					       && ta_buf[ta_len] == Ctrl_D)
 			    {
 				close(toshell_fd);
 				toshell_fd = -1;
 				    len -= 2;
 				}
 			    }
 			    else if (ta_buf[i] == '\r')
 				ta_buf[i] = '\n';
-#  ifdef FEAT_MBYTE
+# ifdef FEAT_MBYTE
 			    if (has_mbyte)
 				i += (*mb_ptr2len_check)(ta_buf + i) - 1;
-#  endif
+# 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
+# ifdef FEAT_MBYTE
 				else if (has_mbyte)
 				{
 				    int l = (*mb_ptr2len_check)(ta_buf + i);
 				    msg_outtrans_len(ta_buf + i, l);
 				    i += l - 1;
 				}
-#  endif
+# endif
 				else
 				    msg_outtrans_len(ta_buf + i, 1);
 			    }
 			    windgoto(msg_row, msg_col);
 			    out_flush();
 			/*
 			 * Write the characters to the child, unless EOF has
 			 * been typed for pipes.  Write one character at a
 			 * time, to avoid loosing too much typeahead.
+			 * When writing buffer lines, drop the typed
+			 * characters (only check for CTRL-C).
 			 */
-			if (toshell_fd >= 0)
+			if (options & SHELL_WRITE)
+			    ta_len = 0;
+			else if (toshell_fd >= 0)
 			{
 			    len = write(toshell_fd, (char *)ta_buf, (size_t)1);
 			    if (len > 0)
 			    {
 				ta_len -= len;
 				mch_memmove(ta_buf, ta_buf + len, ta_len);
+				noread_cnt = 0;
 			    }
 			}
+		    }
+		    if (got_int)
+		    {
+			/* CTRL-C sends a signal to the child, we ignore it
+			 * ourselves */
+#  ifdef HAVE_SETSID
+			kill(-pid, SIGINT);
+#  else
+			kill(0, SIGINT);
+#  endif
+			if (wpid > 0)
+			    kill(wpid, SIGINT);
+			got_int = FALSE;
 		    }
 		    /*
 		     * Check if the child has any characters to be printed.
 		     * Read them and write them to our window.	Repeat this as
 		     * for mch_inchar(), or sending typeahead characters to
 		     * the external process.
 		     * TODO: This should handle escape sequences, compatible
 		     * to some terminal (vt52?).
 		     */
+		    ++noread_cnt;
 		    while (RealWaitForChar(fromshell_fd, 10L, NULL))
 		    {
 			len = read(fromshell_fd, (char *)buffer
-#  ifdef FEAT_MBYTE
+# ifdef FEAT_MBYTE
 				+ buffer_off, (size_t)(BUFLEN - buffer_off)
-#  else
+# else
 				, (size_t)BUFLEN
-#  endif
+# endif
 				);
 			if (len <= 0)		    /* end of file or error */
 			    goto finished;
-#  ifdef FEAT_MBYTE
-			len += buffer_off;
+			noread_cnt = 0;
-			buffer[len] = NUL;
+			if (options & SHELL_READ)
-			if (has_mbyte)
+			{
+			    /* 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)
 				mch_memmove(buffer, p, buffer_off);
 				continue;
 			    }
 			    buffer_off = 0;
 			}
+# endif /* FEAT_MBYTE */
 			else
-#  endif /* FEAT_MBYTE */
 			{
 			    buffer[len] = NUL;
 			    msg_puts(buffer);
 			}
 		    /*
 		     * Check if the child still exists, before checking for
 		     * typed characters (otherwise we would loose typeahead).
 		     */
-#  ifdef __NeXT__
+# ifdef __NeXT__
 		    wait_pid = wait4(pid, &status, WNOHANG, (struct rusage *) 0);
-#  else
+# else
 		    wait_pid = waitpid(pid, &status, WNOHANG);
-#  endif
+# endif
 		    if ((wait_pid == (pid_t)-1 && errno == ECHILD)
 			    || (wait_pid == pid && WIFEXITED(status)))
 		    {
 			wait_pid = pid;
 			break;
 		    }
 		    wait_pid = 0;
 		}
 finished:
 		p_more = p_more_save;
+		if (options & SHELL_READ)
-#  ifndef MACOS_X_UNIX /* TODO: Is it needed for MACOS_X ? */
+		{
+		    if (ga.ga_len > 0)
+		    {
+			append_ga_line(&ga);
+			/* remember that the NL was missing */
+			write_no_eol_lnum = curwin->w_cursor.lnum;
+		    }
+		    else
+			write_no_eol_lnum = 0;
+		    ga_clear(&ga);
+		}
 		/*
 		 * Give all typeahead that wasn't used back to ui_inchar().
 		 */
 		if (ta_len)
 		    ui_inchar_undo(ta_buf, ta_len);
-#  endif
 		State = old_State;
 		if (toshell_fd >= 0)
 		    close(toshell_fd);
 		close(fromshell_fd);
 	    }
-# endif /* FEAT_GUI */
 	    /*
 	     * Wait until our child has exited.
 	     * Ignore wait() returning pids of other children and returning
 	     * because of some signal like SIGWINCH.
 	     * Don't wait if wait_pid was already set above, indicating the
 	     * child already exited.
 	     */
 	    while (wait_pid != pid)
 	    {
-#ifdef _THREAD_SAFE
+# ifdef _THREAD_SAFE
 		/* Ugly hack: when compiled with Python threads are probably
 		 * used, in which case wait() sometimes hangs for no obvious
 		 * reason.  Use waitpid() instead and loop (like the GUI). */
 #  ifdef __NeXT__
 		wait_pid = wait4(pid, &status, WNOHANG, (struct rusage *)0);
 		{
 		    /* Wait for 1/100 sec before trying again. */
 		    mch_delay(10L, TRUE);
 		    continue;
 		}
-#else
+# else
 		wait_pid = wait(&status);
-#endif
+# endif
 		if (wait_pid <= 0
 # ifdef ECHILD
 			&& errno == ECHILD
 # endif
 		   )
 		    break;
 	    }
+	    /* Make sure the child that writes to the external program is
+	     * dead. */
+	    if (wpid > 0)
+		kill(wpid, SIGKILL);
 	    /*
 	     * Set to raw mode right now, otherwise a CTRL-C after
 	     * catch_signals() will kill Vim.
 	     */
 		    /* no more wildcards, check if there is a match */
 		    /* remove backslashes for the remaining components only */
 		    if (*path_end != NUL)
 			backslash_halve(buf + len + 1);
 		    if (mch_getperm(buf) >= 0)	/* add existing file */
+		    {
+#if defined(MACOS_X) && defined(FEAT_MBYTE)
+			size_t precomp_len = STRLEN(buf)+1;
+			char_u *precomp_buf =
+			    mac_precompose_path(buf, precomp_len, &precomp_len);
+			if (precomp_buf)
+			{
+			    mch_memmove(buf, precomp_buf, precomp_len);
+			    vim_free(precomp_buf);
+			}
+#endif
 			addfile(gap, buf, flags);
+		    }
 		}
 	    }
 	}
 	closedir(dirp);

Mercurial > vim

comparison src/os_unix.c @ 167:c93c9cad9618