1 /* Process support for GNU Emacs on the Microsoft Windows API.
3 Copyright (C) 1992, 1995, 1999-2015 Free Software Foundation, Inc.
5 This file is part of GNU Emacs.
7 GNU Emacs is free software: you can redistribute it and/or modify
8 it under the terms of the GNU General Public License as published by
9 the Free Software Foundation, either version 3 of the License, or
10 (at your option) any later version.
12 GNU Emacs is distributed in the hope that it will be useful,
13 but WITHOUT ANY WARRANTY; without even the implied warranty of
14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 GNU General Public License for more details.
17 You should have received a copy of the GNU General Public License
18 along with GNU Emacs. If not, see <http://www.gnu.org/licenses/>. */
21 Drew Bliss Oct 14, 1993
22 Adapted from alarm.c by Tim Fleehart
25 #include <mingw_time.h>
36 /* must include CRT headers *before* config.h */
46 #if defined(__GNUC__) && !defined(__MINGW64__)
47 /* This definition is missing from mingw.org headers, but not MinGW64
49 extern BOOL WINAPI
IsValidLocale (LCID
, DWORD
);
52 #ifdef HAVE_LANGINFO_CODESET
59 #include "w32common.h"
64 #include "syssignal.h"
66 #include "dispextern.h" /* for xstrcasecmp */
69 #define RVA_TO_PTR(var,section,filedata) \
70 ((void *)((section)->PointerToRawData \
71 + ((DWORD_PTR)(var) - (section)->VirtualAddress) \
72 + (filedata).file_base))
74 Lisp_Object Qhigh
, Qlow
;
76 /* Signal handlers...SIG_DFL == 0 so this is initialized correctly. */
77 static signal_handler sig_handlers
[NSIG
];
79 static sigset_t sig_mask
;
81 static CRITICAL_SECTION crit_sig
;
83 /* Improve on the CRT 'signal' implementation so that we could record
84 the SIGCHLD handler and fake interval timers. */
86 sys_signal (int sig
, signal_handler handler
)
90 /* SIGCHLD is needed for supporting subprocesses, see sys_kill
91 below. SIGALRM and SIGPROF are used by setitimer. All the
92 others are the only ones supported by the MS runtime. */
93 if (!(sig
== SIGCHLD
|| sig
== SIGSEGV
|| sig
== SIGILL
94 || sig
== SIGFPE
|| sig
== SIGABRT
|| sig
== SIGTERM
95 || sig
== SIGALRM
|| sig
== SIGPROF
))
100 old
= sig_handlers
[sig
];
101 /* SIGABRT is treated specially because w32.c installs term_ntproc
102 as its handler, so we don't want to override that afterwards.
103 Aborting Emacs works specially anyway: either by calling
104 emacs_abort directly or through terminate_due_to_signal, which
105 calls emacs_abort through emacs_raise. */
106 if (!(sig
== SIGABRT
&& old
== term_ntproc
))
108 sig_handlers
[sig
] = handler
;
109 if (!(sig
== SIGCHLD
|| sig
== SIGALRM
|| sig
== SIGPROF
))
110 signal (sig
, handler
);
115 /* Emulate sigaction. */
117 sigaction (int sig
, const struct sigaction
*act
, struct sigaction
*oact
)
119 signal_handler old
= SIG_DFL
;
123 old
= sys_signal (sig
, act
->sa_handler
);
125 old
= sig_handlers
[sig
];
134 oact
->sa_handler
= old
;
136 oact
->sa_mask
= empty_mask
;
141 /* Emulate signal sets and blocking of signals used by timers. */
144 sigemptyset (sigset_t
*set
)
151 sigaddset (sigset_t
*set
, int signo
)
158 if (signo
< 0 || signo
>= NSIG
)
164 *set
|= (1U << signo
);
170 sigfillset (sigset_t
*set
)
183 sigprocmask (int how
, const sigset_t
*set
, sigset_t
*oset
)
185 if (!(how
== SIG_BLOCK
|| how
== SIG_UNBLOCK
|| how
== SIG_SETMASK
))
206 /* FIXME: Catch signals that are blocked and reissue them when
207 they are unblocked. Important for SIGALRM and SIGPROF only. */
216 pthread_sigmask (int how
, const sigset_t
*set
, sigset_t
*oset
)
218 if (sigprocmask (how
, set
, oset
) == -1)
224 sigismember (const sigset_t
*set
, int signo
)
226 if (signo
< 0 || signo
>= NSIG
)
231 if (signo
> sizeof (*set
) * BITS_PER_CHAR
)
234 return (*set
& (1U << signo
)) != 0;
250 setpgid (pid_t pid
, pid_t pgid
)
261 /* Emulations of interval timers.
263 Limitations: only ITIMER_REAL and ITIMER_PROF are supported.
265 Implementation: a separate thread is started for each timer type,
266 the thread calls the appropriate signal handler when the timer
267 expires, after stopping the thread which installed the timer. */
270 volatile ULONGLONG expire
;
271 volatile ULONGLONG reload
;
272 volatile int terminate
;
274 HANDLE caller_thread
;
278 static ULONGLONG ticks_now
;
279 static struct itimer_data real_itimer
, prof_itimer
;
280 static ULONGLONG clocks_min
;
281 /* If non-zero, itimers are disabled. Used during shutdown, when we
282 delete the critical sections used by the timer threads. */
283 static int disable_itimers
;
285 static CRITICAL_SECTION crit_real
, crit_prof
;
287 /* GetThreadTimes is not available on Windows 9X and possibly also on 2K. */
288 typedef BOOL (WINAPI
*GetThreadTimes_Proc
) (
290 LPFILETIME lpCreationTime
,
291 LPFILETIME lpExitTime
,
292 LPFILETIME lpKernelTime
,
293 LPFILETIME lpUserTime
);
295 static GetThreadTimes_Proc s_pfn_Get_Thread_Times
;
297 #define MAX_SINGLE_SLEEP 30
298 #define TIMER_TICKS_PER_SEC 1000
300 /* Return a suitable time value, in 1-ms units, for THREAD, a handle
301 to a thread. If THREAD is NULL or an invalid handle, return the
302 current wall-clock time since January 1, 1601 (UTC). Otherwise,
303 return the sum of kernel and user times used by THREAD since it was
304 created, plus its creation time. */
306 w32_get_timer_time (HANDLE thread
)
309 int use_system_time
= 1;
310 /* The functions below return times in 100-ns units. */
311 const int tscale
= 10 * TIMER_TICKS_PER_SEC
;
313 if (thread
&& thread
!= INVALID_HANDLE_VALUE
314 && s_pfn_Get_Thread_Times
!= NULL
)
316 FILETIME creation_ftime
, exit_ftime
, kernel_ftime
, user_ftime
;
317 ULARGE_INTEGER temp_creation
, temp_kernel
, temp_user
;
319 if (s_pfn_Get_Thread_Times (thread
, &creation_ftime
, &exit_ftime
,
320 &kernel_ftime
, &user_ftime
))
323 temp_creation
.LowPart
= creation_ftime
.dwLowDateTime
;
324 temp_creation
.HighPart
= creation_ftime
.dwHighDateTime
;
325 temp_kernel
.LowPart
= kernel_ftime
.dwLowDateTime
;
326 temp_kernel
.HighPart
= kernel_ftime
.dwHighDateTime
;
327 temp_user
.LowPart
= user_ftime
.dwLowDateTime
;
328 temp_user
.HighPart
= user_ftime
.dwHighDateTime
;
330 temp_creation
.QuadPart
/ tscale
+ temp_kernel
.QuadPart
/ tscale
331 + temp_user
.QuadPart
/ tscale
;
334 DebPrint (("GetThreadTimes failed with error code %lu\n",
340 FILETIME current_ftime
;
343 GetSystemTimeAsFileTime (¤t_ftime
);
345 temp
.LowPart
= current_ftime
.dwLowDateTime
;
346 temp
.HighPart
= current_ftime
.dwHighDateTime
;
348 retval
= temp
.QuadPart
/ tscale
;
354 /* Thread function for a timer thread. */
356 timer_loop (LPVOID arg
)
358 struct itimer_data
*itimer
= (struct itimer_data
*)arg
;
359 int which
= itimer
->type
;
360 int sig
= (which
== ITIMER_REAL
) ? SIGALRM
: SIGPROF
;
361 CRITICAL_SECTION
*crit
= (which
== ITIMER_REAL
) ? &crit_real
: &crit_prof
;
362 const DWORD max_sleep
= MAX_SINGLE_SLEEP
* 1000 / TIMER_TICKS_PER_SEC
;
363 HANDLE hth
= (which
== ITIMER_REAL
) ? NULL
: itimer
->caller_thread
;
368 signal_handler handler
;
369 ULONGLONG now
, expire
, reload
;
371 /* Load new values if requested by setitimer. */
372 EnterCriticalSection (crit
);
373 expire
= itimer
->expire
;
374 reload
= itimer
->reload
;
375 LeaveCriticalSection (crit
);
376 if (itimer
->terminate
)
386 if (expire
> (now
= w32_get_timer_time (hth
)))
387 sleep_time
= expire
- now
;
390 /* Don't sleep too long at a time, to be able to see the
391 termination flag without too long a delay. */
392 while (sleep_time
> max_sleep
)
394 if (itimer
->terminate
)
397 EnterCriticalSection (crit
);
398 expire
= itimer
->expire
;
399 LeaveCriticalSection (crit
);
401 (expire
> (now
= w32_get_timer_time (hth
))) ? expire
- now
: 0;
403 if (itimer
->terminate
)
407 Sleep (sleep_time
* 1000 / TIMER_TICKS_PER_SEC
);
408 /* Always sleep past the expiration time, to make sure we
409 never call the handler _before_ the expiration time,
410 always slightly after it. Sleep(5) makes sure we don't
411 hog the CPU by calling 'w32_get_timer_time' with high
412 frequency, and also let other threads work. */
413 while (w32_get_timer_time (hth
) < expire
)
417 EnterCriticalSection (crit
);
418 expire
= itimer
->expire
;
419 LeaveCriticalSection (crit
);
424 handler
= sig_handlers
[sig
];
425 if (!(handler
== SIG_DFL
|| handler
== SIG_IGN
|| handler
== SIG_ERR
)
426 /* FIXME: Don't ignore masked signals. Instead, record that
427 they happened and reissue them when the signal is
429 && !sigismember (&sig_mask
, sig
)
430 /* Simulate masking of SIGALRM and SIGPROF when processing
432 && !fatal_error_in_progress
433 && itimer
->caller_thread
)
435 /* Simulate a signal delivered to the thread which installed
436 the timer, by suspending that thread while the handler
438 HANDLE th
= itimer
->caller_thread
;
439 DWORD result
= SuspendThread (th
);
441 if (result
== (DWORD
)-1)
448 /* Update expiration time and loop. */
449 EnterCriticalSection (crit
);
450 expire
= itimer
->expire
;
453 LeaveCriticalSection (crit
);
456 reload
= itimer
->reload
;
459 now
= w32_get_timer_time (hth
);
462 ULONGLONG lag
= now
- expire
;
464 /* If we missed some opportunities (presumably while
465 sleeping or while the signal handler ran), skip
468 expire
= now
- (lag
% reload
);
474 expire
= 0; /* become idle */
475 itimer
->expire
= expire
;
476 LeaveCriticalSection (crit
);
482 stop_timer_thread (int which
)
484 struct itimer_data
*itimer
=
485 (which
== ITIMER_REAL
) ? &real_itimer
: &prof_itimer
;
487 DWORD err
, exit_code
= 255;
490 /* Signal the thread that it should terminate. */
491 itimer
->terminate
= 1;
493 if (itimer
->timer_thread
== NULL
)
496 /* Wait for the timer thread to terminate voluntarily, then kill it
497 if it doesn't. This loop waits twice more than the maximum
498 amount of time a timer thread sleeps, see above. */
499 for (i
= 0; i
< MAX_SINGLE_SLEEP
/ 5; i
++)
501 if (!((status
= GetExitCodeThread (itimer
->timer_thread
, &exit_code
))
502 && exit_code
== STILL_ACTIVE
))
506 if ((status
== FALSE
&& (err
= GetLastError ()) == ERROR_INVALID_HANDLE
)
507 || exit_code
== STILL_ACTIVE
)
509 if (!(status
== FALSE
&& err
== ERROR_INVALID_HANDLE
))
510 TerminateThread (itimer
->timer_thread
, 0);
514 CloseHandle (itimer
->timer_thread
);
515 itimer
->timer_thread
= NULL
;
516 if (itimer
->caller_thread
)
518 CloseHandle (itimer
->caller_thread
);
519 itimer
->caller_thread
= NULL
;
523 /* This is called at shutdown time from term_ntproc. */
527 if (real_itimer
.timer_thread
)
528 stop_timer_thread (ITIMER_REAL
);
529 if (prof_itimer
.timer_thread
)
530 stop_timer_thread (ITIMER_PROF
);
532 /* We are going to delete the critical sections, so timers cannot
536 DeleteCriticalSection (&crit_real
);
537 DeleteCriticalSection (&crit_prof
);
538 DeleteCriticalSection (&crit_sig
);
541 /* This is called at initialization time from init_ntproc. */
545 /* GetThreadTimes is not available on all versions of Windows, so
546 need to probe for its availability dynamically, and call it
547 through a pointer. */
548 s_pfn_Get_Thread_Times
= NULL
; /* in case dumped Emacs comes with a value */
549 if (os_subtype
!= OS_9X
)
550 s_pfn_Get_Thread_Times
=
551 (GetThreadTimes_Proc
)GetProcAddress (GetModuleHandle ("kernel32.dll"),
554 /* Make sure we start with zeroed out itimer structures, since
555 dumping may have left there traces of threads long dead. */
556 memset (&real_itimer
, 0, sizeof real_itimer
);
557 memset (&prof_itimer
, 0, sizeof prof_itimer
);
559 InitializeCriticalSection (&crit_real
);
560 InitializeCriticalSection (&crit_prof
);
561 InitializeCriticalSection (&crit_sig
);
567 start_timer_thread (int which
)
569 DWORD exit_code
, tid
;
571 struct itimer_data
*itimer
=
572 (which
== ITIMER_REAL
) ? &real_itimer
: &prof_itimer
;
574 if (itimer
->timer_thread
575 && GetExitCodeThread (itimer
->timer_thread
, &exit_code
)
576 && exit_code
== STILL_ACTIVE
)
579 /* Clean up after possibly exited thread. */
580 if (itimer
->timer_thread
)
582 CloseHandle (itimer
->timer_thread
);
583 itimer
->timer_thread
= NULL
;
585 if (itimer
->caller_thread
)
587 CloseHandle (itimer
->caller_thread
);
588 itimer
->caller_thread
= NULL
;
591 /* Start a new thread. */
592 if (!DuplicateHandle (GetCurrentProcess (), GetCurrentThread (),
593 GetCurrentProcess (), &th
, 0, FALSE
,
594 DUPLICATE_SAME_ACCESS
))
599 itimer
->terminate
= 0;
600 itimer
->type
= which
;
601 itimer
->caller_thread
= th
;
602 /* Request that no more than 64KB of stack be reserved for this
603 thread, to avoid reserving too much memory, which would get in
604 the way of threads we start to wait for subprocesses. See also
606 itimer
->timer_thread
= CreateThread (NULL
, 64 * 1024, timer_loop
,
607 (void *)itimer
, 0x00010000, &tid
);
609 if (!itimer
->timer_thread
)
611 CloseHandle (itimer
->caller_thread
);
612 itimer
->caller_thread
= NULL
;
617 /* This is needed to make sure that the timer thread running for
618 profiling gets CPU as soon as the Sleep call terminates. */
619 if (which
== ITIMER_PROF
)
620 SetThreadPriority (itimer
->timer_thread
, THREAD_PRIORITY_TIME_CRITICAL
);
625 /* Most of the code of getitimer and setitimer (but not of their
626 subroutines) was shamelessly stolen from itimer.c in the DJGPP
627 library, see www.delorie.com/djgpp. */
629 getitimer (int which
, struct itimerval
*value
)
631 volatile ULONGLONG
*t_expire
;
632 volatile ULONGLONG
*t_reload
;
633 ULONGLONG expire
, reload
;
635 CRITICAL_SECTION
*crit
;
636 struct itimer_data
*itimer
;
647 if (which
!= ITIMER_REAL
&& which
!= ITIMER_PROF
)
653 itimer
= (which
== ITIMER_REAL
) ? &real_itimer
: &prof_itimer
;
655 ticks_now
= w32_get_timer_time ((which
== ITIMER_REAL
)
657 : GetCurrentThread ());
659 t_expire
= &itimer
->expire
;
660 t_reload
= &itimer
->reload
;
661 crit
= (which
== ITIMER_REAL
) ? &crit_real
: &crit_prof
;
663 EnterCriticalSection (crit
);
666 LeaveCriticalSection (crit
);
671 value
->it_value
.tv_sec
= expire
/ TIMER_TICKS_PER_SEC
;
673 (expire
% TIMER_TICKS_PER_SEC
) * (__int64
)1000000 / TIMER_TICKS_PER_SEC
;
674 value
->it_value
.tv_usec
= usecs
;
675 value
->it_interval
.tv_sec
= reload
/ TIMER_TICKS_PER_SEC
;
677 (reload
% TIMER_TICKS_PER_SEC
) * (__int64
)1000000 / TIMER_TICKS_PER_SEC
;
678 value
->it_interval
.tv_usec
= usecs
;
684 setitimer(int which
, struct itimerval
*value
, struct itimerval
*ovalue
)
686 volatile ULONGLONG
*t_expire
, *t_reload
;
687 ULONGLONG expire
, reload
, expire_old
, reload_old
;
689 CRITICAL_SECTION
*crit
;
690 struct itimerval tem
, *ptem
;
695 /* Posix systems expect timer values smaller than the resolution of
696 the system clock be rounded up to the clock resolution. First
697 time we are called, measure the clock tick resolution. */
702 for (t1
= w32_get_timer_time (NULL
);
703 (t2
= w32_get_timer_time (NULL
)) == t1
; )
705 clocks_min
= t2
- t1
;
713 if (getitimer (which
, ptem
)) /* also sets ticks_now */
714 return -1; /* errno already set */
717 (which
== ITIMER_REAL
) ? &real_itimer
.expire
: &prof_itimer
.expire
;
719 (which
== ITIMER_REAL
) ? &real_itimer
.reload
: &prof_itimer
.reload
;
721 crit
= (which
== ITIMER_REAL
) ? &crit_real
: &crit_prof
;
724 || (value
->it_value
.tv_sec
== 0 && value
->it_value
.tv_usec
== 0))
726 EnterCriticalSection (crit
);
727 /* Disable the timer. */
730 LeaveCriticalSection (crit
);
734 reload
= value
->it_interval
.tv_sec
* TIMER_TICKS_PER_SEC
;
736 usecs
= value
->it_interval
.tv_usec
;
737 if (value
->it_interval
.tv_sec
== 0
738 && usecs
&& usecs
* TIMER_TICKS_PER_SEC
< clocks_min
* 1000000)
742 usecs
*= TIMER_TICKS_PER_SEC
;
743 reload
+= usecs
/ 1000000;
746 expire
= value
->it_value
.tv_sec
* TIMER_TICKS_PER_SEC
;
747 usecs
= value
->it_value
.tv_usec
;
748 if (value
->it_value
.tv_sec
== 0
749 && usecs
* TIMER_TICKS_PER_SEC
< clocks_min
* 1000000)
753 usecs
*= TIMER_TICKS_PER_SEC
;
754 expire
+= usecs
/ 1000000;
759 EnterCriticalSection (crit
);
760 expire_old
= *t_expire
;
761 reload_old
= *t_reload
;
762 if (!(expire
== expire_old
&& reload
== reload_old
))
767 LeaveCriticalSection (crit
);
769 return start_timer_thread (which
);
775 #ifdef HAVE_SETITIMER
776 struct itimerval new_values
, old_values
;
778 new_values
.it_value
.tv_sec
= seconds
;
779 new_values
.it_value
.tv_usec
= 0;
780 new_values
.it_interval
.tv_sec
= new_values
.it_interval
.tv_usec
= 0;
782 if (setitimer (ITIMER_REAL
, &new_values
, &old_values
) < 0)
784 return old_values
.it_value
.tv_sec
;
792 /* Here's an overview of how support for subprocesses and
793 network/serial streams is implemented on MS-Windows.
795 The management of both subprocesses and network/serial streams
796 circles around the child_procs[] array, which can record up to the
797 grand total of MAX_CHILDREN (= 32) of these. (The reasons for the
798 32 limitation will become clear below.) Each member of
799 child_procs[] is a child_process structure, defined on w32.h.
801 A related data structure is the fd_info[] array, which holds twice
802 as many members, 64, and records the information about file
803 descriptors used for communicating with subprocesses and
804 network/serial devices. Each member of the array is the filedesc
805 structure, which records the Windows handle for communications,
806 such as the read end of the pipe to a subprocess, a socket handle,
809 Both these arrays reference each other: there's a member of
810 child_process structure that records the file corresponding
811 descriptor, and there's a member of filedesc structure that holds a
812 pointer to the corresponding child_process.
814 Whenever Emacs starts a subprocess or opens a network/serial
815 stream, the function new_child is called to prepare a new
816 child_process structure. new_child looks for the first vacant slot
817 in the child_procs[] array, initializes it, and starts a "reader
818 thread" that will watch the output of the subprocess/stream and its
819 status. (If no vacant slot can be found, new_child returns a
820 failure indication to its caller, and the higher-level Emacs
821 primitive will then fail with EMFILE or EAGAIN.)
823 The reader thread started by new_child communicates with the main
824 (a.k.a. "Lisp") thread via two event objects and a status, all of
825 them recorded by the members of the child_process structure in
826 child_procs[]. The event objects serve as semaphores between the
827 reader thread and the 'select' emulation in sys_select, as follows:
829 . Initially, the reader thread is waiting for the char_consumed
830 event to become signaled by sys_select, which is an indication
831 for the reader thread to go ahead and try reading more stuff
832 from the subprocess/stream.
834 . The reader thread then attempts to read by calling a
835 blocking-read function. When the read call returns, either
836 successfully or with some failure indication, the reader thread
837 updates the status of the read accordingly, and signals the 2nd
838 event object, char_avail, on whose handle sys_select is
839 waiting. This tells sys_select that the file descriptor
840 allocated for the subprocess or the the stream is ready to be
843 When the subprocess exits or the network/serial stream is closed,
844 the reader thread sets the status accordingly and exits. It also
845 exits when the main thread sets the ststus to STATUS_READ_ERROR
846 and/or the char_avail and char_consumed event handles are NULL;
847 this is how delete_child, called by Emacs when a subprocess or a
848 stream is terminated, terminates the reader thread as part of
849 deleting the child_process object.
851 The sys_select function emulates the Posix 'pselect' function; it
852 is needed because the Windows 'select' function supports only
853 network sockets, while Emacs expects 'pselect' to work for any file
854 descriptor, including pipes and serial streams.
856 When sys_select is called, it uses the information in fd_info[]
857 array to convert the file descriptors which it was asked to watch
858 into Windows handles. In general, the handle to watch is the
859 handle of the char_avail event of the child_process structure that
860 corresponds to the file descriptor. In addition, for subprocesses,
861 sys_select watches one more handle: the handle for the subprocess,
862 so that it could emulate the SIGCHLD signal when the subprocess
865 If file descriptor zero (stdin) doesn't have its bit set in the
866 'rfds' argument to sys_select, the function always watches for
867 keyboard interrupts, to be able to return when the user presses
870 Having collected the handles to watch, sys_select calls
871 WaitForMultipleObjects to wait for any one of them to become
872 signaled. Since WaitForMultipleObjects can only watch up to 64
873 handles, Emacs on Windows is limited to maximum 32 child_process
874 objects (since a subprocess consumes 2 handles to be watched, see
877 When any of the handles become signaled, sys_select does whatever
878 is appropriate for the corresponding child_process object:
880 . If it's a handle to the char_avail event, sys_select marks the
881 corresponding bit in 'rfds', and Emacs will then read from that
884 . If it's a handle to the process, sys_select calls the SIGCHLD
885 handler, to inform Emacs of the fact that the subprocess
888 The waitpid emulation works very similar to sys_select, except that
889 it only watches handles of subprocesses, and doesn't synchronize
890 with the reader thread.
892 Because socket descriptors on Windows are handles, while Emacs
893 expects them to be file descriptors, all low-level I/O functions,
894 such as 'read' and 'write', and all socket operations, like
895 'connect', 'recvfrom', 'accept', etc., are redirected to the
896 corresponding 'sys_*' functions, which must convert a file
897 descriptor to a handle using the fd_info[] array, and then invoke
898 the corresponding Windows API on the handle. Most of these
899 redirected 'sys_*' functions are implemented on w32.c.
901 When the file descriptor was produced by functions such as 'open',
902 the corresponding handle is obtained by calling _get_osfhandle. To
903 produce a file descriptor for a socket handle, which has no file
904 descriptor as far as Windows is concerned, the function
905 socket_to_fd opens the null device; the resulting file descriptor
906 will never be used directly in any I/O API, but serves as an index
907 into the fd_info[] array, where the socket handle is stored. The
908 SOCK_HANDLE macro retrieves the handle when given the file
911 The function sys_kill emulates the Posix 'kill' functionality to
912 terminate other processes. It does that by attaching to the
913 foreground window of the process and sending a Ctrl-C or Ctrl-BREAK
914 signal to the process; if that doesn't work, then it calls
915 TerminateProcess to forcibly terminate the process. Note that this
916 only terminates the immediate process whose PID was passed to
917 sys_kill; it doesn't terminate the child processes of that process.
918 This means, for example, that an Emacs subprocess run through a
919 shell might not be killed, because sys_kill will only terminate the
920 shell. (In practice, however, such problems are very rare.) */
922 /* Defined in <process.h> which conflicts with the local copy */
925 /* Child process management list. */
926 int child_proc_count
= 0;
927 child_process child_procs
[ MAX_CHILDREN
];
929 static DWORD WINAPI
reader_thread (void *arg
);
931 /* Find an unused process slot. */
938 for (cp
= child_procs
+ (child_proc_count
-1); cp
>= child_procs
; cp
--)
939 if (!CHILD_ACTIVE (cp
) && cp
->procinfo
.hProcess
== NULL
)
941 if (child_proc_count
== MAX_CHILDREN
)
944 child_process
*dead_cp
= NULL
;
946 DebPrint (("new_child: No vacant slots, looking for dead processes\n"));
947 for (cp
= child_procs
+ (child_proc_count
-1); cp
>= child_procs
; cp
--)
948 if (!CHILD_ACTIVE (cp
) && cp
->procinfo
.hProcess
)
952 if (!GetExitCodeProcess (cp
->procinfo
.hProcess
, &status
))
954 DebPrint (("new_child.GetExitCodeProcess: error %lu for PID %lu\n",
955 GetLastError (), cp
->procinfo
.dwProcessId
));
956 status
= STILL_ACTIVE
;
958 if (status
!= STILL_ACTIVE
959 || WaitForSingleObject (cp
->procinfo
.hProcess
, 0) == WAIT_OBJECT_0
)
961 DebPrint (("new_child: Freeing slot of dead process %d, fd %d\n",
962 cp
->procinfo
.dwProcessId
, cp
->fd
));
963 CloseHandle (cp
->procinfo
.hProcess
);
964 cp
->procinfo
.hProcess
= NULL
;
965 CloseHandle (cp
->procinfo
.hThread
);
966 cp
->procinfo
.hThread
= NULL
;
967 /* Free up to 2 dead slots at a time, so that if we
968 have a lot of them, they will eventually all be
969 freed when the tornado ends. */
983 if (child_proc_count
== MAX_CHILDREN
)
985 cp
= &child_procs
[child_proc_count
++];
988 /* Last opportunity to avoid leaking handles before we forget them
990 if (cp
->procinfo
.hProcess
)
991 CloseHandle (cp
->procinfo
.hProcess
);
992 if (cp
->procinfo
.hThread
)
993 CloseHandle (cp
->procinfo
.hThread
);
994 memset (cp
, 0, sizeof (*cp
));
997 cp
->procinfo
.hProcess
= NULL
;
998 cp
->status
= STATUS_READ_ERROR
;
1000 /* use manual reset event so that select() will function properly */
1001 cp
->char_avail
= CreateEvent (NULL
, TRUE
, FALSE
, NULL
);
1004 cp
->char_consumed
= CreateEvent (NULL
, FALSE
, FALSE
, NULL
);
1005 if (cp
->char_consumed
)
1007 /* The 0x00010000 flag is STACK_SIZE_PARAM_IS_A_RESERVATION.
1008 It means that the 64K stack we are requesting in the 2nd
1009 argument is how much memory should be reserved for the
1010 stack. If we don't use this flag, the memory requested
1011 by the 2nd argument is the amount actually _committed_,
1012 but Windows reserves 8MB of memory for each thread's
1013 stack. (The 8MB figure comes from the -stack
1014 command-line argument we pass to the linker when building
1015 Emacs, but that's because we need a large stack for
1016 Emacs's main thread.) Since we request 2GB of reserved
1017 memory at startup (see w32heap.c), which is close to the
1018 maximum memory available for a 32-bit process on Windows,
1019 the 8MB reservation for each thread causes failures in
1020 starting subprocesses, because we create a thread running
1021 reader_thread for each subprocess. As 8MB of stack is
1022 way too much for reader_thread, forcing Windows to
1023 reserve less wins the day. */
1024 cp
->thrd
= CreateThread (NULL
, 64 * 1024, reader_thread
, cp
,
1035 delete_child (child_process
*cp
)
1039 /* Should not be deleting a child that is still needed. */
1040 for (i
= 0; i
< MAXDESC
; i
++)
1041 if (fd_info
[i
].cp
== cp
)
1044 if (!CHILD_ACTIVE (cp
) && cp
->procinfo
.hProcess
== NULL
)
1047 /* reap thread if necessary */
1052 if (GetExitCodeThread (cp
->thrd
, &rc
) && rc
== STILL_ACTIVE
)
1054 /* let the thread exit cleanly if possible */
1055 cp
->status
= STATUS_READ_ERROR
;
1056 SetEvent (cp
->char_consumed
);
1058 /* We used to forcibly terminate the thread here, but it
1059 is normally unnecessary, and in abnormal cases, the worst that
1060 will happen is we have an extra idle thread hanging around
1061 waiting for the zombie process. */
1062 if (WaitForSingleObject (cp
->thrd
, 1000) != WAIT_OBJECT_0
)
1064 DebPrint (("delete_child.WaitForSingleObject (thread) failed "
1065 "with %lu for fd %ld\n", GetLastError (), cp
->fd
));
1066 TerminateThread (cp
->thrd
, 0);
1070 CloseHandle (cp
->thrd
);
1075 CloseHandle (cp
->char_avail
);
1076 cp
->char_avail
= NULL
;
1078 if (cp
->char_consumed
)
1080 CloseHandle (cp
->char_consumed
);
1081 cp
->char_consumed
= NULL
;
1084 /* update child_proc_count (highest numbered slot in use plus one) */
1085 if (cp
== child_procs
+ child_proc_count
- 1)
1087 for (i
= child_proc_count
-1; i
>= 0; i
--)
1088 if (CHILD_ACTIVE (&child_procs
[i
])
1089 || child_procs
[i
].procinfo
.hProcess
!= NULL
)
1091 child_proc_count
= i
+ 1;
1096 child_proc_count
= 0;
1099 /* Find a child by pid. */
1100 static child_process
*
1101 find_child_pid (DWORD pid
)
1105 for (cp
= child_procs
+ (child_proc_count
-1); cp
>= child_procs
; cp
--)
1106 if ((CHILD_ACTIVE (cp
) || cp
->procinfo
.hProcess
!= NULL
)
1113 release_listen_threads (void)
1117 for (i
= child_proc_count
- 1; i
>= 0; i
--)
1119 if (CHILD_ACTIVE (&child_procs
[i
])
1120 && (fd_info
[child_procs
[i
].fd
].flags
& FILE_LISTEN
))
1121 child_procs
[i
].status
= STATUS_READ_ERROR
;
1125 /* Thread proc for child process and socket reader threads. Each thread
1126 is normally blocked until woken by select() to check for input by
1127 reading one char. When the read completes, char_avail is signaled
1128 to wake up the select emulator and the thread blocks itself again. */
1130 reader_thread (void *arg
)
1135 cp
= (child_process
*)arg
;
1137 /* We have to wait for the go-ahead before we can start */
1139 || WaitForSingleObject (cp
->char_consumed
, INFINITE
) != WAIT_OBJECT_0
1147 if (cp
->fd
>= 0 && fd_info
[cp
->fd
].flags
& FILE_LISTEN
)
1148 rc
= _sys_wait_accept (cp
->fd
);
1150 rc
= _sys_read_ahead (cp
->fd
);
1152 /* Don't bother waiting for the event if we already have been
1153 told to exit by delete_child. */
1154 if (cp
->status
== STATUS_READ_ERROR
|| !cp
->char_avail
)
1157 /* The name char_avail is a misnomer - it really just means the
1158 read-ahead has completed, whether successfully or not. */
1159 if (!SetEvent (cp
->char_avail
))
1161 DebPrint (("reader_thread.SetEvent(0x%x) failed with %lu for fd %ld (PID %d)\n",
1162 (DWORD_PTR
)cp
->char_avail
, GetLastError (),
1167 if (rc
== STATUS_READ_ERROR
)
1170 /* If the read died, the child has died so let the thread die */
1171 if (rc
== STATUS_READ_FAILED
)
1174 /* Don't bother waiting for the acknowledge if we already have
1175 been told to exit by delete_child. */
1176 if (cp
->status
== STATUS_READ_ERROR
|| !cp
->char_consumed
)
1179 /* Wait until our input is acknowledged before reading again */
1180 if (WaitForSingleObject (cp
->char_consumed
, INFINITE
) != WAIT_OBJECT_0
)
1182 DebPrint (("reader_thread.WaitForSingleObject failed with "
1183 "%lu for fd %ld\n", GetLastError (), cp
->fd
));
1186 /* delete_child sets status to STATUS_READ_ERROR when it wants
1188 if (cp
->status
== STATUS_READ_ERROR
)
1194 /* To avoid Emacs changing directory, we just record here the
1195 directory the new process should start in. This is set just before
1196 calling sys_spawnve, and is not generally valid at any other time.
1197 Note that this directory's name is UTF-8 encoded. */
1198 static char * process_dir
;
1201 create_child (char *exe
, char *cmdline
, char *env
, int is_gui_app
,
1202 pid_t
* pPid
, child_process
*cp
)
1205 SECURITY_ATTRIBUTES sec_attrs
;
1207 SECURITY_DESCRIPTOR sec_desc
;
1210 char dir
[ MAX_PATH
];
1213 if (cp
== NULL
) emacs_abort ();
1215 memset (&start
, 0, sizeof (start
));
1216 start
.cb
= sizeof (start
);
1219 if (NILP (Vw32_start_process_show_window
) && !is_gui_app
)
1220 start
.dwFlags
= STARTF_USESTDHANDLES
| STARTF_USESHOWWINDOW
;
1222 start
.dwFlags
= STARTF_USESTDHANDLES
;
1223 start
.wShowWindow
= SW_HIDE
;
1225 start
.hStdInput
= GetStdHandle (STD_INPUT_HANDLE
);
1226 start
.hStdOutput
= GetStdHandle (STD_OUTPUT_HANDLE
);
1227 start
.hStdError
= GetStdHandle (STD_ERROR_HANDLE
);
1228 #endif /* HAVE_NTGUI */
1231 /* Explicitly specify no security */
1232 if (!InitializeSecurityDescriptor (&sec_desc
, SECURITY_DESCRIPTOR_REVISION
))
1234 if (!SetSecurityDescriptorDacl (&sec_desc
, TRUE
, NULL
, FALSE
))
1237 sec_attrs
.nLength
= sizeof (sec_attrs
);
1238 sec_attrs
.lpSecurityDescriptor
= NULL
/* &sec_desc */;
1239 sec_attrs
.bInheritHandle
= FALSE
;
1241 filename_to_ansi (process_dir
, dir
);
1242 /* Can't use unixtodos_filename here, since that needs its file name
1243 argument encoded in UTF-8. OTOH, process_dir, which _is_ in
1244 UTF-8, points, to the directory computed by our caller, and we
1245 don't want to modify that, either. */
1246 for (p
= dir
; *p
; p
= CharNextA (p
))
1250 flags
= (!NILP (Vw32_start_process_share_console
)
1251 ? CREATE_NEW_PROCESS_GROUP
1252 : CREATE_NEW_CONSOLE
);
1253 if (NILP (Vw32_start_process_inherit_error_mode
))
1254 flags
|= CREATE_DEFAULT_ERROR_MODE
;
1255 if (!CreateProcessA (exe
, cmdline
, &sec_attrs
, NULL
, TRUE
,
1256 flags
, env
, dir
, &start
, &cp
->procinfo
))
1259 cp
->pid
= (int) cp
->procinfo
.dwProcessId
;
1261 /* Hack for Windows 95, which assigns large (ie negative) pids */
1270 DebPrint (("create_child.CreateProcess failed: %ld\n", GetLastError ()););
1274 /* create_child doesn't know what emacs's file handle will be for waiting
1275 on output from the child, so we need to make this additional call
1276 to register the handle with the process
1277 This way the select emulator knows how to match file handles with
1278 entries in child_procs. */
1280 register_child (pid_t pid
, int fd
)
1284 cp
= find_child_pid ((DWORD
)pid
);
1287 DebPrint (("register_child unable to find pid %lu\n", pid
));
1292 DebPrint (("register_child registered fd %d with pid %lu\n", fd
, pid
));
1297 /* thread is initially blocked until select is called; set status so
1298 that select will release thread */
1299 cp
->status
= STATUS_READ_ACKNOWLEDGED
;
1301 /* attach child_process to fd_info */
1302 if (fd_info
[fd
].cp
!= NULL
)
1304 DebPrint (("register_child: fd_info[%d] apparently in use!\n", fd
));
1308 fd_info
[fd
].cp
= cp
;
1311 /* Called from waitpid when a process exits. */
1313 reap_subprocess (child_process
*cp
)
1315 if (cp
->procinfo
.hProcess
)
1317 /* Reap the process */
1319 /* Process should have already died before we are called. */
1320 if (WaitForSingleObject (cp
->procinfo
.hProcess
, 0) != WAIT_OBJECT_0
)
1321 DebPrint (("reap_subprocess: child for fd %d has not died yet!", cp
->fd
));
1323 CloseHandle (cp
->procinfo
.hProcess
);
1324 cp
->procinfo
.hProcess
= NULL
;
1325 CloseHandle (cp
->procinfo
.hThread
);
1326 cp
->procinfo
.hThread
= NULL
;
1329 /* If cp->fd was not closed yet, we might be still reading the
1330 process output, so don't free its resources just yet. The call
1331 to delete_child on behalf of this subprocess will be made by
1332 sys_read when the subprocess output is fully read. */
1337 /* Wait for a child process specified by PID, or for any of our
1338 existing child processes (if PID is nonpositive) to die. When it
1339 does, close its handle. Return the pid of the process that died
1340 and fill in STATUS if non-NULL. */
1343 waitpid (pid_t pid
, int *status
, int options
)
1345 DWORD active
, retval
;
1347 child_process
*cp
, *cps
[MAX_CHILDREN
];
1348 HANDLE wait_hnd
[MAX_CHILDREN
];
1350 int dont_wait
= (options
& WNOHANG
) != 0;
1353 /* According to Posix:
1355 PID = -1 means status is requested for any child process.
1357 PID > 0 means status is requested for a single child process
1360 PID = 0 means status is requested for any child process whose
1361 process group ID is equal to that of the calling process. But
1362 since Windows has only a limited support for process groups (only
1363 for console processes and only for the purposes of passing
1364 Ctrl-BREAK signal to them), and since we have no documented way
1365 of determining whether a given process belongs to our group, we
1368 PID < -1 means status is requested for any child process whose
1369 process group ID is equal to the absolute value of PID. Again,
1370 since we don't support process groups, we treat that as -1. */
1375 /* We are requested to wait for a specific child. */
1376 for (cp
= child_procs
+ (child_proc_count
-1); cp
>= child_procs
; cp
--)
1378 /* Some child_procs might be sockets; ignore them. Also
1379 ignore subprocesses whose output is not yet completely
1381 if (CHILD_ACTIVE (cp
)
1382 && cp
->procinfo
.hProcess
1391 if (cp
->fd
< 0 || (fd_info
[cp
->fd
].flags
& FILE_AT_EOF
) != 0)
1393 wait_hnd
[nh
] = cp
->procinfo
.hProcess
;
1399 /* PID specifies our subprocess, but its status is not
1406 /* No such child process, or nothing to wait for, so fail. */
1413 for (cp
= child_procs
+ (child_proc_count
-1); cp
>= child_procs
; cp
--)
1415 if (CHILD_ACTIVE (cp
)
1416 && cp
->procinfo
.hProcess
1417 && (cp
->fd
< 0 || (fd_info
[cp
->fd
].flags
& FILE_AT_EOF
) != 0))
1419 wait_hnd
[nh
] = cp
->procinfo
.hProcess
;
1426 /* Nothing to wait on, so fail. */
1435 timeout_ms
= 1000; /* check for quit about once a second. */
1440 active
= WaitForMultipleObjects (nh
, wait_hnd
, FALSE
, timeout_ms
);
1441 } while (active
== WAIT_TIMEOUT
&& !dont_wait
);
1443 if (active
== WAIT_FAILED
)
1448 else if (active
== WAIT_TIMEOUT
&& dont_wait
)
1450 /* PID specifies our subprocess, but it didn't exit yet, so its
1451 status is not yet available. */
1453 DebPrint (("Wait: PID %d not reap yet\n", cp
->pid
));
1457 else if (active
>= WAIT_OBJECT_0
1458 && active
< WAIT_OBJECT_0
+MAXIMUM_WAIT_OBJECTS
)
1460 active
-= WAIT_OBJECT_0
;
1462 else if (active
>= WAIT_ABANDONED_0
1463 && active
< WAIT_ABANDONED_0
+MAXIMUM_WAIT_OBJECTS
)
1465 active
-= WAIT_ABANDONED_0
;
1470 if (!GetExitCodeProcess (wait_hnd
[active
], &retval
))
1472 DebPrint (("Wait.GetExitCodeProcess failed with %lu\n",
1476 if (retval
== STILL_ACTIVE
)
1478 /* Should never happen. */
1479 DebPrint (("Wait.WaitForMultipleObjects returned an active process\n"));
1480 if (pid
> 0 && dont_wait
)
1486 /* Massage the exit code from the process to match the format expected
1487 by the WIFSTOPPED et al macros in syswait.h. Only WIFSIGNALED and
1488 WIFEXITED are supported; WIFSTOPPED doesn't make sense under NT. */
1490 if (retval
== STATUS_CONTROL_C_EXIT
)
1495 if (pid
> 0 && active
!= 0)
1500 DebPrint (("Wait signaled with process pid %d\n", cp
->pid
));
1505 reap_subprocess (cp
);
1510 /* Old versions of w32api headers don't have separate 32-bit and
1511 64-bit defines, but the one they have matches the 32-bit variety. */
1512 #ifndef IMAGE_NT_OPTIONAL_HDR32_MAGIC
1513 # define IMAGE_NT_OPTIONAL_HDR32_MAGIC IMAGE_NT_OPTIONAL_HDR_MAGIC
1514 # define IMAGE_OPTIONAL_HEADER32 IMAGE_OPTIONAL_HEADER
1517 /* Implementation note: This function works with file names encoded in
1518 the current ANSI codepage. */
1520 w32_executable_type (char * filename
,
1522 int * is_cygnus_app
,
1525 file_data executable
;
1528 /* Default values in case we can't tell for sure. */
1529 *is_dos_app
= FALSE
;
1530 *is_cygnus_app
= FALSE
;
1531 *is_gui_app
= FALSE
;
1533 if (!open_input_file (&executable
, filename
))
1536 p
= strrchr (filename
, '.');
1538 /* We can only identify DOS .com programs from the extension. */
1539 if (p
&& xstrcasecmp (p
, ".com") == 0)
1541 else if (p
&& (xstrcasecmp (p
, ".bat") == 0
1542 || xstrcasecmp (p
, ".cmd") == 0))
1544 /* A DOS shell script - it appears that CreateProcess is happy to
1545 accept this (somewhat surprisingly); presumably it looks at
1546 COMSPEC to determine what executable to actually invoke.
1547 Therefore, we have to do the same here as well. */
1548 /* Actually, I think it uses the program association for that
1549 extension, which is defined in the registry. */
1550 p
= egetenv ("COMSPEC");
1552 w32_executable_type (p
, is_dos_app
, is_cygnus_app
, is_gui_app
);
1556 /* Look for DOS .exe signature - if found, we must also check that
1557 it isn't really a 16- or 32-bit Windows exe, since both formats
1558 start with a DOS program stub. Note that 16-bit Windows
1559 executables use the OS/2 1.x format. */
1561 IMAGE_DOS_HEADER
* dos_header
;
1562 IMAGE_NT_HEADERS
* nt_header
;
1564 dos_header
= (PIMAGE_DOS_HEADER
) executable
.file_base
;
1565 if (dos_header
->e_magic
!= IMAGE_DOS_SIGNATURE
)
1568 nt_header
= (PIMAGE_NT_HEADERS
) ((unsigned char *) dos_header
+ dos_header
->e_lfanew
);
1570 if ((char *) nt_header
> (char *) dos_header
+ executable
.size
)
1572 /* Some dos headers (pkunzip) have bogus e_lfanew fields. */
1575 else if (nt_header
->Signature
!= IMAGE_NT_SIGNATURE
1576 && LOWORD (nt_header
->Signature
) != IMAGE_OS2_SIGNATURE
)
1580 else if (nt_header
->Signature
== IMAGE_NT_SIGNATURE
)
1582 IMAGE_DATA_DIRECTORY
*data_dir
= NULL
;
1583 if (nt_header
->OptionalHeader
.Magic
== IMAGE_NT_OPTIONAL_HDR32_MAGIC
)
1585 /* Ensure we are using the 32 bit structure. */
1586 IMAGE_OPTIONAL_HEADER32
*opt
1587 = (IMAGE_OPTIONAL_HEADER32
*) &(nt_header
->OptionalHeader
);
1588 data_dir
= opt
->DataDirectory
;
1589 *is_gui_app
= (opt
->Subsystem
== IMAGE_SUBSYSTEM_WINDOWS_GUI
);
1591 /* MingW 3.12 has the required 64 bit structs, but in case older
1592 versions don't, only check 64 bit exes if we know how. */
1593 #ifdef IMAGE_NT_OPTIONAL_HDR64_MAGIC
1594 else if (nt_header
->OptionalHeader
.Magic
1595 == IMAGE_NT_OPTIONAL_HDR64_MAGIC
)
1597 IMAGE_OPTIONAL_HEADER64
*opt
1598 = (IMAGE_OPTIONAL_HEADER64
*) &(nt_header
->OptionalHeader
);
1599 data_dir
= opt
->DataDirectory
;
1600 *is_gui_app
= (opt
->Subsystem
== IMAGE_SUBSYSTEM_WINDOWS_GUI
);
1605 /* Look for cygwin.dll in DLL import list. */
1606 IMAGE_DATA_DIRECTORY import_dir
=
1607 data_dir
[IMAGE_DIRECTORY_ENTRY_IMPORT
];
1608 IMAGE_IMPORT_DESCRIPTOR
* imports
;
1609 IMAGE_SECTION_HEADER
* section
;
1611 section
= rva_to_section (import_dir
.VirtualAddress
, nt_header
);
1612 imports
= RVA_TO_PTR (import_dir
.VirtualAddress
, section
,
1615 for ( ; imports
->Name
; imports
++)
1617 char * dllname
= RVA_TO_PTR (imports
->Name
, section
,
1620 /* The exact name of the cygwin dll has changed with
1621 various releases, but hopefully this will be reasonably
1623 if (strncmp (dllname
, "cygwin", 6) == 0)
1625 *is_cygnus_app
= TRUE
;
1634 close_file_data (&executable
);
1638 compare_env (const void *strp1
, const void *strp2
)
1640 const char *str1
= *(const char **)strp1
, *str2
= *(const char **)strp2
;
1642 while (*str1
&& *str2
&& *str1
!= '=' && *str2
!= '=')
1644 /* Sort order in command.com/cmd.exe is based on uppercasing
1645 names, so do the same here. */
1646 if (toupper (*str1
) > toupper (*str2
))
1648 else if (toupper (*str1
) < toupper (*str2
))
1653 if (*str1
== '=' && *str2
== '=')
1655 else if (*str1
== '=')
1662 merge_and_sort_env (char **envp1
, char **envp2
, char **new_envp
)
1664 char **optr
, **nptr
;
1676 num
+= optr
- envp2
;
1678 qsort (new_envp
, num
, sizeof (char *), compare_env
);
1683 /* When a new child process is created we need to register it in our list,
1684 so intercept spawn requests. */
1686 sys_spawnve (int mode
, char *cmdname
, char **argv
, char **envp
)
1688 Lisp_Object program
, full
;
1689 char *cmdline
, *env
, *parg
, **targ
;
1693 int is_dos_app
, is_cygnus_app
, is_gui_app
;
1695 /* We pass our process ID to our children by setting up an environment
1696 variable in their environment. */
1697 char ppid_env_var_buffer
[64];
1698 char *extra_env
[] = {ppid_env_var_buffer
, NULL
};
1699 /* These are the characters that cause an argument to need quoting.
1700 Arguments with whitespace characters need quoting to prevent the
1701 argument being split into two or more. Arguments with wildcards
1702 are also quoted, for consistency with posix platforms, where wildcards
1703 are not expanded if we run the program directly without a shell.
1704 Some extra whitespace characters need quoting in Cygwin programs,
1705 so this list is conditionally modified below. */
1706 char *sepchars
= " \t*?";
1707 /* This is for native w32 apps; modified below for Cygwin apps. */
1708 char escape_char
= '\\';
1709 char cmdname_a
[MAX_PATH
];
1711 /* We don't care about the other modes */
1712 if (mode
!= _P_NOWAIT
)
1718 /* Handle executable names without an executable suffix. The caller
1719 already searched exec-path and verified the file is executable,
1720 but start-process doesn't do that for file names that are already
1721 absolute. So we double-check this here, just in case. */
1722 if (faccessat (AT_FDCWD
, cmdname
, X_OK
, AT_EACCESS
) != 0)
1724 struct gcpro gcpro1
;
1726 program
= build_string (cmdname
);
1729 openp (Vexec_path
, program
, Vexec_suffixes
, &full
, make_number (X_OK
), 0);
1736 program
= ENCODE_FILE (full
);
1737 cmdname
= SDATA (program
);
1740 /* make sure argv[0] and cmdname are both in DOS format */
1741 unixtodos_filename (cmdname
);
1742 /* argv[0] was encoded by caller using ENCODE_FILE, so it is in
1743 UTF-8. All the other arguments are encoded by ENCODE_SYSTEM or
1744 some such, and are in some ANSI codepage. We need to have
1745 argv[0] encoded in ANSI codepage. */
1746 filename_to_ansi (cmdname
, cmdname_a
);
1747 /* We explicitly require that the command's file name be encodable
1748 in the current ANSI codepage, because we will be invoking it via
1750 if (_mbspbrk (cmdname_a
, "?"))
1755 /* From here on, CMDNAME is an ANSI-encoded string. */
1756 cmdname
= cmdname_a
;
1759 /* Determine whether program is a 16-bit DOS executable, or a 32-bit Windows
1760 executable that is implicitly linked to the Cygnus dll (implying it
1761 was compiled with the Cygnus GNU toolchain and hence relies on
1762 cygwin.dll to parse the command line - we use this to decide how to
1763 escape quote chars in command line args that must be quoted).
1765 Also determine whether it is a GUI app, so that we don't hide its
1766 initial window unless specifically requested. */
1767 w32_executable_type (cmdname
, &is_dos_app
, &is_cygnus_app
, &is_gui_app
);
1769 /* On Windows 95, if cmdname is a DOS app, we invoke a helper
1770 application to start it by specifying the helper app as cmdname,
1771 while leaving the real app name as argv[0]. */
1776 cmdname
= alloca (MAX_PATH
);
1777 if (egetenv ("CMDPROXY"))
1778 strcpy (cmdname
, egetenv ("CMDPROXY"));
1781 strcpy (cmdname
, SDATA (Vinvocation_directory
));
1782 strcat (cmdname
, "cmdproxy.exe");
1785 /* Can't use unixtodos_filename here, since that needs its file
1786 name argument encoded in UTF-8. */
1787 for (p
= cmdname
; *p
; p
= CharNextA (p
))
1792 /* we have to do some conjuring here to put argv and envp into the
1793 form CreateProcess wants... argv needs to be a space separated/null
1794 terminated list of parameters, and envp is a null
1795 separated/double-null terminated list of parameters.
1797 Additionally, zero-length args and args containing whitespace or
1798 quote chars need to be wrapped in double quotes - for this to work,
1799 embedded quotes need to be escaped as well. The aim is to ensure
1800 the child process reconstructs the argv array we start with
1801 exactly, so we treat quotes at the beginning and end of arguments
1804 The w32 GNU-based library from Cygnus doubles quotes to escape
1805 them, while MSVC uses backslash for escaping. (Actually the MSVC
1806 startup code does attempt to recognize doubled quotes and accept
1807 them, but gets it wrong and ends up requiring three quotes to get a
1808 single embedded quote!) So by default we decide whether to use
1809 quote or backslash as the escape character based on whether the
1810 binary is apparently a Cygnus compiled app.
1812 Note that using backslash to escape embedded quotes requires
1813 additional special handling if an embedded quote is already
1814 preceded by backslash, or if an arg requiring quoting ends with
1815 backslash. In such cases, the run of escape characters needs to be
1816 doubled. For consistency, we apply this special handling as long
1817 as the escape character is not quote.
1819 Since we have no idea how large argv and envp are likely to be we
1820 figure out list lengths on the fly and allocate them. */
1822 if (!NILP (Vw32_quote_process_args
))
1825 /* Override escape char by binding w32-quote-process-args to
1826 desired character, or use t for auto-selection. */
1827 if (INTEGERP (Vw32_quote_process_args
))
1828 escape_char
= XINT (Vw32_quote_process_args
);
1830 escape_char
= is_cygnus_app
? '"' : '\\';
1833 /* Cygwin apps needs quoting a bit more often. */
1834 if (escape_char
== '"')
1835 sepchars
= "\r\n\t\f '";
1843 int need_quotes
= 0;
1844 int escape_char_run
= 0;
1850 if (escape_char
== '"' && *p
== '\\')
1851 /* If it's a Cygwin app, \ needs to be escaped. */
1855 /* allow for embedded quotes to be escaped */
1858 /* handle the case where the embedded quote is already escaped */
1859 if (escape_char_run
> 0)
1861 /* To preserve the arg exactly, we need to double the
1862 preceding escape characters (plus adding one to
1863 escape the quote character itself). */
1864 arglen
+= escape_char_run
;
1867 else if (strchr (sepchars
, *p
) != NULL
)
1872 if (*p
== escape_char
&& escape_char
!= '"')
1875 escape_char_run
= 0;
1880 /* handle the case where the arg ends with an escape char - we
1881 must not let the enclosing quote be escaped. */
1882 if (escape_char_run
> 0)
1883 arglen
+= escape_char_run
;
1885 arglen
+= strlen (*targ
++) + 1;
1887 cmdline
= alloca (arglen
);
1893 int need_quotes
= 0;
1901 if ((strchr (sepchars
, *p
) != NULL
) || *p
== '"')
1906 int escape_char_run
= 0;
1912 last
= p
+ strlen (p
) - 1;
1915 /* This version does not escape quotes if they occur at the
1916 beginning or end of the arg - this could lead to incorrect
1917 behavior when the arg itself represents a command line
1918 containing quoted args. I believe this was originally done
1919 as a hack to make some things work, before
1920 `w32-quote-process-args' was added. */
1923 if (*p
== '"' && p
> first
&& p
< last
)
1924 *parg
++ = escape_char
; /* escape embedded quotes */
1932 /* double preceding escape chars if any */
1933 while (escape_char_run
> 0)
1935 *parg
++ = escape_char
;
1938 /* escape all quote chars, even at beginning or end */
1939 *parg
++ = escape_char
;
1941 else if (escape_char
== '"' && *p
== '\\')
1945 if (*p
== escape_char
&& escape_char
!= '"')
1948 escape_char_run
= 0;
1950 /* double escape chars before enclosing quote */
1951 while (escape_char_run
> 0)
1953 *parg
++ = escape_char
;
1961 strcpy (parg
, *targ
);
1962 parg
+= strlen (*targ
);
1972 numenv
= 1; /* for end null */
1975 arglen
+= strlen (*targ
++) + 1;
1978 /* extra env vars... */
1979 sprintf (ppid_env_var_buffer
, "EM_PARENT_PROCESS_ID=%lu",
1980 GetCurrentProcessId ());
1981 arglen
+= strlen (ppid_env_var_buffer
) + 1;
1984 /* merge env passed in and extra env into one, and sort it. */
1985 targ
= (char **) alloca (numenv
* sizeof (char *));
1986 merge_and_sort_env (envp
, extra_env
, targ
);
1988 /* concatenate env entries. */
1989 env
= alloca (arglen
);
1993 strcpy (parg
, *targ
);
1994 parg
+= strlen (*targ
++);
2007 /* Now create the process. */
2008 if (!create_child (cmdname
, cmdline
, env
, is_gui_app
, &pid
, cp
))
2018 /* Emulate the select call
2019 Wait for available input on any of the given rfds, or timeout if
2020 a timeout is given and no input is detected
2021 wfds and efds are not supported and must be NULL.
2023 For simplicity, we detect the death of child processes here and
2024 synchronously call the SIGCHLD handler. Since it is possible for
2025 children to be created without a corresponding pipe handle from which
2026 to read output, we wait separately on the process handles as well as
2027 the char_avail events for each process pipe. We only call
2028 wait/reap_process when the process actually terminates.
2030 To reduce the number of places in which Emacs can be hung such that
2031 C-g is not able to interrupt it, we always wait on interrupt_handle
2032 (which is signaled by the input thread when C-g is detected). If we
2033 detect that we were woken up by C-g, we return -1 with errno set to
2034 EINTR as on Unix. */
2036 /* From w32console.c */
2037 extern HANDLE keyboard_handle
;
2039 /* From w32xfns.c */
2040 extern HANDLE interrupt_handle
;
2042 /* From process.c */
2043 extern int proc_buffered_char
[];
2046 sys_select (int nfds
, SELECT_TYPE
*rfds
, SELECT_TYPE
*wfds
, SELECT_TYPE
*efds
,
2047 struct timespec
*timeout
, void *ignored
)
2050 DWORD timeout_ms
, start_time
;
2053 child_process
*cp
, *cps
[MAX_CHILDREN
];
2054 HANDLE wait_hnd
[MAXDESC
+ MAX_CHILDREN
];
2055 int fdindex
[MAXDESC
]; /* mapping from wait handles back to descriptors */
2058 timeout
? (timeout
->tv_sec
* 1000 + timeout
->tv_nsec
/ 1000000) : INFINITE
;
2060 /* If the descriptor sets are NULL but timeout isn't, then just Sleep. */
2061 if (rfds
== NULL
&& wfds
== NULL
&& efds
== NULL
&& timeout
!= NULL
)
2067 /* Otherwise, we only handle rfds, so fail otherwise. */
2068 if (rfds
== NULL
|| wfds
!= NULL
|| efds
!= NULL
)
2078 /* If interrupt_handle is available and valid, always wait on it, to
2079 detect C-g (quit). */
2081 if (interrupt_handle
&& interrupt_handle
!= INVALID_HANDLE_VALUE
)
2083 wait_hnd
[0] = interrupt_handle
;
2088 /* Build a list of pipe handles to wait on. */
2089 for (i
= 0; i
< nfds
; i
++)
2090 if (FD_ISSET (i
, &orfds
))
2094 if (keyboard_handle
)
2096 /* Handle stdin specially */
2097 wait_hnd
[nh
] = keyboard_handle
;
2102 /* Check for any emacs-generated input in the queue since
2103 it won't be detected in the wait */
2104 if (detect_input_pending ())
2109 else if (noninteractive
)
2111 if (handle_file_notifications (NULL
))
2117 /* Child process and socket/comm port input. */
2121 int current_status
= cp
->status
;
2123 if (current_status
== STATUS_READ_ACKNOWLEDGED
)
2125 /* Tell reader thread which file handle to use. */
2127 /* Wake up the reader thread for this process */
2128 cp
->status
= STATUS_READ_READY
;
2129 if (!SetEvent (cp
->char_consumed
))
2130 DebPrint (("sys_select.SetEvent failed with "
2131 "%lu for fd %ld\n", GetLastError (), i
));
2134 #ifdef CHECK_INTERLOCK
2135 /* slightly crude cross-checking of interlock between threads */
2137 current_status
= cp
->status
;
2138 if (WaitForSingleObject (cp
->char_avail
, 0) == WAIT_OBJECT_0
)
2140 /* char_avail has been signaled, so status (which may
2141 have changed) should indicate read has completed
2142 but has not been acknowledged. */
2143 current_status
= cp
->status
;
2144 if (current_status
!= STATUS_READ_SUCCEEDED
2145 && current_status
!= STATUS_READ_FAILED
)
2146 DebPrint (("char_avail set, but read not completed: status %d\n",
2151 /* char_avail has not been signaled, so status should
2152 indicate that read is in progress; small possibility
2153 that read has completed but event wasn't yet signaled
2154 when we tested it (because a context switch occurred
2155 or if running on separate CPUs). */
2156 if (current_status
!= STATUS_READ_READY
2157 && current_status
!= STATUS_READ_IN_PROGRESS
2158 && current_status
!= STATUS_READ_SUCCEEDED
2159 && current_status
!= STATUS_READ_FAILED
)
2160 DebPrint (("char_avail reset, but read status is bad: %d\n",
2164 wait_hnd
[nh
] = cp
->char_avail
;
2166 if (!wait_hnd
[nh
]) emacs_abort ();
2169 DebPrint (("select waiting on child %d fd %d\n",
2170 cp
-child_procs
, i
));
2175 /* Unable to find something to wait on for this fd, skip */
2177 /* Note that this is not a fatal error, and can in fact
2178 happen in unusual circumstances. Specifically, if
2179 sys_spawnve fails, eg. because the program doesn't
2180 exist, and debug-on-error is t so Fsignal invokes a
2181 nested input loop, then the process output pipe is
2182 still included in input_wait_mask with no child_proc
2183 associated with it. (It is removed when the debugger
2184 exits the nested input loop and the error is thrown.) */
2186 DebPrint (("sys_select: fd %ld is invalid! ignoring\n", i
));
2192 /* Add handles of child processes. */
2194 for (cp
= child_procs
+ (child_proc_count
-1); cp
>= child_procs
; cp
--)
2195 /* Some child_procs might be sockets; ignore them. Also some
2196 children may have died already, but we haven't finished reading
2197 the process output; ignore them too. */
2198 if ((CHILD_ACTIVE (cp
) && cp
->procinfo
.hProcess
)
2200 || (fd_info
[cp
->fd
].flags
& FILE_SEND_SIGCHLD
) == 0
2201 || (fd_info
[cp
->fd
].flags
& FILE_AT_EOF
) != 0)
2204 wait_hnd
[nh
+ nc
] = cp
->procinfo
.hProcess
;
2209 /* Nothing to look for, so we didn't find anything */
2216 if (handle_file_notifications (NULL
))
2222 start_time
= GetTickCount ();
2224 /* Wait for input or child death to be signaled. If user input is
2225 allowed, then also accept window messages. */
2226 if (FD_ISSET (0, &orfds
))
2227 active
= MsgWaitForMultipleObjects (nh
+ nc
, wait_hnd
, FALSE
, timeout_ms
,
2230 active
= WaitForMultipleObjects (nh
+ nc
, wait_hnd
, FALSE
, timeout_ms
);
2232 if (active
== WAIT_FAILED
)
2234 DebPrint (("select.WaitForMultipleObjects (%d, %lu) failed with %lu\n",
2235 nh
+ nc
, timeout_ms
, GetLastError ()));
2236 /* don't return EBADF - this causes wait_reading_process_output to
2237 abort; WAIT_FAILED is returned when single-stepping under
2238 Windows 95 after switching thread focus in debugger, and
2239 possibly at other times. */
2243 else if (active
== WAIT_TIMEOUT
)
2247 if (handle_file_notifications (NULL
))
2252 else if (active
>= WAIT_OBJECT_0
2253 && active
< WAIT_OBJECT_0
+MAXIMUM_WAIT_OBJECTS
)
2255 active
-= WAIT_OBJECT_0
;
2257 else if (active
>= WAIT_ABANDONED_0
2258 && active
< WAIT_ABANDONED_0
+MAXIMUM_WAIT_OBJECTS
)
2260 active
-= WAIT_ABANDONED_0
;
2265 /* Loop over all handles after active (now officially documented as
2266 being the first signaled handle in the array). We do this to
2267 ensure fairness, so that all channels with data available will be
2268 processed - otherwise higher numbered channels could be starved. */
2271 if (active
== nh
+ nc
)
2273 /* There are messages in the lisp thread's queue; we must
2274 drain the queue now to ensure they are processed promptly,
2275 because if we don't do so, we will not be woken again until
2276 further messages arrive.
2278 NB. If ever we allow window message procedures to callback
2279 into lisp, we will need to ensure messages are dispatched
2280 at a safe time for lisp code to be run (*), and we may also
2281 want to provide some hooks in the dispatch loop to cater
2282 for modeless dialogs created by lisp (ie. to register
2283 window handles to pass to IsDialogMessage).
2285 (*) Note that MsgWaitForMultipleObjects above is an
2286 internal dispatch point for messages that are sent to
2287 windows created by this thread. */
2288 if (drain_message_queue ()
2289 /* If drain_message_queue returns non-zero, that means
2290 we received a WM_EMACS_FILENOTIFY message. If this
2291 is a TTY frame, we must signal the caller that keyboard
2292 input is available, so that w32_console_read_socket
2293 will be called to pick up the notifications. If we
2294 don't do that, file notifications will only work when
2295 the Emacs TTY frame has focus. */
2296 && FRAME_TERMCAP_P (SELECTED_FRAME ())
2297 /* they asked for stdin reads */
2298 && FD_ISSET (0, &orfds
)
2299 /* the stdin handle is valid */
2307 else if (active
>= nh
)
2309 cp
= cps
[active
- nh
];
2311 /* We cannot always signal SIGCHLD immediately; if we have not
2312 finished reading the process output, we must delay sending
2313 SIGCHLD until we do. */
2315 if (cp
->fd
>= 0 && (fd_info
[cp
->fd
].flags
& FILE_AT_EOF
) == 0)
2316 fd_info
[cp
->fd
].flags
|= FILE_SEND_SIGCHLD
;
2317 /* SIG_DFL for SIGCHLD is ignore */
2318 else if (sig_handlers
[SIGCHLD
] != SIG_DFL
&&
2319 sig_handlers
[SIGCHLD
] != SIG_IGN
)
2322 DebPrint (("select calling SIGCHLD handler for pid %d\n",
2325 sig_handlers
[SIGCHLD
] (SIGCHLD
);
2328 else if (fdindex
[active
] == -1)
2330 /* Quit (C-g) was detected. */
2334 else if (fdindex
[active
] == 0)
2336 /* Keyboard input available */
2342 /* must be a socket or pipe - read ahead should have
2343 completed, either succeeding or failing. */
2344 FD_SET (fdindex
[active
], rfds
);
2348 /* Even though wait_reading_process_output only reads from at most
2349 one channel, we must process all channels here so that we reap
2350 all children that have died. */
2351 while (++active
< nh
+ nc
)
2352 if (WaitForSingleObject (wait_hnd
[active
], 0) == WAIT_OBJECT_0
)
2354 } while (active
< nh
+ nc
);
2358 if (handle_file_notifications (NULL
))
2362 /* If no input has arrived and timeout hasn't expired, wait again. */
2365 DWORD elapsed
= GetTickCount () - start_time
;
2367 if (timeout_ms
> elapsed
) /* INFINITE is MAX_UINT */
2369 if (timeout_ms
!= INFINITE
)
2370 timeout_ms
-= elapsed
;
2371 goto count_children
;
2378 /* Substitute for certain kill () operations */
2380 static BOOL CALLBACK
2381 find_child_console (HWND hwnd
, LPARAM arg
)
2383 child_process
* cp
= (child_process
*) arg
;
2387 thread_id
= GetWindowThreadProcessId (hwnd
, &process_id
);
2388 if (process_id
== cp
->procinfo
.dwProcessId
)
2390 char window_class
[32];
2392 GetClassName (hwnd
, window_class
, sizeof (window_class
));
2393 if (strcmp (window_class
,
2394 (os_subtype
== OS_9X
)
2396 : "ConsoleWindowClass") == 0)
2406 /* Emulate 'kill', but only for other processes. */
2408 sys_kill (pid_t pid
, int sig
)
2412 int need_to_free
= 0;
2415 /* Each process is in its own process group. */
2419 /* Only handle signals that will result in the process dying */
2421 && sig
!= SIGINT
&& sig
!= SIGKILL
&& sig
!= SIGQUIT
&& sig
!= SIGHUP
)
2429 /* It will take _some_ time before PID 4 or less on Windows will
2436 proc_hand
= OpenProcess (PROCESS_QUERY_INFORMATION
, 0, pid
);
2437 if (proc_hand
== NULL
)
2439 DWORD err
= GetLastError ();
2443 case ERROR_ACCESS_DENIED
: /* existing process, but access denied */
2446 case ERROR_INVALID_PARAMETER
: /* process PID does not exist */
2452 CloseHandle (proc_hand
);
2456 cp
= find_child_pid (pid
);
2459 /* We were passed a PID of something other than our subprocess.
2460 If that is our own PID, we will send to ourself a message to
2461 close the selected frame, which does not necessarily
2462 terminates Emacs. But then we are not supposed to call
2463 sys_kill with our own PID. */
2464 proc_hand
= OpenProcess (PROCESS_TERMINATE
, 0, pid
);
2465 if (proc_hand
== NULL
)
2474 proc_hand
= cp
->procinfo
.hProcess
;
2475 pid
= cp
->procinfo
.dwProcessId
;
2477 /* Try to locate console window for process. */
2478 EnumWindows (find_child_console
, (LPARAM
) cp
);
2481 if (sig
== SIGINT
|| sig
== SIGQUIT
)
2483 if (NILP (Vw32_start_process_share_console
) && cp
&& cp
->hwnd
)
2485 BYTE control_scan_code
= (BYTE
) MapVirtualKey (VK_CONTROL
, 0);
2486 /* Fake Ctrl-C for SIGINT, and Ctrl-Break for SIGQUIT. */
2487 BYTE vk_break_code
= (sig
== SIGINT
) ? 'C' : VK_CANCEL
;
2488 BYTE break_scan_code
= (BYTE
) MapVirtualKey (vk_break_code
, 0);
2489 HWND foreground_window
;
2491 if (break_scan_code
== 0)
2493 /* Fake Ctrl-C for SIGQUIT if we can't manage Ctrl-Break. */
2494 vk_break_code
= 'C';
2495 break_scan_code
= (BYTE
) MapVirtualKey (vk_break_code
, 0);
2498 foreground_window
= GetForegroundWindow ();
2499 if (foreground_window
)
2501 /* NT 5.0, and apparently also Windows 98, will not allow
2502 a Window to be set to foreground directly without the
2503 user's involvement. The workaround is to attach
2504 ourselves to the thread that owns the foreground
2505 window, since that is the only thread that can set the
2506 foreground window. */
2507 DWORD foreground_thread
, child_thread
;
2509 GetWindowThreadProcessId (foreground_window
, NULL
);
2510 if (foreground_thread
== GetCurrentThreadId ()
2511 || !AttachThreadInput (GetCurrentThreadId (),
2512 foreground_thread
, TRUE
))
2513 foreground_thread
= 0;
2515 child_thread
= GetWindowThreadProcessId (cp
->hwnd
, NULL
);
2516 if (child_thread
== GetCurrentThreadId ()
2517 || !AttachThreadInput (GetCurrentThreadId (),
2518 child_thread
, TRUE
))
2521 /* Set the foreground window to the child. */
2522 if (SetForegroundWindow (cp
->hwnd
))
2524 /* Generate keystrokes as if user had typed Ctrl-Break or
2526 keybd_event (VK_CONTROL
, control_scan_code
, 0, 0);
2527 keybd_event (vk_break_code
, break_scan_code
,
2528 (vk_break_code
== 'C' ? 0 : KEYEVENTF_EXTENDEDKEY
), 0);
2529 keybd_event (vk_break_code
, break_scan_code
,
2530 (vk_break_code
== 'C' ? 0 : KEYEVENTF_EXTENDEDKEY
)
2531 | KEYEVENTF_KEYUP
, 0);
2532 keybd_event (VK_CONTROL
, control_scan_code
,
2533 KEYEVENTF_KEYUP
, 0);
2535 /* Sleep for a bit to give time for Emacs frame to respond
2536 to focus change events (if Emacs was active app). */
2539 SetForegroundWindow (foreground_window
);
2541 /* Detach from the foreground and child threads now that
2542 the foreground switching is over. */
2543 if (foreground_thread
)
2544 AttachThreadInput (GetCurrentThreadId (),
2545 foreground_thread
, FALSE
);
2547 AttachThreadInput (GetCurrentThreadId (),
2548 child_thread
, FALSE
);
2551 /* Ctrl-Break is NT equivalent of SIGINT. */
2552 else if (!GenerateConsoleCtrlEvent (CTRL_BREAK_EVENT
, pid
))
2554 DebPrint (("sys_kill.GenerateConsoleCtrlEvent return %d "
2555 "for pid %lu\n", GetLastError (), pid
));
2562 if (NILP (Vw32_start_process_share_console
) && cp
&& cp
->hwnd
)
2565 if (os_subtype
== OS_9X
)
2568 Another possibility is to try terminating the VDM out-right by
2569 calling the Shell VxD (id 0x17) V86 interface, function #4
2570 "SHELL_Destroy_VM", ie.
2576 First need to determine the current VM handle, and then arrange for
2577 the shellapi call to be made from the system vm (by using
2578 Switch_VM_and_callback).
2580 Could try to invoke DestroyVM through CallVxD.
2584 /* On Windows 95, posting WM_QUIT causes the 16-bit subsystem
2585 to hang when cmdproxy is used in conjunction with
2586 command.com for an interactive shell. Posting
2587 WM_CLOSE pops up a dialog that, when Yes is selected,
2588 does the same thing. TerminateProcess is also less
2589 than ideal in that subprocesses tend to stick around
2590 until the machine is shutdown, but at least it
2591 doesn't freeze the 16-bit subsystem. */
2592 PostMessage (cp
->hwnd
, WM_QUIT
, 0xff, 0);
2594 if (!TerminateProcess (proc_hand
, 0xff))
2596 DebPrint (("sys_kill.TerminateProcess returned %d "
2597 "for pid %lu\n", GetLastError (), pid
));
2604 PostMessage (cp
->hwnd
, WM_CLOSE
, 0, 0);
2606 /* Kill the process. On W32 this doesn't kill child processes
2607 so it doesn't work very well for shells which is why it's not
2608 used in every case. */
2609 else if (!TerminateProcess (proc_hand
, 0xff))
2611 DebPrint (("sys_kill.TerminateProcess returned %d "
2612 "for pid %lu\n", GetLastError (), pid
));
2619 CloseHandle (proc_hand
);
2624 /* The following two routines are used to manipulate stdin, stdout, and
2625 stderr of our child processes.
2627 Assuming that in, out, and err are *not* inheritable, we make them
2628 stdin, stdout, and stderr of the child as follows:
2630 - Save the parent's current standard handles.
2631 - Set the std handles to inheritable duplicates of the ones being passed in.
2632 (Note that _get_osfhandle() is an io.h procedure that retrieves the
2633 NT file handle for a crt file descriptor.)
2634 - Spawn the child, which inherits in, out, and err as stdin,
2635 stdout, and stderr. (see Spawnve)
2636 - Close the std handles passed to the child.
2637 - Reset the parent's standard handles to the saved handles.
2638 (see reset_standard_handles)
2639 We assume that the caller closes in, out, and err after calling us. */
2642 prepare_standard_handles (int in
, int out
, int err
, HANDLE handles
[3])
2645 HANDLE newstdin
, newstdout
, newstderr
;
2647 parent
= GetCurrentProcess ();
2649 handles
[0] = GetStdHandle (STD_INPUT_HANDLE
);
2650 handles
[1] = GetStdHandle (STD_OUTPUT_HANDLE
);
2651 handles
[2] = GetStdHandle (STD_ERROR_HANDLE
);
2653 /* make inheritable copies of the new handles */
2654 if (!DuplicateHandle (parent
,
2655 (HANDLE
) _get_osfhandle (in
),
2660 DUPLICATE_SAME_ACCESS
))
2661 report_file_error ("Duplicating input handle for child", Qnil
);
2663 if (!DuplicateHandle (parent
,
2664 (HANDLE
) _get_osfhandle (out
),
2669 DUPLICATE_SAME_ACCESS
))
2670 report_file_error ("Duplicating output handle for child", Qnil
);
2672 if (!DuplicateHandle (parent
,
2673 (HANDLE
) _get_osfhandle (err
),
2678 DUPLICATE_SAME_ACCESS
))
2679 report_file_error ("Duplicating error handle for child", Qnil
);
2681 /* and store them as our std handles */
2682 if (!SetStdHandle (STD_INPUT_HANDLE
, newstdin
))
2683 report_file_error ("Changing stdin handle", Qnil
);
2685 if (!SetStdHandle (STD_OUTPUT_HANDLE
, newstdout
))
2686 report_file_error ("Changing stdout handle", Qnil
);
2688 if (!SetStdHandle (STD_ERROR_HANDLE
, newstderr
))
2689 report_file_error ("Changing stderr handle", Qnil
);
2693 reset_standard_handles (int in
, int out
, int err
, HANDLE handles
[3])
2695 /* close the duplicated handles passed to the child */
2696 CloseHandle (GetStdHandle (STD_INPUT_HANDLE
));
2697 CloseHandle (GetStdHandle (STD_OUTPUT_HANDLE
));
2698 CloseHandle (GetStdHandle (STD_ERROR_HANDLE
));
2700 /* now restore parent's saved std handles */
2701 SetStdHandle (STD_INPUT_HANDLE
, handles
[0]);
2702 SetStdHandle (STD_OUTPUT_HANDLE
, handles
[1]);
2703 SetStdHandle (STD_ERROR_HANDLE
, handles
[2]);
2707 set_process_dir (char * dir
)
2712 /* To avoid problems with winsock implementations that work over dial-up
2713 connections causing or requiring a connection to exist while Emacs is
2714 running, Emacs no longer automatically loads winsock on startup if it
2715 is present. Instead, it will be loaded when open-network-stream is
2718 To allow full control over when winsock is loaded, we provide these
2719 two functions to dynamically load and unload winsock. This allows
2720 dial-up users to only be connected when they actually need to use
2724 extern HANDLE winsock_lib
;
2725 extern BOOL
term_winsock (void);
2726 extern BOOL
init_winsock (int load_now
);
2728 DEFUN ("w32-has-winsock", Fw32_has_winsock
, Sw32_has_winsock
, 0, 1, 0,
2729 doc
: /* Test for presence of the Windows socket library `winsock'.
2730 Returns non-nil if winsock support is present, nil otherwise.
2732 If the optional argument LOAD-NOW is non-nil, the winsock library is
2733 also loaded immediately if not already loaded. If winsock is loaded,
2734 the winsock local hostname is returned (since this may be different from
2735 the value of `system-name' and should supplant it), otherwise t is
2736 returned to indicate winsock support is present. */)
2737 (Lisp_Object load_now
)
2741 have_winsock
= init_winsock (!NILP (load_now
));
2744 if (winsock_lib
!= NULL
)
2746 /* Return new value for system-name. The best way to do this
2747 is to call init_system_name, saving and restoring the
2748 original value to avoid side-effects. */
2749 Lisp_Object orig_hostname
= Vsystem_name
;
2750 Lisp_Object hostname
;
2752 init_system_name ();
2753 hostname
= Vsystem_name
;
2754 Vsystem_name
= orig_hostname
;
2762 DEFUN ("w32-unload-winsock", Fw32_unload_winsock
, Sw32_unload_winsock
,
2764 doc
: /* Unload the Windows socket library `winsock' if loaded.
2765 This is provided to allow dial-up socket connections to be disconnected
2766 when no longer needed. Returns nil without unloading winsock if any
2767 socket connections still exist. */)
2770 return term_winsock () ? Qt
: Qnil
;
2774 /* Some miscellaneous functions that are Windows specific, but not GUI
2775 specific (ie. are applicable in terminal or batch mode as well). */
2777 DEFUN ("w32-short-file-name", Fw32_short_file_name
, Sw32_short_file_name
, 1, 1, 0,
2778 doc
: /* Return the short file name version (8.3) of the full path of FILENAME.
2779 If FILENAME does not exist, return nil.
2780 All path elements in FILENAME are converted to their short names. */)
2781 (Lisp_Object filename
)
2783 char shortname
[MAX_PATH
];
2785 CHECK_STRING (filename
);
2787 /* first expand it. */
2788 filename
= Fexpand_file_name (filename
, Qnil
);
2790 /* luckily, this returns the short version of each element in the path. */
2791 if (w32_get_short_filename (SDATA (ENCODE_FILE (filename
)),
2792 shortname
, MAX_PATH
) == 0)
2795 dostounix_filename (shortname
);
2797 /* No need to DECODE_FILE, because 8.3 names are pure ASCII. */
2798 return build_string (shortname
);
2802 DEFUN ("w32-long-file-name", Fw32_long_file_name
, Sw32_long_file_name
,
2804 doc
: /* Return the long file name version of the full path of FILENAME.
2805 If FILENAME does not exist, return nil.
2806 All path elements in FILENAME are converted to their long names. */)
2807 (Lisp_Object filename
)
2809 char longname
[ MAX_UTF8_PATH
];
2812 CHECK_STRING (filename
);
2814 if (SBYTES (filename
) == 2
2815 && *(SDATA (filename
) + 1) == ':')
2818 /* first expand it. */
2819 filename
= Fexpand_file_name (filename
, Qnil
);
2821 if (!w32_get_long_filename (SDATA (ENCODE_FILE (filename
)), longname
,
2825 dostounix_filename (longname
);
2827 /* If we were passed only a drive, make sure that a slash is not appended
2828 for consistency with directories. Allow for drive mapping via SUBST
2829 in case expand-file-name is ever changed to expand those. */
2830 if (drive_only
&& longname
[1] == ':' && longname
[2] == '/' && !longname
[3])
2833 return DECODE_FILE (build_unibyte_string (longname
));
2836 DEFUN ("w32-set-process-priority", Fw32_set_process_priority
,
2837 Sw32_set_process_priority
, 2, 2, 0,
2838 doc
: /* Set the priority of PROCESS to PRIORITY.
2839 If PROCESS is nil, the priority of Emacs is changed, otherwise the
2840 priority of the process whose pid is PROCESS is changed.
2841 PRIORITY should be one of the symbols high, normal, or low;
2842 any other symbol will be interpreted as normal.
2844 If successful, the return value is t, otherwise nil. */)
2845 (Lisp_Object process
, Lisp_Object priority
)
2847 HANDLE proc_handle
= GetCurrentProcess ();
2848 DWORD priority_class
= NORMAL_PRIORITY_CLASS
;
2849 Lisp_Object result
= Qnil
;
2851 CHECK_SYMBOL (priority
);
2853 if (!NILP (process
))
2858 CHECK_NUMBER (process
);
2860 /* Allow pid to be an internally generated one, or one obtained
2861 externally. This is necessary because real pids on Windows 95 are
2864 pid
= XINT (process
);
2865 cp
= find_child_pid (pid
);
2867 pid
= cp
->procinfo
.dwProcessId
;
2869 proc_handle
= OpenProcess (PROCESS_SET_INFORMATION
, FALSE
, pid
);
2872 if (EQ (priority
, Qhigh
))
2873 priority_class
= HIGH_PRIORITY_CLASS
;
2874 else if (EQ (priority
, Qlow
))
2875 priority_class
= IDLE_PRIORITY_CLASS
;
2877 if (proc_handle
!= NULL
)
2879 if (SetPriorityClass (proc_handle
, priority_class
))
2881 if (!NILP (process
))
2882 CloseHandle (proc_handle
);
2888 #ifdef HAVE_LANGINFO_CODESET
2889 /* Emulation of nl_langinfo. Used in fns.c:Flocale_info. */
2891 nl_langinfo (nl_item item
)
2893 /* Conversion of Posix item numbers to their Windows equivalents. */
2894 static const LCTYPE w32item
[] = {
2895 LOCALE_IDEFAULTANSICODEPAGE
,
2896 LOCALE_SDAYNAME1
, LOCALE_SDAYNAME2
, LOCALE_SDAYNAME3
,
2897 LOCALE_SDAYNAME4
, LOCALE_SDAYNAME5
, LOCALE_SDAYNAME6
, LOCALE_SDAYNAME7
,
2898 LOCALE_SMONTHNAME1
, LOCALE_SMONTHNAME2
, LOCALE_SMONTHNAME3
,
2899 LOCALE_SMONTHNAME4
, LOCALE_SMONTHNAME5
, LOCALE_SMONTHNAME6
,
2900 LOCALE_SMONTHNAME7
, LOCALE_SMONTHNAME8
, LOCALE_SMONTHNAME9
,
2901 LOCALE_SMONTHNAME10
, LOCALE_SMONTHNAME11
, LOCALE_SMONTHNAME12
2904 static char *nl_langinfo_buf
= NULL
;
2905 static int nl_langinfo_len
= 0;
2907 if (nl_langinfo_len
<= 0)
2908 nl_langinfo_buf
= xmalloc (nl_langinfo_len
= 1);
2910 if (item
< 0 || item
>= _NL_NUM
)
2911 nl_langinfo_buf
[0] = 0;
2914 LCID cloc
= GetThreadLocale ();
2915 int need_len
= GetLocaleInfo (cloc
, w32item
[item
] | LOCALE_USE_CP_ACP
,
2919 nl_langinfo_buf
[0] = 0;
2922 if (item
== CODESET
)
2924 need_len
+= 2; /* for the "cp" prefix */
2925 if (need_len
< 8) /* for the case we call GetACP */
2928 if (nl_langinfo_len
<= need_len
)
2929 nl_langinfo_buf
= xrealloc (nl_langinfo_buf
,
2930 nl_langinfo_len
= need_len
);
2931 if (!GetLocaleInfo (cloc
, w32item
[item
] | LOCALE_USE_CP_ACP
,
2932 nl_langinfo_buf
, nl_langinfo_len
))
2933 nl_langinfo_buf
[0] = 0;
2934 else if (item
== CODESET
)
2936 if (strcmp (nl_langinfo_buf
, "0") == 0 /* CP_ACP */
2937 || strcmp (nl_langinfo_buf
, "1") == 0) /* CP_OEMCP */
2938 sprintf (nl_langinfo_buf
, "cp%u", GetACP ());
2941 memmove (nl_langinfo_buf
+ 2, nl_langinfo_buf
,
2942 strlen (nl_langinfo_buf
) + 1);
2943 nl_langinfo_buf
[0] = 'c';
2944 nl_langinfo_buf
[1] = 'p';
2949 return nl_langinfo_buf
;
2951 #endif /* HAVE_LANGINFO_CODESET */
2953 DEFUN ("w32-get-locale-info", Fw32_get_locale_info
,
2954 Sw32_get_locale_info
, 1, 2, 0,
2955 doc
: /* Return information about the Windows locale LCID.
2956 By default, return a three letter locale code which encodes the default
2957 language as the first two characters, and the country or regional variant
2958 as the third letter. For example, ENU refers to `English (United States)',
2959 while ENC means `English (Canadian)'.
2961 If the optional argument LONGFORM is t, the long form of the locale
2962 name is returned, e.g. `English (United States)' instead; if LONGFORM
2963 is a number, it is interpreted as an LCTYPE constant and the corresponding
2964 locale information is returned.
2966 If LCID (a 16-bit number) is not a valid locale, the result is nil. */)
2967 (Lisp_Object lcid
, Lisp_Object longform
)
2971 char abbrev_name
[32] = { 0 };
2972 char full_name
[256] = { 0 };
2974 CHECK_NUMBER (lcid
);
2976 if (!IsValidLocale (XINT (lcid
), LCID_SUPPORTED
))
2979 if (NILP (longform
))
2981 got_abbrev
= GetLocaleInfo (XINT (lcid
),
2982 LOCALE_SABBREVLANGNAME
| LOCALE_USE_CP_ACP
,
2983 abbrev_name
, sizeof (abbrev_name
));
2985 return build_string (abbrev_name
);
2987 else if (EQ (longform
, Qt
))
2989 got_full
= GetLocaleInfo (XINT (lcid
),
2990 LOCALE_SLANGUAGE
| LOCALE_USE_CP_ACP
,
2991 full_name
, sizeof (full_name
));
2993 return DECODE_SYSTEM (build_string (full_name
));
2995 else if (NUMBERP (longform
))
2997 got_full
= GetLocaleInfo (XINT (lcid
),
2999 full_name
, sizeof (full_name
));
3000 /* GetLocaleInfo's return value includes the terminating null
3001 character, when the returned information is a string, whereas
3002 make_unibyte_string needs the string length without the
3003 terminating null. */
3005 return make_unibyte_string (full_name
, got_full
- 1);
3012 DEFUN ("w32-get-current-locale-id", Fw32_get_current_locale_id
,
3013 Sw32_get_current_locale_id
, 0, 0, 0,
3014 doc
: /* Return Windows locale id for current locale setting.
3015 This is a numerical value; use `w32-get-locale-info' to convert to a
3016 human-readable form. */)
3019 return make_number (GetThreadLocale ());
3023 int_from_hex (char * s
)
3026 static char hex
[] = "0123456789abcdefABCDEF";
3029 while (*s
&& (p
= strchr (hex
, *s
)) != NULL
)
3031 unsigned digit
= p
- hex
;
3034 val
= val
* 16 + digit
;
3040 /* We need to build a global list, since the EnumSystemLocale callback
3041 function isn't given a context pointer. */
3042 Lisp_Object Vw32_valid_locale_ids
;
3044 static BOOL CALLBACK
3045 enum_locale_fn (LPTSTR localeNum
)
3047 DWORD id
= int_from_hex (localeNum
);
3048 Vw32_valid_locale_ids
= Fcons (make_number (id
), Vw32_valid_locale_ids
);
3052 DEFUN ("w32-get-valid-locale-ids", Fw32_get_valid_locale_ids
,
3053 Sw32_get_valid_locale_ids
, 0, 0, 0,
3054 doc
: /* Return list of all valid Windows locale ids.
3055 Each id is a numerical value; use `w32-get-locale-info' to convert to a
3056 human-readable form. */)
3059 Vw32_valid_locale_ids
= Qnil
;
3061 EnumSystemLocales (enum_locale_fn
, LCID_SUPPORTED
);
3063 Vw32_valid_locale_ids
= Fnreverse (Vw32_valid_locale_ids
);
3064 return Vw32_valid_locale_ids
;
3068 DEFUN ("w32-get-default-locale-id", Fw32_get_default_locale_id
, Sw32_get_default_locale_id
, 0, 1, 0,
3069 doc
: /* Return Windows locale id for default locale setting.
3070 By default, the system default locale setting is returned; if the optional
3071 parameter USERP is non-nil, the user default locale setting is returned.
3072 This is a numerical value; use `w32-get-locale-info' to convert to a
3073 human-readable form. */)
3077 return make_number (GetSystemDefaultLCID ());
3078 return make_number (GetUserDefaultLCID ());
3082 DEFUN ("w32-set-current-locale", Fw32_set_current_locale
, Sw32_set_current_locale
, 1, 1, 0,
3083 doc
: /* Make Windows locale LCID be the current locale setting for Emacs.
3084 If successful, the new locale id is returned, otherwise nil. */)
3087 CHECK_NUMBER (lcid
);
3089 if (!IsValidLocale (XINT (lcid
), LCID_SUPPORTED
))
3092 if (!SetThreadLocale (XINT (lcid
)))
3095 /* Need to set input thread locale if present. */
3096 if (dwWindowsThreadId
)
3097 /* Reply is not needed. */
3098 PostThreadMessage (dwWindowsThreadId
, WM_EMACS_SETLOCALE
, XINT (lcid
), 0);
3100 return make_number (GetThreadLocale ());
3104 /* We need to build a global list, since the EnumCodePages callback
3105 function isn't given a context pointer. */
3106 Lisp_Object Vw32_valid_codepages
;
3108 static BOOL CALLBACK
3109 enum_codepage_fn (LPTSTR codepageNum
)
3111 DWORD id
= atoi (codepageNum
);
3112 Vw32_valid_codepages
= Fcons (make_number (id
), Vw32_valid_codepages
);
3116 DEFUN ("w32-get-valid-codepages", Fw32_get_valid_codepages
,
3117 Sw32_get_valid_codepages
, 0, 0, 0,
3118 doc
: /* Return list of all valid Windows codepages. */)
3121 Vw32_valid_codepages
= Qnil
;
3123 EnumSystemCodePages (enum_codepage_fn
, CP_SUPPORTED
);
3125 Vw32_valid_codepages
= Fnreverse (Vw32_valid_codepages
);
3126 return Vw32_valid_codepages
;
3130 DEFUN ("w32-get-console-codepage", Fw32_get_console_codepage
,
3131 Sw32_get_console_codepage
, 0, 0, 0,
3132 doc
: /* Return current Windows codepage for console input. */)
3135 return make_number (GetConsoleCP ());
3139 DEFUN ("w32-set-console-codepage", Fw32_set_console_codepage
,
3140 Sw32_set_console_codepage
, 1, 1, 0,
3141 doc
: /* Make Windows codepage CP be the codepage for Emacs tty keyboard input.
3142 This codepage setting affects keyboard input in tty mode.
3143 If successful, the new CP is returned, otherwise nil. */)
3148 if (!IsValidCodePage (XINT (cp
)))
3151 if (!SetConsoleCP (XINT (cp
)))
3154 return make_number (GetConsoleCP ());
3158 DEFUN ("w32-get-console-output-codepage", Fw32_get_console_output_codepage
,
3159 Sw32_get_console_output_codepage
, 0, 0, 0,
3160 doc
: /* Return current Windows codepage for console output. */)
3163 return make_number (GetConsoleOutputCP ());
3167 DEFUN ("w32-set-console-output-codepage", Fw32_set_console_output_codepage
,
3168 Sw32_set_console_output_codepage
, 1, 1, 0,
3169 doc
: /* Make Windows codepage CP be the codepage for Emacs console output.
3170 This codepage setting affects display in tty mode.
3171 If successful, the new CP is returned, otherwise nil. */)
3176 if (!IsValidCodePage (XINT (cp
)))
3179 if (!SetConsoleOutputCP (XINT (cp
)))
3182 return make_number (GetConsoleOutputCP ());
3186 DEFUN ("w32-get-codepage-charset", Fw32_get_codepage_charset
,
3187 Sw32_get_codepage_charset
, 1, 1, 0,
3188 doc
: /* Return charset ID corresponding to codepage CP.
3189 Returns nil if the codepage is not valid or its charset ID could
3192 Note that this function is only guaranteed to work with ANSI
3193 codepages; most console codepages are not supported and will
3201 if (!IsValidCodePage (XINT (cp
)))
3204 if (TranslateCharsetInfo ((DWORD
*) XINT (cp
), &info
, TCI_SRCCODEPAGE
))
3205 return make_number (info
.ciCharset
);
3211 DEFUN ("w32-get-valid-keyboard-layouts", Fw32_get_valid_keyboard_layouts
,
3212 Sw32_get_valid_keyboard_layouts
, 0, 0, 0,
3213 doc
: /* Return list of Windows keyboard languages and layouts.
3214 The return value is a list of pairs of language id and layout id. */)
3217 int num_layouts
= GetKeyboardLayoutList (0, NULL
);
3218 HKL
* layouts
= (HKL
*) alloca (num_layouts
* sizeof (HKL
));
3219 Lisp_Object obj
= Qnil
;
3221 if (GetKeyboardLayoutList (num_layouts
, layouts
) == num_layouts
)
3223 while (--num_layouts
>= 0)
3225 HKL kl
= layouts
[num_layouts
];
3227 obj
= Fcons (Fcons (make_number (LOWORD (kl
)),
3228 make_number (HIWORD (kl
))),
3237 DEFUN ("w32-get-keyboard-layout", Fw32_get_keyboard_layout
,
3238 Sw32_get_keyboard_layout
, 0, 0, 0,
3239 doc
: /* Return current Windows keyboard language and layout.
3240 The return value is the cons of the language id and the layout id. */)
3243 HKL kl
= GetKeyboardLayout (dwWindowsThreadId
);
3245 return Fcons (make_number (LOWORD (kl
)),
3246 make_number (HIWORD (kl
)));
3250 DEFUN ("w32-set-keyboard-layout", Fw32_set_keyboard_layout
,
3251 Sw32_set_keyboard_layout
, 1, 1, 0,
3252 doc
: /* Make LAYOUT be the current keyboard layout for Emacs.
3253 The keyboard layout setting affects interpretation of keyboard input.
3254 If successful, the new layout id is returned, otherwise nil. */)
3255 (Lisp_Object layout
)
3259 CHECK_CONS (layout
);
3260 CHECK_NUMBER_CAR (layout
);
3261 CHECK_NUMBER_CDR (layout
);
3263 kl
= (HKL
) ((XINT (XCAR (layout
)) & 0xffff)
3264 | (XINT (XCDR (layout
)) << 16));
3266 /* Synchronize layout with input thread. */
3267 if (dwWindowsThreadId
)
3269 if (PostThreadMessage (dwWindowsThreadId
, WM_EMACS_SETKEYBOARDLAYOUT
,
3273 GetMessage (&msg
, NULL
, WM_EMACS_DONE
, WM_EMACS_DONE
);
3275 if (msg
.wParam
== 0)
3279 else if (!ActivateKeyboardLayout (kl
, 0))
3282 return Fw32_get_keyboard_layout ();
3287 syms_of_ntproc (void)
3289 DEFSYM (Qhigh
, "high");
3290 DEFSYM (Qlow
, "low");
3292 defsubr (&Sw32_has_winsock
);
3293 defsubr (&Sw32_unload_winsock
);
3295 defsubr (&Sw32_short_file_name
);
3296 defsubr (&Sw32_long_file_name
);
3297 defsubr (&Sw32_set_process_priority
);
3298 defsubr (&Sw32_get_locale_info
);
3299 defsubr (&Sw32_get_current_locale_id
);
3300 defsubr (&Sw32_get_default_locale_id
);
3301 defsubr (&Sw32_get_valid_locale_ids
);
3302 defsubr (&Sw32_set_current_locale
);
3304 defsubr (&Sw32_get_console_codepage
);
3305 defsubr (&Sw32_set_console_codepage
);
3306 defsubr (&Sw32_get_console_output_codepage
);
3307 defsubr (&Sw32_set_console_output_codepage
);
3308 defsubr (&Sw32_get_valid_codepages
);
3309 defsubr (&Sw32_get_codepage_charset
);
3311 defsubr (&Sw32_get_valid_keyboard_layouts
);
3312 defsubr (&Sw32_get_keyboard_layout
);
3313 defsubr (&Sw32_set_keyboard_layout
);
3315 DEFVAR_LISP ("w32-quote-process-args", Vw32_quote_process_args
,
3316 doc
: /* Non-nil enables quoting of process arguments to ensure correct parsing.
3317 Because Windows does not directly pass argv arrays to child processes,
3318 programs have to reconstruct the argv array by parsing the command
3319 line string. For an argument to contain a space, it must be enclosed
3320 in double quotes or it will be parsed as multiple arguments.
3322 If the value is a character, that character will be used to escape any
3323 quote characters that appear, otherwise a suitable escape character
3324 will be chosen based on the type of the program. */);
3325 Vw32_quote_process_args
= Qt
;
3327 DEFVAR_LISP ("w32-start-process-show-window",
3328 Vw32_start_process_show_window
,
3329 doc
: /* When nil, new child processes hide their windows.
3330 When non-nil, they show their window in the method of their choice.
3331 This variable doesn't affect GUI applications, which will never be hidden. */);
3332 Vw32_start_process_show_window
= Qnil
;
3334 DEFVAR_LISP ("w32-start-process-share-console",
3335 Vw32_start_process_share_console
,
3336 doc
: /* When nil, new child processes are given a new console.
3337 When non-nil, they share the Emacs console; this has the limitation of
3338 allowing only one DOS subprocess to run at a time (whether started directly
3339 or indirectly by Emacs), and preventing Emacs from cleanly terminating the
3340 subprocess group, but may allow Emacs to interrupt a subprocess that doesn't
3341 otherwise respond to interrupts from Emacs. */);
3342 Vw32_start_process_share_console
= Qnil
;
3344 DEFVAR_LISP ("w32-start-process-inherit-error-mode",
3345 Vw32_start_process_inherit_error_mode
,
3346 doc
: /* When nil, new child processes revert to the default error mode.
3347 When non-nil, they inherit their error mode setting from Emacs, which stops
3348 them blocking when trying to access unmounted drives etc. */);
3349 Vw32_start_process_inherit_error_mode
= Qt
;
3351 DEFVAR_INT ("w32-pipe-read-delay", w32_pipe_read_delay
,
3352 doc
: /* Forced delay before reading subprocess output.
3353 This is done to improve the buffering of subprocess output, by
3354 avoiding the inefficiency of frequently reading small amounts of data.
3356 If positive, the value is the number of milliseconds to sleep before
3357 reading the subprocess output. If negative, the magnitude is the number
3358 of time slices to wait (effectively boosting the priority of the child
3359 process temporarily). A value of zero disables waiting entirely. */);
3360 w32_pipe_read_delay
= 50;
3362 DEFVAR_LISP ("w32-downcase-file-names", Vw32_downcase_file_names
,
3363 doc
: /* Non-nil means convert all-upper case file names to lower case.
3364 This applies when performing completions and file name expansion.
3365 Note that the value of this setting also affects remote file names,
3366 so you probably don't want to set to non-nil if you use case-sensitive
3367 filesystems via ange-ftp. */);
3368 Vw32_downcase_file_names
= Qnil
;
3371 DEFVAR_LISP ("w32-generate-fake-inodes", Vw32_generate_fake_inodes
,
3372 doc
: /* Non-nil means attempt to fake realistic inode values.
3373 This works by hashing the truename of files, and should detect
3374 aliasing between long and short (8.3 DOS) names, but can have
3375 false positives because of hash collisions. Note that determining
3376 the truename of a file can be slow. */);
3377 Vw32_generate_fake_inodes
= Qnil
;
3380 DEFVAR_LISP ("w32-get-true-file-attributes", Vw32_get_true_file_attributes
,
3381 doc
: /* Non-nil means determine accurate file attributes in `file-attributes'.
3382 This option controls whether to issue additional system calls to determine
3383 accurate link counts, file type, and ownership information. It is more
3384 useful for files on NTFS volumes, where hard links and file security are
3385 supported, than on volumes of the FAT family.
3387 Without these system calls, link count will always be reported as 1 and file
3388 ownership will be attributed to the current user.
3389 The default value `local' means only issue these system calls for files
3390 on local fixed drives. A value of nil means never issue them.
3391 Any other non-nil value means do this even on remote and removable drives
3392 where the performance impact may be noticeable even on modern hardware. */);
3393 Vw32_get_true_file_attributes
= Qlocal
;
3395 staticpro (&Vw32_valid_locale_ids
);
3396 staticpro (&Vw32_valid_codepages
);
3398 /* end of w32proc.c */