1 /* Process support for GNU Emacs on the Microsoft W32 API.
2 Copyright (C) 1992, 1995 Free Software Foundation, Inc.
4 This file is part of GNU Emacs.
6 GNU Emacs is free software; you can redistribute it and/or modify
7 it under the terms of the GNU General Public License as published by
8 the Free Software Foundation; either version 2, or (at your option)
11 GNU Emacs is distributed in the hope that it will be useful,
12 but WITHOUT ANY WARRANTY; without even the implied warranty of
13 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14 GNU General Public License for more details.
16 You should have received a copy of the GNU General Public License
17 along with GNU Emacs; see the file COPYING. If not, write to
18 the Free Software Foundation, Inc., 59 Temple Place - Suite 330,
19 Boston, MA 02111-1307, USA.
21 Drew Bliss Oct 14, 1993
22 Adapted from alarm.c by Tim Fleehart
32 /* must include CRT headers *before* config.h */
49 /* Control whether spawnve quotes arguments as necessary to ensure
50 correct parsing by child process. Because not all uses of spawnve
51 are careful about constructing argv arrays, we make this behaviour
52 conditional (off by default). */
53 Lisp_Object Vw32_quote_process_args
;
55 /* Control whether create_child causes the process' window to be
56 hidden. The default is nil. */
57 Lisp_Object Vw32_start_process_show_window
;
59 /* Control whether create_child causes the process to inherit Emacs'
60 console window, or be given a new one of its own. The default is
61 nil, to allow multiple DOS programs to run on Win95. Having separate
62 consoles also allows Emacs to cleanly terminate process groups. */
63 Lisp_Object Vw32_start_process_share_console
;
65 /* Time to sleep before reading from a subprocess output pipe - this
66 avoids the inefficiency of frequently reading small amounts of data.
67 This is primarily necessary for handling DOS processes on Windows 95,
68 but is useful for W32 processes on both Windows 95 and NT as well. */
69 Lisp_Object Vw32_pipe_read_delay
;
71 /* Control conversion of upper case file names to lower case.
72 nil means no, t means yes. */
73 Lisp_Object Vw32_downcase_file_names
;
75 /* Control whether stat() attempts to generate fake but hopefully
76 "accurate" inode values, by hashing the absolute truenames of files.
77 This should detect aliasing between long and short names, but still
78 allows the possibility of hash collisions. */
79 Lisp_Object Vw32_generate_fake_inodes
;
81 /* Control whether stat() attempts to determine file type and link count
82 exactly, at the expense of slower operation. Since true hard links
83 are supported on NTFS volumes, this is only relevant on NT. */
84 Lisp_Object Vw32_get_true_file_attributes
;
86 Lisp_Object Qhigh
, Qlow
;
88 #ifndef SYS_SIGLIST_DECLARED
89 extern char *sys_siglist
[];
93 void _DebPrint (const char *fmt
, ...)
99 vsprintf (buf
, fmt
, args
);
101 OutputDebugString (buf
);
105 typedef void (_CALLBACK_
*signal_handler
)(int);
107 /* Signal handlers...SIG_DFL == 0 so this is initialized correctly. */
108 static signal_handler sig_handlers
[NSIG
];
110 /* Fake signal implementation to record the SIGCHLD handler. */
112 sys_signal (int sig
, signal_handler handler
)
121 old
= sig_handlers
[sig
];
122 sig_handlers
[sig
] = handler
;
126 /* Defined in <process.h> which conflicts with the local copy */
129 /* Child process management list. */
130 int child_proc_count
= 0;
131 child_process child_procs
[ MAX_CHILDREN
];
132 child_process
*dead_child
= NULL
;
134 DWORD WINAPI
reader_thread (void *arg
);
136 /* Find an unused process slot. */
143 for (cp
= child_procs
+(child_proc_count
-1); cp
>= child_procs
; cp
--)
144 if (!CHILD_ACTIVE (cp
))
146 if (child_proc_count
== MAX_CHILDREN
)
148 cp
= &child_procs
[child_proc_count
++];
151 memset (cp
, 0, sizeof(*cp
));
154 cp
->procinfo
.hProcess
= NULL
;
155 cp
->status
= STATUS_READ_ERROR
;
157 /* use manual reset event so that select() will function properly */
158 cp
->char_avail
= CreateEvent (NULL
, TRUE
, FALSE
, NULL
);
161 cp
->char_consumed
= CreateEvent (NULL
, FALSE
, FALSE
, NULL
);
162 if (cp
->char_consumed
)
164 cp
->thrd
= CreateThread (NULL
, 1024, reader_thread
, cp
, 0, &id
);
174 delete_child (child_process
*cp
)
178 /* Should not be deleting a child that is still needed. */
179 for (i
= 0; i
< MAXDESC
; i
++)
180 if (fd_info
[i
].cp
== cp
)
183 if (!CHILD_ACTIVE (cp
))
186 /* reap thread if necessary */
191 if (GetExitCodeThread (cp
->thrd
, &rc
) && rc
== STILL_ACTIVE
)
193 /* let the thread exit cleanly if possible */
194 cp
->status
= STATUS_READ_ERROR
;
195 SetEvent (cp
->char_consumed
);
196 if (WaitForSingleObject (cp
->thrd
, 1000) != WAIT_OBJECT_0
)
198 DebPrint (("delete_child.WaitForSingleObject (thread) failed "
199 "with %lu for fd %ld\n", GetLastError (), cp
->fd
));
200 TerminateThread (cp
->thrd
, 0);
203 CloseHandle (cp
->thrd
);
208 CloseHandle (cp
->char_avail
);
209 cp
->char_avail
= NULL
;
211 if (cp
->char_consumed
)
213 CloseHandle (cp
->char_consumed
);
214 cp
->char_consumed
= NULL
;
217 /* update child_proc_count (highest numbered slot in use plus one) */
218 if (cp
== child_procs
+ child_proc_count
- 1)
220 for (i
= child_proc_count
-1; i
>= 0; i
--)
221 if (CHILD_ACTIVE (&child_procs
[i
]))
223 child_proc_count
= i
+ 1;
228 child_proc_count
= 0;
231 /* Find a child by pid. */
232 static child_process
*
233 find_child_pid (DWORD pid
)
237 for (cp
= child_procs
+(child_proc_count
-1); cp
>= child_procs
; cp
--)
238 if (CHILD_ACTIVE (cp
) && pid
== cp
->pid
)
244 /* Thread proc for child process and socket reader threads. Each thread
245 is normally blocked until woken by select() to check for input by
246 reading one char. When the read completes, char_avail is signalled
247 to wake up the select emulator and the thread blocks itself again. */
249 reader_thread (void *arg
)
254 cp
= (child_process
*)arg
;
256 /* We have to wait for the go-ahead before we can start */
258 || WaitForSingleObject (cp
->char_consumed
, INFINITE
) != WAIT_OBJECT_0
)
265 rc
= _sys_read_ahead (cp
->fd
);
267 /* The name char_avail is a misnomer - it really just means the
268 read-ahead has completed, whether successfully or not. */
269 if (!SetEvent (cp
->char_avail
))
271 DebPrint (("reader_thread.SetEvent failed with %lu for fd %ld\n",
272 GetLastError (), cp
->fd
));
276 if (rc
== STATUS_READ_ERROR
)
279 /* If the read died, the child has died so let the thread die */
280 if (rc
== STATUS_READ_FAILED
)
283 /* Wait until our input is acknowledged before reading again */
284 if (WaitForSingleObject (cp
->char_consumed
, INFINITE
) != WAIT_OBJECT_0
)
286 DebPrint (("reader_thread.WaitForSingleObject failed with "
287 "%lu for fd %ld\n", GetLastError (), cp
->fd
));
294 /* To avoid Emacs changing directory, we just record here the directory
295 the new process should start in. This is set just before calling
296 sys_spawnve, and is not generally valid at any other time. */
297 static char * process_dir
;
300 create_child (char *exe
, char *cmdline
, char *env
,
301 int * pPid
, child_process
*cp
)
304 SECURITY_ATTRIBUTES sec_attrs
;
305 SECURITY_DESCRIPTOR sec_desc
;
306 char dir
[ MAXPATHLEN
];
308 if (cp
== NULL
) abort ();
310 memset (&start
, 0, sizeof (start
));
311 start
.cb
= sizeof (start
);
314 if (NILP (Vw32_start_process_show_window
))
315 start
.dwFlags
= STARTF_USESTDHANDLES
| STARTF_USESHOWWINDOW
;
317 start
.dwFlags
= STARTF_USESTDHANDLES
;
318 start
.wShowWindow
= SW_HIDE
;
320 start
.hStdInput
= GetStdHandle (STD_INPUT_HANDLE
);
321 start
.hStdOutput
= GetStdHandle (STD_OUTPUT_HANDLE
);
322 start
.hStdError
= GetStdHandle (STD_ERROR_HANDLE
);
323 #endif /* HAVE_NTGUI */
325 /* Explicitly specify no security */
326 if (!InitializeSecurityDescriptor (&sec_desc
, SECURITY_DESCRIPTOR_REVISION
))
328 if (!SetSecurityDescriptorDacl (&sec_desc
, TRUE
, NULL
, FALSE
))
330 sec_attrs
.nLength
= sizeof (sec_attrs
);
331 sec_attrs
.lpSecurityDescriptor
= &sec_desc
;
332 sec_attrs
.bInheritHandle
= FALSE
;
334 strcpy (dir
, process_dir
);
335 unixtodos_filename (dir
);
337 if (!CreateProcess (exe
, cmdline
, &sec_attrs
, NULL
, TRUE
,
338 (!NILP (Vw32_start_process_share_console
)
339 ? CREATE_NEW_PROCESS_GROUP
340 : CREATE_NEW_CONSOLE
),
342 &start
, &cp
->procinfo
))
345 cp
->pid
= (int) cp
->procinfo
.dwProcessId
;
347 /* Hack for Windows 95, which assigns large (ie negative) pids */
351 /* pid must fit in a Lisp_Int */
352 cp
->pid
= (cp
->pid
& VALMASK
);
359 DebPrint (("create_child.CreateProcess failed: %ld\n", GetLastError()););
363 /* create_child doesn't know what emacs' file handle will be for waiting
364 on output from the child, so we need to make this additional call
365 to register the handle with the process
366 This way the select emulator knows how to match file handles with
367 entries in child_procs. */
369 register_child (int pid
, int fd
)
373 cp
= find_child_pid (pid
);
376 DebPrint (("register_child unable to find pid %lu\n", pid
));
381 DebPrint (("register_child registered fd %d with pid %lu\n", fd
, pid
));
386 /* thread is initially blocked until select is called; set status so
387 that select will release thread */
388 cp
->status
= STATUS_READ_ACKNOWLEDGED
;
390 /* attach child_process to fd_info */
391 if (fd_info
[fd
].cp
!= NULL
)
393 DebPrint (("register_child: fd_info[%d] apparently in use!\n", fd
));
400 /* When a process dies its pipe will break so the reader thread will
401 signal failure to the select emulator.
402 The select emulator then calls this routine to clean up.
403 Since the thread signaled failure we can assume it is exiting. */
405 reap_subprocess (child_process
*cp
)
407 if (cp
->procinfo
.hProcess
)
409 /* Reap the process */
411 /* Process should have already died before we are called. */
412 if (WaitForSingleObject (cp
->procinfo
.hProcess
, 0) != WAIT_OBJECT_0
)
413 DebPrint (("reap_subprocess: child fpr fd %d has not died yet!", cp
->fd
));
415 CloseHandle (cp
->procinfo
.hProcess
);
416 cp
->procinfo
.hProcess
= NULL
;
417 CloseHandle (cp
->procinfo
.hThread
);
418 cp
->procinfo
.hThread
= NULL
;
421 /* For asynchronous children, the child_proc resources will be freed
422 when the last pipe read descriptor is closed; for synchronous
423 children, we must explicitly free the resources now because
424 register_child has not been called. */
429 /* Wait for any of our existing child processes to die
430 When it does, close its handle
431 Return the pid and fill in the status if non-NULL. */
434 sys_wait (int *status
)
436 DWORD active
, retval
;
439 child_process
*cp
, *cps
[MAX_CHILDREN
];
440 HANDLE wait_hnd
[MAX_CHILDREN
];
443 if (dead_child
!= NULL
)
445 /* We want to wait for a specific child */
446 wait_hnd
[nh
] = dead_child
->procinfo
.hProcess
;
447 cps
[nh
] = dead_child
;
448 if (!wait_hnd
[nh
]) abort ();
455 for (cp
= child_procs
+(child_proc_count
-1); cp
>= child_procs
; cp
--)
456 /* some child_procs might be sockets; ignore them */
457 if (CHILD_ACTIVE (cp
) && cp
->procinfo
.hProcess
)
459 wait_hnd
[nh
] = cp
->procinfo
.hProcess
;
467 /* Nothing to wait on, so fail */
474 /* Check for quit about once a second. */
476 active
= WaitForMultipleObjects (nh
, wait_hnd
, FALSE
, 1000);
477 } while (active
== WAIT_TIMEOUT
);
479 if (active
== WAIT_FAILED
)
484 else if (active
>= WAIT_OBJECT_0
485 && active
< WAIT_OBJECT_0
+MAXIMUM_WAIT_OBJECTS
)
487 active
-= WAIT_OBJECT_0
;
489 else if (active
>= WAIT_ABANDONED_0
490 && active
< WAIT_ABANDONED_0
+MAXIMUM_WAIT_OBJECTS
)
492 active
-= WAIT_ABANDONED_0
;
498 if (!GetExitCodeProcess (wait_hnd
[active
], &retval
))
500 DebPrint (("Wait.GetExitCodeProcess failed with %lu\n",
504 if (retval
== STILL_ACTIVE
)
506 /* Should never happen */
507 DebPrint (("Wait.WaitForMultipleObjects returned an active process\n"));
512 /* Massage the exit code from the process to match the format expected
513 by the WIFSTOPPED et al macros in syswait.h. Only WIFSIGNALED and
514 WIFEXITED are supported; WIFSTOPPED doesn't make sense under NT. */
516 if (retval
== STATUS_CONTROL_C_EXIT
)
524 DebPrint (("Wait signaled with process pid %d\n", cp
->pid
));
531 else if (synch_process_alive
)
533 synch_process_alive
= 0;
535 /* Report the status of the synchronous process. */
536 if (WIFEXITED (retval
))
537 synch_process_retcode
= WRETCODE (retval
);
538 else if (WIFSIGNALED (retval
))
540 int code
= WTERMSIG (retval
);
545 /* Suppress warning if the table has const char *. */
546 signame
= (char *) sys_siglist
[code
];
551 synch_process_death
= signame
;
554 reap_subprocess (cp
);
557 reap_subprocess (cp
);
563 w32_executable_type (char * filename
, int * is_dos_app
, int * is_cygnus_app
)
565 file_data executable
;
568 /* Default values in case we can't tell for sure. */
570 *is_cygnus_app
= FALSE
;
572 if (!open_input_file (&executable
, filename
))
575 p
= strrchr (filename
, '.');
577 /* We can only identify DOS .com programs from the extension. */
578 if (p
&& stricmp (p
, ".com") == 0)
580 else if (p
&& (stricmp (p
, ".bat") == 0
581 || stricmp (p
, ".cmd") == 0))
583 /* A DOS shell script - it appears that CreateProcess is happy to
584 accept this (somewhat surprisingly); presumably it looks at
585 COMSPEC to determine what executable to actually invoke.
586 Therefore, we have to do the same here as well. */
587 /* Actually, I think it uses the program association for that
588 extension, which is defined in the registry. */
589 p
= egetenv ("COMSPEC");
591 w32_executable_type (p
, is_dos_app
, is_cygnus_app
);
595 /* Look for DOS .exe signature - if found, we must also check that
596 it isn't really a 16- or 32-bit Windows exe, since both formats
597 start with a DOS program stub. Note that 16-bit Windows
598 executables use the OS/2 1.x format. */
600 IMAGE_DOS_HEADER
* dos_header
;
601 IMAGE_NT_HEADERS
* nt_header
;
603 dos_header
= (PIMAGE_DOS_HEADER
) executable
.file_base
;
604 if (dos_header
->e_magic
!= IMAGE_DOS_SIGNATURE
)
607 nt_header
= (PIMAGE_NT_HEADERS
) ((char *) dos_header
+ dos_header
->e_lfanew
);
609 if (nt_header
> dos_header
+ executable
.size
)
611 /* Some dos headers (pkunzip) have bogus e_lfanew fields. */
614 else if (nt_header
->Signature
!= IMAGE_NT_SIGNATURE
615 && LOWORD (nt_header
->Signature
) != IMAGE_OS2_SIGNATURE
)
619 else if (nt_header
->Signature
== IMAGE_NT_SIGNATURE
)
621 /* Look for cygwin.dll in DLL import list. */
622 IMAGE_DATA_DIRECTORY import_dir
=
623 nt_header
->OptionalHeader
.DataDirectory
[IMAGE_DIRECTORY_ENTRY_IMPORT
];
624 IMAGE_IMPORT_DESCRIPTOR
* imports
;
625 IMAGE_SECTION_HEADER
* section
;
627 section
= rva_to_section (import_dir
.VirtualAddress
, nt_header
);
628 imports
= RVA_TO_PTR (import_dir
.VirtualAddress
, section
, executable
);
630 for ( ; imports
->Name
; imports
++)
632 char * dllname
= RVA_TO_PTR (imports
->Name
, section
, executable
);
634 if (strcmp (dllname
, "cygwin.dll") == 0)
636 *is_cygnus_app
= TRUE
;
644 close_file_data (&executable
);
648 compare_env (const char **strp1
, const char **strp2
)
650 const char *str1
= *strp1
, *str2
= *strp2
;
652 while (*str1
&& *str2
&& *str1
!= '=' && *str2
!= '=')
654 if (tolower (*str1
) > tolower (*str2
))
656 else if (tolower (*str1
) < tolower (*str2
))
661 if (*str1
== '=' && *str2
== '=')
663 else if (*str1
== '=')
670 merge_and_sort_env (char **envp1
, char **envp2
, char **new_envp
)
686 qsort (new_envp
, num
, sizeof (char *), compare_env
);
691 /* When a new child process is created we need to register it in our list,
692 so intercept spawn requests. */
694 sys_spawnve (int mode
, char *cmdname
, char **argv
, char **envp
)
696 Lisp_Object program
, full
;
697 char *cmdline
, *env
, *parg
, **targ
;
701 int is_dos_app
, is_cygnus_app
;
704 /* We pass our process ID to our children by setting up an environment
705 variable in their environment. */
706 char ppid_env_var_buffer
[64];
707 char *extra_env
[] = {ppid_env_var_buffer
, NULL
};
709 /* We don't care about the other modes */
710 if (mode
!= _P_NOWAIT
)
716 /* Handle executable names without an executable suffix. */
717 program
= make_string (cmdname
, strlen (cmdname
));
718 if (NILP (Ffile_executable_p (program
)))
724 openp (Vexec_path
, program
, EXEC_SUFFIXES
, &full
, 1);
734 /* make sure argv[0] and cmdname are both in DOS format */
735 cmdname
= XSTRING (program
)->data
;
736 unixtodos_filename (cmdname
);
739 /* Determine whether program is a 16-bit DOS executable, or a Win32
740 executable that is implicitly linked to the Cygnus dll (implying it
741 was compiled with the Cygnus GNU toolchain and hence relies on
742 cygwin.dll to parse the command line - we use this to decide how to
743 escape quote chars in command line args that must be quoted). */
744 w32_executable_type (cmdname
, &is_dos_app
, &is_cygnus_app
);
746 /* On Windows 95, if cmdname is a DOS app, we invoke a helper
747 application to start it by specifying the helper app as cmdname,
748 while leaving the real app name as argv[0]. */
751 cmdname
= alloca (MAXPATHLEN
);
752 if (egetenv ("CMDPROXY"))
753 strcpy (cmdname
, egetenv ("CMDPROXY"));
756 strcpy (cmdname
, XSTRING (Vinvocation_directory
)->data
);
757 strcat (cmdname
, "cmdproxy.exe");
759 unixtodos_filename (cmdname
);
762 /* we have to do some conjuring here to put argv and envp into the
763 form CreateProcess wants... argv needs to be a space separated/null
764 terminated list of parameters, and envp is a null
765 separated/double-null terminated list of parameters.
767 Additionally, zero-length args and args containing whitespace or
768 quote chars need to be wrapped in double quotes - for this to work,
769 embedded quotes need to be escaped as well. The aim is to ensure
770 the child process reconstructs the argv array we start with
771 exactly, so we treat quotes at the beginning and end of arguments
774 The Win32 GNU-based library from Cygnus doubles quotes to escape
775 them, while MSVC uses backslash for escaping. (Actually the MSVC
776 startup code does attempt to recognise doubled quotes and accept
777 them, but gets it wrong and ends up requiring three quotes to get a
778 single embedded quote!) So by default we decide whether to use
779 quote or backslash as the escape character based on whether the
780 binary is apparently a Cygnus compiled app.
782 Note that using backslash to escape embedded quotes requires
783 additional special handling if an embedded quote is already
784 preceeded by backslash, or if an arg requiring quoting ends with
785 backslash. In such cases, the run of escape characters needs to be
786 doubled. For consistency, we apply this special handling as long
787 as the escape character is not quote.
789 Since we have no idea how large argv and envp are likely to be we
790 figure out list lengths on the fly and allocate them. */
792 if (!NILP (Vw32_quote_process_args
))
795 /* Override escape char by binding w32-quote-process-args to
796 desired character, or use t for auto-selection. */
797 if (INTEGERP (Vw32_quote_process_args
))
798 escape_char
= XINT (Vw32_quote_process_args
);
800 escape_char
= is_cygnus_app
? '"' : '\\';
810 int escape_char_run
= 0;
818 /* allow for embedded quotes to be escaped */
821 /* handle the case where the embedded quote is already escaped */
822 if (escape_char_run
> 0)
824 /* To preserve the arg exactly, we need to double the
825 preceding escape characters (plus adding one to
826 escape the quote character itself). */
827 arglen
+= escape_char_run
;
830 else if (*p
== ' ' || *p
== '\t')
835 if (*p
== escape_char
&& escape_char
!= '"')
843 /* handle the case where the arg ends with an escape char - we
844 must not let the enclosing quote be escaped. */
845 if (escape_char_run
> 0)
846 arglen
+= escape_char_run
;
848 arglen
+= strlen (*targ
++) + 1;
850 cmdline
= alloca (arglen
);
864 if (*p
== ' ' || *p
== '\t' || *p
== '"')
869 int escape_char_run
= 0;
875 last
= p
+ strlen (p
) - 1;
878 /* This version does not escape quotes if they occur at the
879 beginning or end of the arg - this could lead to incorrect
880 behaviour when the arg itself represents a command line
881 containing quoted args. I believe this was originally done
882 as a hack to make some things work, before
883 `w32-quote-process-args' was added. */
886 if (*p
== '"' && p
> first
&& p
< last
)
887 *parg
++ = escape_char
; /* escape embedded quotes */
895 /* double preceding escape chars if any */
896 while (escape_char_run
> 0)
898 *parg
++ = escape_char
;
901 /* escape all quote chars, even at beginning or end */
902 *parg
++ = escape_char
;
906 if (*p
== escape_char
&& escape_char
!= '"')
911 /* double escape chars before enclosing quote */
912 while (escape_char_run
> 0)
914 *parg
++ = escape_char
;
922 strcpy (parg
, *targ
);
923 parg
+= strlen (*targ
);
933 numenv
= 1; /* for end null */
936 arglen
+= strlen (*targ
++) + 1;
939 /* extra env vars... */
940 sprintf (ppid_env_var_buffer
, "__PARENT_PROCESS_ID=%d",
941 GetCurrentProcessId ());
942 arglen
+= strlen (ppid_env_var_buffer
) + 1;
945 /* merge env passed in and extra env into one, and sort it. */
946 targ
= (char **) alloca (numenv
* sizeof (char *));
947 merge_and_sort_env (envp
, extra_env
, targ
);
949 /* concatenate env entries. */
950 env
= alloca (arglen
);
954 strcpy (parg
, *targ
);
955 parg
+= strlen (*targ
++);
968 /* Now create the process. */
969 if (!create_child (cmdname
, cmdline
, env
, &pid
, cp
))
979 /* Emulate the select call
980 Wait for available input on any of the given rfds, or timeout if
981 a timeout is given and no input is detected
982 wfds and efds are not supported and must be NULL.
984 For simplicity, we detect the death of child processes here and
985 synchronously call the SIGCHLD handler. Since it is possible for
986 children to be created without a corresponding pipe handle from which
987 to read output, we wait separately on the process handles as well as
988 the char_avail events for each process pipe. We only call
989 wait/reap_process when the process actually terminates. */
992 extern HANDLE keyboard_handle
;
994 extern int proc_buffered_char
[];
997 sys_select (int nfds
, SELECT_TYPE
*rfds
, SELECT_TYPE
*wfds
, SELECT_TYPE
*efds
,
1001 DWORD timeout_ms
, start_time
;
1004 child_process
*cp
, *cps
[MAX_CHILDREN
];
1005 HANDLE wait_hnd
[MAXDESC
+ MAX_CHILDREN
];
1006 int fdindex
[MAXDESC
]; /* mapping from wait handles back to descriptors */
1008 timeout_ms
= timeout
? (timeout
->tv_sec
* 1000 + timeout
->tv_usec
/ 1000) : INFINITE
;
1010 /* If the descriptor sets are NULL but timeout isn't, then just Sleep. */
1011 if (rfds
== NULL
&& wfds
== NULL
&& efds
== NULL
&& timeout
!= NULL
)
1017 /* Otherwise, we only handle rfds, so fail otherwise. */
1018 if (rfds
== NULL
|| wfds
!= NULL
|| efds
!= NULL
)
1028 /* Build a list of pipe handles to wait on. */
1030 for (i
= 0; i
< nfds
; i
++)
1031 if (FD_ISSET (i
, &orfds
))
1035 if (keyboard_handle
)
1037 /* Handle stdin specially */
1038 wait_hnd
[nh
] = keyboard_handle
;
1043 /* Check for any emacs-generated input in the queue since
1044 it won't be detected in the wait */
1045 if (detect_input_pending ())
1053 /* Child process and socket input */
1057 int current_status
= cp
->status
;
1059 if (current_status
== STATUS_READ_ACKNOWLEDGED
)
1061 /* Tell reader thread which file handle to use. */
1063 /* Wake up the reader thread for this process */
1064 cp
->status
= STATUS_READ_READY
;
1065 if (!SetEvent (cp
->char_consumed
))
1066 DebPrint (("nt_select.SetEvent failed with "
1067 "%lu for fd %ld\n", GetLastError (), i
));
1070 #ifdef CHECK_INTERLOCK
1071 /* slightly crude cross-checking of interlock between threads */
1073 current_status
= cp
->status
;
1074 if (WaitForSingleObject (cp
->char_avail
, 0) == WAIT_OBJECT_0
)
1076 /* char_avail has been signalled, so status (which may
1077 have changed) should indicate read has completed
1078 but has not been acknowledged. */
1079 current_status
= cp
->status
;
1080 if (current_status
!= STATUS_READ_SUCCEEDED
1081 && current_status
!= STATUS_READ_FAILED
)
1082 DebPrint (("char_avail set, but read not completed: status %d\n",
1087 /* char_avail has not been signalled, so status should
1088 indicate that read is in progress; small possibility
1089 that read has completed but event wasn't yet signalled
1090 when we tested it (because a context switch occurred
1091 or if running on separate CPUs). */
1092 if (current_status
!= STATUS_READ_READY
1093 && current_status
!= STATUS_READ_IN_PROGRESS
1094 && current_status
!= STATUS_READ_SUCCEEDED
1095 && current_status
!= STATUS_READ_FAILED
)
1096 DebPrint (("char_avail reset, but read status is bad: %d\n",
1100 wait_hnd
[nh
] = cp
->char_avail
;
1102 if (!wait_hnd
[nh
]) abort ();
1105 DebPrint (("select waiting on child %d fd %d\n",
1106 cp
-child_procs
, i
));
1111 /* Unable to find something to wait on for this fd, skip */
1112 DebPrint (("sys_select: fd %ld is invalid! ignoring\n", i
));
1119 /* Add handles of child processes. */
1121 for (cp
= child_procs
+(child_proc_count
-1); cp
>= child_procs
; cp
--)
1122 /* some child_procs might be sockets; ignore them */
1123 if (CHILD_ACTIVE (cp
) && cp
->procinfo
.hProcess
)
1125 wait_hnd
[nh
+ nc
] = cp
->procinfo
.hProcess
;
1130 /* Nothing to look for, so we didn't find anything */
1138 /* Wait for input or child death to be signalled. */
1139 start_time
= GetTickCount ();
1140 active
= WaitForMultipleObjects (nh
+ nc
, wait_hnd
, FALSE
, timeout_ms
);
1142 if (active
== WAIT_FAILED
)
1144 DebPrint (("select.WaitForMultipleObjects (%d, %lu) failed with %lu\n",
1145 nh
+ nc
, timeout_ms
, GetLastError ()));
1146 /* don't return EBADF - this causes wait_reading_process_input to
1147 abort; WAIT_FAILED is returned when single-stepping under
1148 Windows 95 after switching thread focus in debugger, and
1149 possibly at other times. */
1153 else if (active
== WAIT_TIMEOUT
)
1157 else if (active
>= WAIT_OBJECT_0
1158 && active
< WAIT_OBJECT_0
+MAXIMUM_WAIT_OBJECTS
)
1160 active
-= WAIT_OBJECT_0
;
1162 else if (active
>= WAIT_ABANDONED_0
1163 && active
< WAIT_ABANDONED_0
+MAXIMUM_WAIT_OBJECTS
)
1165 active
-= WAIT_ABANDONED_0
;
1170 /* Loop over all handles after active (now officially documented as
1171 being the first signalled handle in the array). We do this to
1172 ensure fairness, so that all channels with data available will be
1173 processed - otherwise higher numbered channels could be starved. */
1178 cp
= cps
[active
- nh
];
1179 /* SIG_DFL for SIGCHLD is ignore */
1180 if (sig_handlers
[SIGCHLD
] != SIG_DFL
1181 && sig_handlers
[SIGCHLD
] != SIG_IGN
)
1184 DebPrint (("select calling SIGCHLD handler for pid %d\n",
1188 sig_handlers
[SIGCHLD
] (SIGCHLD
);
1192 else if (fdindex
[active
] == 0)
1194 /* Keyboard input available */
1200 /* must be a socket or pipe - read ahead should have
1201 completed, either succeeding or failing. */
1202 FD_SET (fdindex
[active
], rfds
);
1206 /* Even though wait_reading_process_output only reads from at most
1207 one channel, we must process all channels here so that we reap
1208 all children that have died. */
1209 while (++active
< nh
+ nc
)
1210 if (WaitForSingleObject (wait_hnd
[active
], 0) == WAIT_OBJECT_0
)
1212 } while (active
< nh
+ nc
);
1214 /* If no input has arrived and timeout hasn't expired, wait again. */
1217 DWORD elapsed
= GetTickCount () - start_time
;
1219 if (timeout_ms
> elapsed
) /* INFINITE is MAX_UINT */
1221 if (timeout_ms
!= INFINITE
)
1222 timeout_ms
-= elapsed
;
1223 goto count_children
;
1230 /* Substitute for certain kill () operations */
1232 static BOOL CALLBACK
1233 find_child_console (HWND hwnd
, child_process
* cp
)
1238 thread_id
= GetWindowThreadProcessId (hwnd
, &process_id
);
1239 if (process_id
== cp
->procinfo
.dwProcessId
)
1241 char window_class
[32];
1243 GetClassName (hwnd
, window_class
, sizeof (window_class
));
1244 if (strcmp (window_class
,
1245 (os_subtype
== OS_WIN95
)
1247 : "ConsoleWindowClass") == 0)
1258 sys_kill (int pid
, int sig
)
1262 int need_to_free
= 0;
1265 /* Only handle signals that will result in the process dying */
1266 if (sig
!= SIGINT
&& sig
!= SIGKILL
&& sig
!= SIGQUIT
&& sig
!= SIGHUP
)
1272 cp
= find_child_pid (pid
);
1275 proc_hand
= OpenProcess (PROCESS_TERMINATE
, 0, pid
);
1276 if (proc_hand
== NULL
)
1285 proc_hand
= cp
->procinfo
.hProcess
;
1286 pid
= cp
->procinfo
.dwProcessId
;
1288 /* Try to locate console window for process. */
1289 EnumWindows (find_child_console
, (LPARAM
) cp
);
1294 if (NILP (Vw32_start_process_share_console
) && cp
&& cp
->hwnd
)
1296 BYTE control_scan_code
= (BYTE
) MapVirtualKey (VK_CONTROL
, 0);
1297 BYTE vk_break_code
= VK_CANCEL
;
1298 BYTE break_scan_code
= (BYTE
) MapVirtualKey (vk_break_code
, 0);
1299 HWND foreground_window
;
1301 if (break_scan_code
== 0)
1303 /* Fake Ctrl-C if we can't manage Ctrl-Break. */
1304 vk_break_code
= 'C';
1305 break_scan_code
= (BYTE
) MapVirtualKey (vk_break_code
, 0);
1308 foreground_window
= GetForegroundWindow ();
1309 if (foreground_window
&& SetForegroundWindow (cp
->hwnd
))
1311 /* Generate keystrokes as if user had typed Ctrl-Break or Ctrl-C. */
1312 keybd_event (VK_CONTROL
, control_scan_code
, 0, 0);
1313 keybd_event (vk_break_code
, break_scan_code
, 0, 0);
1314 keybd_event (vk_break_code
, break_scan_code
, KEYEVENTF_KEYUP
, 0);
1315 keybd_event (VK_CONTROL
, control_scan_code
, KEYEVENTF_KEYUP
, 0);
1317 SetForegroundWindow (foreground_window
);
1320 /* Ctrl-Break is NT equivalent of SIGINT. */
1321 else if (!GenerateConsoleCtrlEvent (CTRL_BREAK_EVENT
, pid
))
1323 DebPrint (("sys_kill.GenerateConsoleCtrlEvent return %d "
1324 "for pid %lu\n", GetLastError (), pid
));
1331 if (NILP (Vw32_start_process_share_console
) && cp
&& cp
->hwnd
)
1334 if (os_subtype
== OS_WIN95
)
1337 Another possibility is to try terminating the VDM out-right by
1338 calling the Shell VxD (id 0x17) V86 interface, function #4
1339 "SHELL_Destroy_VM", ie.
1345 First need to determine the current VM handle, and then arrange for
1346 the shellapi call to be made from the system vm (by using
1347 Switch_VM_and_callback).
1349 Could try to invoke DestroyVM through CallVxD.
1352 PostMessage (cp
->hwnd
, WM_QUIT
, 0xff, 0);
1356 PostMessage (cp
->hwnd
, WM_CLOSE
, 0, 0);
1358 /* Kill the process. On W32 this doesn't kill child processes
1359 so it doesn't work very well for shells which is why it's not
1360 used in every case. */
1361 else if (!TerminateProcess (proc_hand
, 0xff))
1363 DebPrint (("sys_kill.TerminateProcess returned %d "
1364 "for pid %lu\n", GetLastError (), pid
));
1371 CloseHandle (proc_hand
);
1376 extern int report_file_error (char *, Lisp_Object
);
1378 /* The following two routines are used to manipulate stdin, stdout, and
1379 stderr of our child processes.
1381 Assuming that in, out, and err are *not* inheritable, we make them
1382 stdin, stdout, and stderr of the child as follows:
1384 - Save the parent's current standard handles.
1385 - Set the std handles to inheritable duplicates of the ones being passed in.
1386 (Note that _get_osfhandle() is an io.h procedure that retrieves the
1387 NT file handle for a crt file descriptor.)
1388 - Spawn the child, which inherits in, out, and err as stdin,
1389 stdout, and stderr. (see Spawnve)
1390 - Close the std handles passed to the child.
1391 - Reset the parent's standard handles to the saved handles.
1392 (see reset_standard_handles)
1393 We assume that the caller closes in, out, and err after calling us. */
1396 prepare_standard_handles (int in
, int out
, int err
, HANDLE handles
[3])
1399 HANDLE newstdin
, newstdout
, newstderr
;
1401 parent
= GetCurrentProcess ();
1403 handles
[0] = GetStdHandle (STD_INPUT_HANDLE
);
1404 handles
[1] = GetStdHandle (STD_OUTPUT_HANDLE
);
1405 handles
[2] = GetStdHandle (STD_ERROR_HANDLE
);
1407 /* make inheritable copies of the new handles */
1408 if (!DuplicateHandle (parent
,
1409 (HANDLE
) _get_osfhandle (in
),
1414 DUPLICATE_SAME_ACCESS
))
1415 report_file_error ("Duplicating input handle for child", Qnil
);
1417 if (!DuplicateHandle (parent
,
1418 (HANDLE
) _get_osfhandle (out
),
1423 DUPLICATE_SAME_ACCESS
))
1424 report_file_error ("Duplicating output handle for child", Qnil
);
1426 if (!DuplicateHandle (parent
,
1427 (HANDLE
) _get_osfhandle (err
),
1432 DUPLICATE_SAME_ACCESS
))
1433 report_file_error ("Duplicating error handle for child", Qnil
);
1435 /* and store them as our std handles */
1436 if (!SetStdHandle (STD_INPUT_HANDLE
, newstdin
))
1437 report_file_error ("Changing stdin handle", Qnil
);
1439 if (!SetStdHandle (STD_OUTPUT_HANDLE
, newstdout
))
1440 report_file_error ("Changing stdout handle", Qnil
);
1442 if (!SetStdHandle (STD_ERROR_HANDLE
, newstderr
))
1443 report_file_error ("Changing stderr handle", Qnil
);
1447 reset_standard_handles (int in
, int out
, int err
, HANDLE handles
[3])
1449 /* close the duplicated handles passed to the child */
1450 CloseHandle (GetStdHandle (STD_INPUT_HANDLE
));
1451 CloseHandle (GetStdHandle (STD_OUTPUT_HANDLE
));
1452 CloseHandle (GetStdHandle (STD_ERROR_HANDLE
));
1454 /* now restore parent's saved std handles */
1455 SetStdHandle (STD_INPUT_HANDLE
, handles
[0]);
1456 SetStdHandle (STD_OUTPUT_HANDLE
, handles
[1]);
1457 SetStdHandle (STD_ERROR_HANDLE
, handles
[2]);
1461 set_process_dir (char * dir
)
1468 /* To avoid problems with winsock implementations that work over dial-up
1469 connections causing or requiring a connection to exist while Emacs is
1470 running, Emacs no longer automatically loads winsock on startup if it
1471 is present. Instead, it will be loaded when open-network-stream is
1474 To allow full control over when winsock is loaded, we provide these
1475 two functions to dynamically load and unload winsock. This allows
1476 dial-up users to only be connected when they actually need to use
1480 extern HANDLE winsock_lib
;
1481 extern BOOL
term_winsock (void);
1482 extern BOOL
init_winsock (int load_now
);
1484 extern Lisp_Object Vsystem_name
;
1486 DEFUN ("w32-has-winsock", Fw32_has_winsock
, Sw32_has_winsock
, 0, 1, 0,
1487 "Test for presence of the Windows socket library `winsock'.\n\
1488 Returns non-nil if winsock support is present, nil otherwise.\n\
1490 If the optional argument LOAD-NOW is non-nil, the winsock library is\n\
1491 also loaded immediately if not already loaded. If winsock is loaded,\n\
1492 the winsock local hostname is returned (since this may be different from\n\
1493 the value of `system-name' and should supplant it), otherwise t is\n\
1494 returned to indicate winsock support is present.")
1496 Lisp_Object load_now
;
1500 have_winsock
= init_winsock (!NILP (load_now
));
1503 if (winsock_lib
!= NULL
)
1505 /* Return new value for system-name. The best way to do this
1506 is to call init_system_name, saving and restoring the
1507 original value to avoid side-effects. */
1508 Lisp_Object orig_hostname
= Vsystem_name
;
1509 Lisp_Object hostname
;
1511 init_system_name ();
1512 hostname
= Vsystem_name
;
1513 Vsystem_name
= orig_hostname
;
1521 DEFUN ("w32-unload-winsock", Fw32_unload_winsock
, Sw32_unload_winsock
,
1523 "Unload the Windows socket library `winsock' if loaded.\n\
1524 This is provided to allow dial-up socket connections to be disconnected\n\
1525 when no longer needed. Returns nil without unloading winsock if any\n\
1526 socket connections still exist.")
1529 return term_winsock () ? Qt
: Qnil
;
1532 #endif /* HAVE_SOCKETS */
1535 /* Some miscellaneous functions that are Windows specific, but not GUI
1536 specific (ie. are applicable in terminal or batch mode as well). */
1538 /* lifted from fileio.c */
1539 #define CORRECT_DIR_SEPS(s) \
1540 do { if ('/' == DIRECTORY_SEP) dostounix_filename (s); \
1541 else unixtodos_filename (s); \
1544 DEFUN ("w32-short-file-name", Fw32_short_file_name
, Sw32_short_file_name
, 1, 1, 0,
1545 "Return the short file name version (8.3) of the full path of FILENAME.\n\
1546 If FILENAME does not exist, return nil.\n\
1547 All path elements in FILENAME are converted to their short names.")
1549 Lisp_Object filename
;
1551 char shortname
[MAX_PATH
];
1553 CHECK_STRING (filename
, 0);
1555 /* first expand it. */
1556 filename
= Fexpand_file_name (filename
, Qnil
);
1558 /* luckily, this returns the short version of each element in the path. */
1559 if (GetShortPathName (XSTRING (filename
)->data
, shortname
, MAX_PATH
) == 0)
1562 CORRECT_DIR_SEPS (shortname
);
1564 return build_string (shortname
);
1568 DEFUN ("w32-long-file-name", Fw32_long_file_name
, Sw32_long_file_name
,
1570 "Return the long file name version of the full path of FILENAME.\n\
1571 If FILENAME does not exist, return nil.\n\
1572 All path elements in FILENAME are converted to their long names.")
1574 Lisp_Object filename
;
1576 char longname
[ MAX_PATH
];
1578 CHECK_STRING (filename
, 0);
1580 /* first expand it. */
1581 filename
= Fexpand_file_name (filename
, Qnil
);
1583 if (!w32_get_long_filename (XSTRING (filename
)->data
, longname
, MAX_PATH
))
1586 CORRECT_DIR_SEPS (longname
);
1588 return build_string (longname
);
1591 DEFUN ("w32-set-process-priority", Fw32_set_process_priority
, Sw32_set_process_priority
,
1593 "Set the priority of PROCESS to PRIORITY.\n\
1594 If PROCESS is nil, the priority of Emacs is changed, otherwise the\n\
1595 priority of the process whose pid is PROCESS is changed.\n\
1596 PRIORITY should be one of the symbols high, normal, or low;\n\
1597 any other symbol will be interpreted as normal.\n\
1599 If successful, the return value is t, otherwise nil.")
1601 Lisp_Object process
, priority
;
1603 HANDLE proc_handle
= GetCurrentProcess ();
1604 DWORD priority_class
= NORMAL_PRIORITY_CLASS
;
1605 Lisp_Object result
= Qnil
;
1607 CHECK_SYMBOL (priority
, 0);
1609 if (!NILP (process
))
1614 CHECK_NUMBER (process
, 0);
1616 /* Allow pid to be an internally generated one, or one obtained
1617 externally. This is necessary because real pids on Win95 are
1620 pid
= XINT (process
);
1621 cp
= find_child_pid (pid
);
1623 pid
= cp
->procinfo
.dwProcessId
;
1625 proc_handle
= OpenProcess (PROCESS_SET_INFORMATION
, FALSE
, pid
);
1628 if (EQ (priority
, Qhigh
))
1629 priority_class
= HIGH_PRIORITY_CLASS
;
1630 else if (EQ (priority
, Qlow
))
1631 priority_class
= IDLE_PRIORITY_CLASS
;
1633 if (proc_handle
!= NULL
)
1635 if (SetPriorityClass (proc_handle
, priority_class
))
1637 if (!NILP (process
))
1638 CloseHandle (proc_handle
);
1645 DEFUN ("w32-get-locale-info", Fw32_get_locale_info
, Sw32_get_locale_info
, 1, 2, 0,
1646 "Return information about the Windows locale LCID.\n\
1647 By default, return a three letter locale code which encodes the default\n\
1648 language as the first two characters, and the country or regionial variant\n\
1649 as the third letter. For example, ENU refers to `English (United States)',\n\
1650 while ENC means `English (Canadian)'.\n\
1652 If the optional argument LONGFORM is non-nil, the long form of the locale\n\
1653 name is returned, e.g. `English (United States)' instead.\n\
1655 If LCID (a 16-bit number) is not a valid locale, the result is nil.")
1657 Lisp_Object lcid
, longform
;
1661 char abbrev_name
[32] = { 0 };
1662 char full_name
[256] = { 0 };
1664 CHECK_NUMBER (lcid
, 0);
1666 if (!IsValidLocale (XINT (lcid
), LCID_SUPPORTED
))
1669 if (NILP (longform
))
1671 got_abbrev
= GetLocaleInfo (XINT (lcid
),
1672 LOCALE_SABBREVLANGNAME
| LOCALE_USE_CP_ACP
,
1673 abbrev_name
, sizeof (abbrev_name
));
1675 return build_string (abbrev_name
);
1679 got_full
= GetLocaleInfo (XINT (lcid
),
1680 LOCALE_SLANGUAGE
| LOCALE_USE_CP_ACP
,
1681 full_name
, sizeof (full_name
));
1683 return build_string (full_name
);
1690 DEFUN ("w32-get-current-locale-id", Fw32_get_current_locale_id
, Sw32_get_current_locale_id
, 0, 0, 0,
1691 "Return Windows locale id for current locale setting.\n\
1692 This is a numerical value; use `w32-get-locale-info' to convert to a\n\
1693 human-readable form.")
1696 return make_number (GetThreadLocale ());
1700 DEFUN ("w32-get-default-locale-id", Fw32_get_default_locale_id
, Sw32_get_default_locale_id
, 0, 1, 0,
1701 "Return Windows locale id for default locale setting.\n\
1702 By default, the system default locale setting is returned; if the optional\n\
1703 parameter USERP is non-nil, the user default locale setting is returned.\n\
1704 This is a numerical value; use `w32-get-locale-info' to convert to a\n\
1705 human-readable form.")
1710 return make_number (GetSystemDefaultLCID ());
1711 return make_number (GetUserDefaultLCID ());
1715 DEFUN ("w32-set-current-locale", Fw32_set_current_locale
, Sw32_set_current_locale
, 1, 1, 0,
1716 "Make Windows locale LCID be the current locale setting for Emacs.\n\
1717 If successful, the new locale id is returned, otherwise nil.")
1721 CHECK_NUMBER (lcid
, 0);
1723 if (!IsValidLocale (XINT (lcid
), LCID_SUPPORTED
))
1726 if (!SetThreadLocale (XINT (lcid
)))
1729 return make_number (GetThreadLocale ());
1735 Qhigh
= intern ("high");
1736 Qlow
= intern ("low");
1739 defsubr (&Sw32_has_winsock
);
1740 defsubr (&Sw32_unload_winsock
);
1742 defsubr (&Sw32_short_file_name
);
1743 defsubr (&Sw32_long_file_name
);
1744 defsubr (&Sw32_set_process_priority
);
1745 defsubr (&Sw32_get_locale_info
);
1746 defsubr (&Sw32_get_current_locale_id
);
1747 defsubr (&Sw32_get_default_locale_id
);
1748 defsubr (&Sw32_set_current_locale
);
1750 DEFVAR_LISP ("w32-quote-process-args", &Vw32_quote_process_args
,
1751 "Non-nil enables quoting of process arguments to ensure correct parsing.\n\
1752 Because Windows does not directly pass argv arrays to child processes,\n\
1753 programs have to reconstruct the argv array by parsing the command\n\
1754 line string. For an argument to contain a space, it must be enclosed\n\
1755 in double quotes or it will be parsed as multiple arguments.\n\
1757 If the value is a character, that character will be used to escape any\n\
1758 quote characters that appear, otherwise a suitable escape character\n\
1759 will be chosen based on the type of the program.");
1760 Vw32_quote_process_args
= Qt
;
1762 DEFVAR_LISP ("w32-start-process-show-window",
1763 &Vw32_start_process_show_window
,
1764 "When nil, processes started via start-process hide their windows.\n\
1765 When non-nil, they show their window in the method of their choice.");
1766 Vw32_start_process_show_window
= Qnil
;
1768 DEFVAR_LISP ("w32-start-process-share-console",
1769 &Vw32_start_process_share_console
,
1770 "When nil, processes started via start-process are given a new console.\n\
1771 When non-nil, they share the Emacs console; this has the limitation of\n\
1772 allowing only only DOS subprocess to run at a time (whether started directly\n\
1773 or indirectly by Emacs), and preventing Emacs from cleanly terminating the\n\
1774 subprocess group, but may allow Emacs to interrupt a subprocess that doesn't\n\
1775 otherwise respond to interrupts from Emacs.");
1776 Vw32_start_process_share_console
= Qnil
;
1778 DEFVAR_INT ("w32-pipe-read-delay", &Vw32_pipe_read_delay
,
1779 "Forced delay before reading subprocess output.\n\
1780 This is done to improve the buffering of subprocess output, by\n\
1781 avoiding the inefficiency of frequently reading small amounts of data.\n\
1783 If positive, the value is the number of milliseconds to sleep before\n\
1784 reading the subprocess output. If negative, the magnitude is the number\n\
1785 of time slices to wait (effectively boosting the priority of the child\n\
1786 process temporarily). A value of zero disables waiting entirely.");
1787 Vw32_pipe_read_delay
= 50;
1789 DEFVAR_LISP ("w32-downcase-file-names", &Vw32_downcase_file_names
,
1790 "Non-nil means convert all-upper case file names to lower case.\n\
1791 This applies when performing completions and file name expansion.");
1792 Vw32_downcase_file_names
= Qnil
;
1795 DEFVAR_LISP ("w32-generate-fake-inodes", &Vw32_generate_fake_inodes
,
1796 "Non-nil means attempt to fake realistic inode values.\n\
1797 This works by hashing the truename of files, and should detect \n\
1798 aliasing between long and short (8.3 DOS) names, but can have\n\
1799 false positives because of hash collisions. Note that determing\n\
1800 the truename of a file can be slow.");
1801 Vw32_generate_fake_inodes
= Qnil
;
1804 DEFVAR_LISP ("w32-get-true-file-attributes", &Vw32_get_true_file_attributes
,
1805 "Non-nil means determine accurate link count in file-attributes.\n\
1806 This option slows down file-attributes noticeably, so is disabled by\n\
1807 default. Note that it is only useful for files on NTFS volumes,\n\
1808 where hard links are supported.");
1809 Vw32_get_true_file_attributes
= Qnil
;
1811 /* end of ntproc.c */