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>
37 /* must include CRT headers *before* config.h */
47 #if defined(__GNUC__) && !defined(__MINGW64__)
48 /* This definition is missing from mingw.org headers, but not MinGW64
50 extern BOOL WINAPI
IsValidLocale (LCID
, DWORD
);
53 #ifdef HAVE_LANGINFO_CODESET
60 #include "w32common.h"
65 #include "syssignal.h"
67 #include "dispextern.h" /* for xstrcasecmp */
70 #define RVA_TO_PTR(var,section,filedata) \
71 ((void *)((section)->PointerToRawData \
72 + ((DWORD_PTR)(var) - (section)->VirtualAddress) \
73 + (filedata).file_base))
75 /* Signal handlers...SIG_DFL == 0 so this is initialized correctly. */
76 static signal_handler sig_handlers
[NSIG
];
78 static sigset_t sig_mask
;
80 static CRITICAL_SECTION crit_sig
;
82 /* Improve on the CRT 'signal' implementation so that we could record
83 the SIGCHLD handler and fake interval timers. */
85 sys_signal (int sig
, signal_handler handler
)
89 /* SIGCHLD is needed for supporting subprocesses, see sys_kill
90 below. SIGALRM and SIGPROF are used by setitimer. All the
91 others are the only ones supported by the MS runtime. */
92 if (!(sig
== SIGCHLD
|| sig
== SIGSEGV
|| sig
== SIGILL
93 || sig
== SIGFPE
|| sig
== SIGABRT
|| sig
== SIGTERM
94 || sig
== SIGALRM
|| sig
== SIGPROF
))
99 old
= sig_handlers
[sig
];
100 /* SIGABRT is treated specially because w32.c installs term_ntproc
101 as its handler, so we don't want to override that afterwards.
102 Aborting Emacs works specially anyway: either by calling
103 emacs_abort directly or through terminate_due_to_signal, which
104 calls emacs_abort through emacs_raise. */
105 if (!(sig
== SIGABRT
&& old
== term_ntproc
))
107 sig_handlers
[sig
] = handler
;
108 if (!(sig
== SIGCHLD
|| sig
== SIGALRM
|| sig
== SIGPROF
))
109 signal (sig
, handler
);
114 /* Emulate sigaction. */
116 sigaction (int sig
, const struct sigaction
*act
, struct sigaction
*oact
)
118 signal_handler old
= SIG_DFL
;
122 old
= sys_signal (sig
, act
->sa_handler
);
124 old
= sig_handlers
[sig
];
133 oact
->sa_handler
= old
;
135 oact
->sa_mask
= empty_mask
;
140 /* Emulate signal sets and blocking of signals used by timers. */
143 sigemptyset (sigset_t
*set
)
150 sigaddset (sigset_t
*set
, int signo
)
157 if (signo
< 0 || signo
>= NSIG
)
163 *set
|= (1U << signo
);
169 sigfillset (sigset_t
*set
)
182 sigprocmask (int how
, const sigset_t
*set
, sigset_t
*oset
)
184 if (!(how
== SIG_BLOCK
|| how
== SIG_UNBLOCK
|| how
== SIG_SETMASK
))
205 /* FIXME: Catch signals that are blocked and reissue them when
206 they are unblocked. Important for SIGALRM and SIGPROF only. */
215 pthread_sigmask (int how
, const sigset_t
*set
, sigset_t
*oset
)
217 if (sigprocmask (how
, set
, oset
) == -1)
223 sigismember (const sigset_t
*set
, int signo
)
225 if (signo
< 0 || signo
>= NSIG
)
230 if (signo
> sizeof (*set
) * BITS_PER_CHAR
)
233 return (*set
& (1U << signo
)) != 0;
249 setpgid (pid_t pid
, pid_t pgid
)
260 /* Emulations of interval timers.
262 Limitations: only ITIMER_REAL and ITIMER_PROF are supported.
264 Implementation: a separate thread is started for each timer type,
265 the thread calls the appropriate signal handler when the timer
266 expires, after stopping the thread which installed the timer. */
269 volatile ULONGLONG expire
;
270 volatile ULONGLONG reload
;
271 volatile int terminate
;
273 HANDLE caller_thread
;
277 static ULONGLONG ticks_now
;
278 static struct itimer_data real_itimer
, prof_itimer
;
279 static ULONGLONG clocks_min
;
280 /* If non-zero, itimers are disabled. Used during shutdown, when we
281 delete the critical sections used by the timer threads. */
282 static int disable_itimers
;
284 static CRITICAL_SECTION crit_real
, crit_prof
;
286 /* GetThreadTimes is not available on Windows 9X and possibly also on 2K. */
287 typedef BOOL (WINAPI
*GetThreadTimes_Proc
) (
289 LPFILETIME lpCreationTime
,
290 LPFILETIME lpExitTime
,
291 LPFILETIME lpKernelTime
,
292 LPFILETIME lpUserTime
);
294 static GetThreadTimes_Proc s_pfn_Get_Thread_Times
;
296 #define MAX_SINGLE_SLEEP 30
297 #define TIMER_TICKS_PER_SEC 1000
299 /* Return a suitable time value, in 1-ms units, for THREAD, a handle
300 to a thread. If THREAD is NULL or an invalid handle, return the
301 current wall-clock time since January 1, 1601 (UTC). Otherwise,
302 return the sum of kernel and user times used by THREAD since it was
303 created, plus its creation time. */
305 w32_get_timer_time (HANDLE thread
)
308 int use_system_time
= 1;
309 /* The functions below return times in 100-ns units. */
310 const int tscale
= 10 * TIMER_TICKS_PER_SEC
;
312 if (thread
&& thread
!= INVALID_HANDLE_VALUE
313 && s_pfn_Get_Thread_Times
!= NULL
)
315 FILETIME creation_ftime
, exit_ftime
, kernel_ftime
, user_ftime
;
316 ULARGE_INTEGER temp_creation
, temp_kernel
, temp_user
;
318 if (s_pfn_Get_Thread_Times (thread
, &creation_ftime
, &exit_ftime
,
319 &kernel_ftime
, &user_ftime
))
322 temp_creation
.LowPart
= creation_ftime
.dwLowDateTime
;
323 temp_creation
.HighPart
= creation_ftime
.dwHighDateTime
;
324 temp_kernel
.LowPart
= kernel_ftime
.dwLowDateTime
;
325 temp_kernel
.HighPart
= kernel_ftime
.dwHighDateTime
;
326 temp_user
.LowPart
= user_ftime
.dwLowDateTime
;
327 temp_user
.HighPart
= user_ftime
.dwHighDateTime
;
329 temp_creation
.QuadPart
/ tscale
+ temp_kernel
.QuadPart
/ tscale
330 + temp_user
.QuadPart
/ tscale
;
333 DebPrint (("GetThreadTimes failed with error code %lu\n",
339 FILETIME current_ftime
;
342 GetSystemTimeAsFileTime (¤t_ftime
);
344 temp
.LowPart
= current_ftime
.dwLowDateTime
;
345 temp
.HighPart
= current_ftime
.dwHighDateTime
;
347 retval
= temp
.QuadPart
/ tscale
;
353 /* Thread function for a timer thread. */
355 timer_loop (LPVOID arg
)
357 struct itimer_data
*itimer
= (struct itimer_data
*)arg
;
358 int which
= itimer
->type
;
359 int sig
= (which
== ITIMER_REAL
) ? SIGALRM
: SIGPROF
;
360 CRITICAL_SECTION
*crit
= (which
== ITIMER_REAL
) ? &crit_real
: &crit_prof
;
361 const DWORD max_sleep
= MAX_SINGLE_SLEEP
* 1000 / TIMER_TICKS_PER_SEC
;
362 HANDLE hth
= (which
== ITIMER_REAL
) ? NULL
: itimer
->caller_thread
;
367 signal_handler handler
;
368 ULONGLONG now
, expire
, reload
;
370 /* Load new values if requested by setitimer. */
371 EnterCriticalSection (crit
);
372 expire
= itimer
->expire
;
373 reload
= itimer
->reload
;
374 LeaveCriticalSection (crit
);
375 if (itimer
->terminate
)
385 if (expire
> (now
= w32_get_timer_time (hth
)))
386 sleep_time
= expire
- now
;
389 /* Don't sleep too long at a time, to be able to see the
390 termination flag without too long a delay. */
391 while (sleep_time
> max_sleep
)
393 if (itimer
->terminate
)
396 EnterCriticalSection (crit
);
397 expire
= itimer
->expire
;
398 LeaveCriticalSection (crit
);
400 (expire
> (now
= w32_get_timer_time (hth
))) ? expire
- now
: 0;
402 if (itimer
->terminate
)
406 Sleep (sleep_time
* 1000 / TIMER_TICKS_PER_SEC
);
407 /* Always sleep past the expiration time, to make sure we
408 never call the handler _before_ the expiration time,
409 always slightly after it. Sleep(5) makes sure we don't
410 hog the CPU by calling 'w32_get_timer_time' with high
411 frequency, and also let other threads work. */
412 while (w32_get_timer_time (hth
) < expire
)
416 EnterCriticalSection (crit
);
417 expire
= itimer
->expire
;
418 LeaveCriticalSection (crit
);
423 handler
= sig_handlers
[sig
];
424 if (!(handler
== SIG_DFL
|| handler
== SIG_IGN
|| handler
== SIG_ERR
)
425 /* FIXME: Don't ignore masked signals. Instead, record that
426 they happened and reissue them when the signal is
428 && !sigismember (&sig_mask
, sig
)
429 /* Simulate masking of SIGALRM and SIGPROF when processing
431 && !fatal_error_in_progress
432 && itimer
->caller_thread
)
434 /* Simulate a signal delivered to the thread which installed
435 the timer, by suspending that thread while the handler
437 HANDLE th
= itimer
->caller_thread
;
438 DWORD result
= SuspendThread (th
);
440 if (result
== (DWORD
)-1)
447 /* Update expiration time and loop. */
448 EnterCriticalSection (crit
);
449 expire
= itimer
->expire
;
452 LeaveCriticalSection (crit
);
455 reload
= itimer
->reload
;
458 now
= w32_get_timer_time (hth
);
461 ULONGLONG lag
= now
- expire
;
463 /* If we missed some opportunities (presumably while
464 sleeping or while the signal handler ran), skip
467 expire
= now
- (lag
% reload
);
473 expire
= 0; /* become idle */
474 itimer
->expire
= expire
;
475 LeaveCriticalSection (crit
);
481 stop_timer_thread (int which
)
483 struct itimer_data
*itimer
=
484 (which
== ITIMER_REAL
) ? &real_itimer
: &prof_itimer
;
486 DWORD err
, exit_code
= 255;
489 /* Signal the thread that it should terminate. */
490 itimer
->terminate
= 1;
492 if (itimer
->timer_thread
== NULL
)
495 /* Wait for the timer thread to terminate voluntarily, then kill it
496 if it doesn't. This loop waits twice more than the maximum
497 amount of time a timer thread sleeps, see above. */
498 for (i
= 0; i
< MAX_SINGLE_SLEEP
/ 5; i
++)
500 if (!((status
= GetExitCodeThread (itimer
->timer_thread
, &exit_code
))
501 && exit_code
== STILL_ACTIVE
))
505 if ((status
== FALSE
&& (err
= GetLastError ()) == ERROR_INVALID_HANDLE
)
506 || exit_code
== STILL_ACTIVE
)
508 if (!(status
== FALSE
&& err
== ERROR_INVALID_HANDLE
))
509 TerminateThread (itimer
->timer_thread
, 0);
513 CloseHandle (itimer
->timer_thread
);
514 itimer
->timer_thread
= NULL
;
515 if (itimer
->caller_thread
)
517 CloseHandle (itimer
->caller_thread
);
518 itimer
->caller_thread
= NULL
;
522 /* This is called at shutdown time from term_ntproc. */
526 if (real_itimer
.timer_thread
)
527 stop_timer_thread (ITIMER_REAL
);
528 if (prof_itimer
.timer_thread
)
529 stop_timer_thread (ITIMER_PROF
);
531 /* We are going to delete the critical sections, so timers cannot
535 DeleteCriticalSection (&crit_real
);
536 DeleteCriticalSection (&crit_prof
);
537 DeleteCriticalSection (&crit_sig
);
540 /* This is called at initialization time from init_ntproc. */
544 /* GetThreadTimes is not available on all versions of Windows, so
545 need to probe for its availability dynamically, and call it
546 through a pointer. */
547 s_pfn_Get_Thread_Times
= NULL
; /* in case dumped Emacs comes with a value */
548 if (os_subtype
!= OS_9X
)
549 s_pfn_Get_Thread_Times
=
550 (GetThreadTimes_Proc
)GetProcAddress (GetModuleHandle ("kernel32.dll"),
553 /* Make sure we start with zeroed out itimer structures, since
554 dumping may have left there traces of threads long dead. */
555 memset (&real_itimer
, 0, sizeof real_itimer
);
556 memset (&prof_itimer
, 0, sizeof prof_itimer
);
558 InitializeCriticalSection (&crit_real
);
559 InitializeCriticalSection (&crit_prof
);
560 InitializeCriticalSection (&crit_sig
);
566 start_timer_thread (int which
)
568 DWORD exit_code
, tid
;
570 struct itimer_data
*itimer
=
571 (which
== ITIMER_REAL
) ? &real_itimer
: &prof_itimer
;
573 if (itimer
->timer_thread
574 && GetExitCodeThread (itimer
->timer_thread
, &exit_code
)
575 && exit_code
== STILL_ACTIVE
)
578 /* Clean up after possibly exited thread. */
579 if (itimer
->timer_thread
)
581 CloseHandle (itimer
->timer_thread
);
582 itimer
->timer_thread
= NULL
;
584 if (itimer
->caller_thread
)
586 CloseHandle (itimer
->caller_thread
);
587 itimer
->caller_thread
= NULL
;
590 /* Start a new thread. */
591 if (!DuplicateHandle (GetCurrentProcess (), GetCurrentThread (),
592 GetCurrentProcess (), &th
, 0, FALSE
,
593 DUPLICATE_SAME_ACCESS
))
598 itimer
->terminate
= 0;
599 itimer
->type
= which
;
600 itimer
->caller_thread
= th
;
601 /* Request that no more than 64KB of stack be reserved for this
602 thread, to avoid reserving too much memory, which would get in
603 the way of threads we start to wait for subprocesses. See also
605 itimer
->timer_thread
= CreateThread (NULL
, 64 * 1024, timer_loop
,
606 (void *)itimer
, 0x00010000, &tid
);
608 if (!itimer
->timer_thread
)
610 CloseHandle (itimer
->caller_thread
);
611 itimer
->caller_thread
= NULL
;
616 /* This is needed to make sure that the timer thread running for
617 profiling gets CPU as soon as the Sleep call terminates. */
618 if (which
== ITIMER_PROF
)
619 SetThreadPriority (itimer
->timer_thread
, THREAD_PRIORITY_TIME_CRITICAL
);
624 /* Most of the code of getitimer and setitimer (but not of their
625 subroutines) was shamelessly stolen from itimer.c in the DJGPP
626 library, see www.delorie.com/djgpp. */
628 getitimer (int which
, struct itimerval
*value
)
630 volatile ULONGLONG
*t_expire
;
631 volatile ULONGLONG
*t_reload
;
632 ULONGLONG expire
, reload
;
634 CRITICAL_SECTION
*crit
;
635 struct itimer_data
*itimer
;
646 if (which
!= ITIMER_REAL
&& which
!= ITIMER_PROF
)
652 itimer
= (which
== ITIMER_REAL
) ? &real_itimer
: &prof_itimer
;
654 ticks_now
= w32_get_timer_time ((which
== ITIMER_REAL
)
656 : GetCurrentThread ());
658 t_expire
= &itimer
->expire
;
659 t_reload
= &itimer
->reload
;
660 crit
= (which
== ITIMER_REAL
) ? &crit_real
: &crit_prof
;
662 EnterCriticalSection (crit
);
665 LeaveCriticalSection (crit
);
670 value
->it_value
.tv_sec
= expire
/ TIMER_TICKS_PER_SEC
;
672 (expire
% TIMER_TICKS_PER_SEC
) * (__int64
)1000000 / TIMER_TICKS_PER_SEC
;
673 value
->it_value
.tv_usec
= usecs
;
674 value
->it_interval
.tv_sec
= reload
/ TIMER_TICKS_PER_SEC
;
676 (reload
% TIMER_TICKS_PER_SEC
) * (__int64
)1000000 / TIMER_TICKS_PER_SEC
;
677 value
->it_interval
.tv_usec
= usecs
;
683 setitimer(int which
, struct itimerval
*value
, struct itimerval
*ovalue
)
685 volatile ULONGLONG
*t_expire
, *t_reload
;
686 ULONGLONG expire
, reload
, expire_old
, reload_old
;
688 CRITICAL_SECTION
*crit
;
689 struct itimerval tem
, *ptem
;
694 /* Posix systems expect timer values smaller than the resolution of
695 the system clock be rounded up to the clock resolution. First
696 time we are called, measure the clock tick resolution. */
701 for (t1
= w32_get_timer_time (NULL
);
702 (t2
= w32_get_timer_time (NULL
)) == t1
; )
704 clocks_min
= t2
- t1
;
712 if (getitimer (which
, ptem
)) /* also sets ticks_now */
713 return -1; /* errno already set */
716 (which
== ITIMER_REAL
) ? &real_itimer
.expire
: &prof_itimer
.expire
;
718 (which
== ITIMER_REAL
) ? &real_itimer
.reload
: &prof_itimer
.reload
;
720 crit
= (which
== ITIMER_REAL
) ? &crit_real
: &crit_prof
;
723 || (value
->it_value
.tv_sec
== 0 && value
->it_value
.tv_usec
== 0))
725 EnterCriticalSection (crit
);
726 /* Disable the timer. */
729 LeaveCriticalSection (crit
);
733 reload
= value
->it_interval
.tv_sec
* TIMER_TICKS_PER_SEC
;
735 usecs
= value
->it_interval
.tv_usec
;
736 if (value
->it_interval
.tv_sec
== 0
737 && usecs
&& usecs
* TIMER_TICKS_PER_SEC
< clocks_min
* 1000000)
741 usecs
*= TIMER_TICKS_PER_SEC
;
742 reload
+= usecs
/ 1000000;
745 expire
= value
->it_value
.tv_sec
* TIMER_TICKS_PER_SEC
;
746 usecs
= value
->it_value
.tv_usec
;
747 if (value
->it_value
.tv_sec
== 0
748 && usecs
* TIMER_TICKS_PER_SEC
< clocks_min
* 1000000)
752 usecs
*= TIMER_TICKS_PER_SEC
;
753 expire
+= usecs
/ 1000000;
758 EnterCriticalSection (crit
);
759 expire_old
= *t_expire
;
760 reload_old
= *t_reload
;
761 if (!(expire
== expire_old
&& reload
== reload_old
))
766 LeaveCriticalSection (crit
);
768 return start_timer_thread (which
);
774 #ifdef HAVE_SETITIMER
775 struct itimerval new_values
, old_values
;
777 new_values
.it_value
.tv_sec
= seconds
;
778 new_values
.it_value
.tv_usec
= 0;
779 new_values
.it_interval
.tv_sec
= new_values
.it_interval
.tv_usec
= 0;
781 if (setitimer (ITIMER_REAL
, &new_values
, &old_values
) < 0)
783 return old_values
.it_value
.tv_sec
;
791 /* Here's an overview of how support for subprocesses and
792 network/serial streams is implemented on MS-Windows.
794 The management of both subprocesses and network/serial streams
795 circles around the child_procs[] array, which can record up to the
796 grand total of MAX_CHILDREN (= 32) of these. (The reasons for the
797 32 limitation will become clear below.) Each member of
798 child_procs[] is a child_process structure, defined on w32.h.
800 A related data structure is the fd_info[] array, which holds twice
801 as many members, 64, and records the information about file
802 descriptors used for communicating with subprocesses and
803 network/serial devices. Each member of the array is the filedesc
804 structure, which records the Windows handle for communications,
805 such as the read end of the pipe to a subprocess, a socket handle,
808 Both these arrays reference each other: there's a member of
809 child_process structure that records the corresponding file
810 descriptor, and there's a member of filedesc structure that holds a
811 pointer to the corresponding child_process.
813 Whenever Emacs starts a subprocess or opens a network/serial
814 stream, the function new_child is called to prepare a new
815 child_process structure. new_child looks for the first vacant slot
816 in the child_procs[] array, initializes it, and starts a "reader
817 thread" that will watch the output of the subprocess/stream and its
818 status. (If no vacant slot can be found, new_child returns a
819 failure indication to its caller, and the higher-level Emacs
820 primitive that called it will then fail with EMFILE or EAGAIN.)
822 The reader thread started by new_child communicates with the main
823 (a.k.a. "Lisp") thread via two event objects and a status, all of
824 them recorded by the members of the child_process structure in
825 child_procs[]. The event objects serve as semaphores between the
826 reader thread and the 'pselect' emulation in sys_select, as follows:
828 . Initially, the reader thread is waiting for the char_consumed
829 event to become signaled by sys_select, which is an indication
830 for the reader thread to go ahead and try reading more stuff
831 from the subprocess/stream.
833 . The reader thread then attempts to read by calling a
834 blocking-read function. When the read call returns, either
835 successfully or with some failure indication, the reader thread
836 updates the status of the read accordingly, and signals the 2nd
837 event object, char_avail, on whose handle sys_select is
838 waiting. This tells sys_select that the file descriptor
839 allocated for the subprocess or the the stream is ready to be
842 When the subprocess exits or the network/serial stream is closed,
843 the reader thread sets the status accordingly and exits. It also
844 exits when the main thread sets the status to STATUS_READ_ERROR
845 and/or the char_avail and char_consumed event handles become NULL;
846 this is how delete_child, called by Emacs when a subprocess or a
847 stream is terminated, terminates the reader thread as part of
848 deleting the child_process object.
850 The sys_select function emulates the Posix 'pselect' function; it
851 is needed because the Windows 'select' function supports only
852 network sockets, while Emacs expects 'pselect' to work for any file
853 descriptor, including pipes and serial streams.
855 When sys_select is called, it uses the information in fd_info[]
856 array to convert the file descriptors which it was asked to watch
857 into Windows handles. In general, the handle to watch is the
858 handle of the char_avail event of the child_process structure that
859 corresponds to the file descriptor. In addition, for subprocesses,
860 sys_select watches one more handle: the handle for the subprocess,
861 so that it could emulate the SIGCHLD signal when the subprocess
864 If file descriptor zero (stdin) doesn't have its bit set in the
865 'rfds' argument to sys_select, the function always watches for
866 keyboard interrupts, to be able to interrupt the wait and return
867 when the user presses C-g.
869 Having collected the handles to watch, sys_select calls
870 WaitForMultipleObjects to wait for any one of them to become
871 signaled. Since WaitForMultipleObjects can only watch up to 64
872 handles, Emacs on Windows is limited to maximum 32 child_process
873 objects (since a subprocess consumes 2 handles to be watched, see
876 When any of the handles become signaled, sys_select does whatever
877 is appropriate for the corresponding child_process object:
879 . If it's a handle to the char_avail event, sys_select marks the
880 corresponding bit in 'rfds', and Emacs will then read from that
883 . If it's a handle to the process, sys_select calls the SIGCHLD
884 handler, to inform Emacs of the fact that the subprocess
887 The waitpid emulation works very similar to sys_select, except that
888 it only watches handles of subprocesses, and doesn't synchronize
889 with the reader thread.
891 Because socket descriptors on Windows are handles, while Emacs
892 expects them to be file descriptors, all low-level I/O functions,
893 such as 'read' and 'write', and all socket operations, like
894 'connect', 'recvfrom', 'accept', etc., are redirected to the
895 corresponding 'sys_*' functions, which must convert a file
896 descriptor to a handle using the fd_info[] array, and then invoke
897 the corresponding Windows API on the handle. Most of these
898 redirected 'sys_*' functions are implemented on w32.c.
900 When the file descriptor was produced by functions such as 'open',
901 the corresponding handle is obtained by calling _get_osfhandle. To
902 produce a file descriptor for a socket handle, which has no file
903 descriptor as far as Windows is concerned, the function
904 socket_to_fd opens the null device; the resulting file descriptor
905 will never be used directly in any I/O API, but serves as an index
906 into the fd_info[] array, where the socket handle is stored. The
907 SOCK_HANDLE macro retrieves the handle when given the file
910 The function sys_kill emulates the Posix 'kill' functionality to
911 terminate other processes. It does that by attaching to the
912 foreground window of the process and sending a Ctrl-C or Ctrl-BREAK
913 signal to the process; if that doesn't work, then it calls
914 TerminateProcess to forcibly terminate the process. Note that this
915 only terminates the immediate process whose PID was passed to
916 sys_kill; it doesn't terminate the child processes of that process.
917 This means, for example, that an Emacs subprocess run through a
918 shell might not be killed, because sys_kill will only terminate the
919 shell. (In practice, however, such problems are very rare.) */
921 /* Defined in <process.h> which conflicts with the local copy */
924 /* Child process management list. */
925 int child_proc_count
= 0;
926 child_process child_procs
[ MAX_CHILDREN
];
928 static DWORD WINAPI
reader_thread (void *arg
);
930 /* Find an unused process slot. */
937 for (cp
= child_procs
+ (child_proc_count
-1); cp
>= child_procs
; cp
--)
938 if (!CHILD_ACTIVE (cp
) && cp
->procinfo
.hProcess
== NULL
)
940 if (child_proc_count
== MAX_CHILDREN
)
943 child_process
*dead_cp
= NULL
;
945 DebPrint (("new_child: No vacant slots, looking for dead processes\n"));
946 for (cp
= child_procs
+ (child_proc_count
-1); cp
>= child_procs
; cp
--)
947 if (!CHILD_ACTIVE (cp
) && cp
->procinfo
.hProcess
)
951 if (!GetExitCodeProcess (cp
->procinfo
.hProcess
, &status
))
953 DebPrint (("new_child.GetExitCodeProcess: error %lu for PID %lu\n",
954 GetLastError (), cp
->procinfo
.dwProcessId
));
955 status
= STILL_ACTIVE
;
957 if (status
!= STILL_ACTIVE
958 || WaitForSingleObject (cp
->procinfo
.hProcess
, 0) == WAIT_OBJECT_0
)
960 DebPrint (("new_child: Freeing slot of dead process %d, fd %d\n",
961 cp
->procinfo
.dwProcessId
, cp
->fd
));
962 CloseHandle (cp
->procinfo
.hProcess
);
963 cp
->procinfo
.hProcess
= NULL
;
964 CloseHandle (cp
->procinfo
.hThread
);
965 cp
->procinfo
.hThread
= NULL
;
966 /* Free up to 2 dead slots at a time, so that if we
967 have a lot of them, they will eventually all be
968 freed when the tornado ends. */
982 if (child_proc_count
== MAX_CHILDREN
)
984 cp
= &child_procs
[child_proc_count
++];
987 /* Last opportunity to avoid leaking handles before we forget them
989 if (cp
->procinfo
.hProcess
)
990 CloseHandle (cp
->procinfo
.hProcess
);
991 if (cp
->procinfo
.hThread
)
992 CloseHandle (cp
->procinfo
.hThread
);
993 memset (cp
, 0, sizeof (*cp
));
996 cp
->procinfo
.hProcess
= NULL
;
997 cp
->status
= STATUS_READ_ERROR
;
999 /* use manual reset event so that select() will function properly */
1000 cp
->char_avail
= CreateEvent (NULL
, TRUE
, FALSE
, NULL
);
1003 cp
->char_consumed
= CreateEvent (NULL
, FALSE
, FALSE
, NULL
);
1004 if (cp
->char_consumed
)
1006 /* The 0x00010000 flag is STACK_SIZE_PARAM_IS_A_RESERVATION.
1007 It means that the 64K stack we are requesting in the 2nd
1008 argument is how much memory should be reserved for the
1009 stack. If we don't use this flag, the memory requested
1010 by the 2nd argument is the amount actually _committed_,
1011 but Windows reserves 8MB of memory for each thread's
1012 stack. (The 8MB figure comes from the -stack
1013 command-line argument we pass to the linker when building
1014 Emacs, but that's because we need a large stack for
1015 Emacs's main thread.) Since we request 2GB of reserved
1016 memory at startup (see w32heap.c), which is close to the
1017 maximum memory available for a 32-bit process on Windows,
1018 the 8MB reservation for each thread causes failures in
1019 starting subprocesses, because we create a thread running
1020 reader_thread for each subprocess. As 8MB of stack is
1021 way too much for reader_thread, forcing Windows to
1022 reserve less wins the day. */
1023 cp
->thrd
= CreateThread (NULL
, 64 * 1024, reader_thread
, cp
,
1034 delete_child (child_process
*cp
)
1038 /* Should not be deleting a child that is still needed. */
1039 for (i
= 0; i
< MAXDESC
; i
++)
1040 if (fd_info
[i
].cp
== cp
)
1043 if (!CHILD_ACTIVE (cp
) && cp
->procinfo
.hProcess
== NULL
)
1046 /* reap thread if necessary */
1051 if (GetExitCodeThread (cp
->thrd
, &rc
) && rc
== STILL_ACTIVE
)
1053 /* let the thread exit cleanly if possible */
1054 cp
->status
= STATUS_READ_ERROR
;
1055 SetEvent (cp
->char_consumed
);
1057 /* We used to forcibly terminate the thread here, but it
1058 is normally unnecessary, and in abnormal cases, the worst that
1059 will happen is we have an extra idle thread hanging around
1060 waiting for the zombie process. */
1061 if (WaitForSingleObject (cp
->thrd
, 1000) != WAIT_OBJECT_0
)
1063 DebPrint (("delete_child.WaitForSingleObject (thread) failed "
1064 "with %lu for fd %ld\n", GetLastError (), cp
->fd
));
1065 TerminateThread (cp
->thrd
, 0);
1069 CloseHandle (cp
->thrd
);
1074 CloseHandle (cp
->char_avail
);
1075 cp
->char_avail
= NULL
;
1077 if (cp
->char_consumed
)
1079 CloseHandle (cp
->char_consumed
);
1080 cp
->char_consumed
= NULL
;
1083 /* update child_proc_count (highest numbered slot in use plus one) */
1084 if (cp
== child_procs
+ child_proc_count
- 1)
1086 for (i
= child_proc_count
-1; i
>= 0; i
--)
1087 if (CHILD_ACTIVE (&child_procs
[i
])
1088 || child_procs
[i
].procinfo
.hProcess
!= NULL
)
1090 child_proc_count
= i
+ 1;
1095 child_proc_count
= 0;
1098 /* Find a child by pid. */
1099 static child_process
*
1100 find_child_pid (DWORD pid
)
1104 for (cp
= child_procs
+ (child_proc_count
-1); cp
>= child_procs
; cp
--)
1105 if ((CHILD_ACTIVE (cp
) || cp
->procinfo
.hProcess
!= NULL
)
1112 release_listen_threads (void)
1116 for (i
= child_proc_count
- 1; i
>= 0; i
--)
1118 if (CHILD_ACTIVE (&child_procs
[i
])
1119 && (fd_info
[child_procs
[i
].fd
].flags
& FILE_LISTEN
))
1120 child_procs
[i
].status
= STATUS_READ_ERROR
;
1124 /* Thread proc for child process and socket reader threads. Each thread
1125 is normally blocked until woken by select() to check for input by
1126 reading one char. When the read completes, char_avail is signaled
1127 to wake up the select emulator and the thread blocks itself again. */
1129 reader_thread (void *arg
)
1134 cp
= (child_process
*)arg
;
1136 /* We have to wait for the go-ahead before we can start */
1138 || WaitForSingleObject (cp
->char_consumed
, INFINITE
) != WAIT_OBJECT_0
1146 if (cp
->fd
>= 0 && (fd_info
[cp
->fd
].flags
& FILE_CONNECT
) != 0)
1147 rc
= _sys_wait_connect (cp
->fd
);
1148 else if (cp
->fd
>= 0 && (fd_info
[cp
->fd
].flags
& FILE_LISTEN
) != 0)
1149 rc
= _sys_wait_accept (cp
->fd
);
1151 rc
= _sys_read_ahead (cp
->fd
);
1153 /* Don't bother waiting for the event if we already have been
1154 told to exit by delete_child. */
1155 if (cp
->status
== STATUS_READ_ERROR
|| !cp
->char_avail
)
1158 /* The name char_avail is a misnomer - it really just means the
1159 read-ahead has completed, whether successfully or not. */
1160 if (!SetEvent (cp
->char_avail
))
1162 DebPrint (("reader_thread.SetEvent(0x%x) failed with %lu for fd %ld (PID %d)\n",
1163 (DWORD_PTR
)cp
->char_avail
, GetLastError (),
1168 if (rc
== STATUS_READ_ERROR
|| rc
== STATUS_CONNECT_FAILED
)
1171 /* If the read died, the child has died so let the thread die */
1172 if (rc
== STATUS_READ_FAILED
)
1175 /* Don't bother waiting for the acknowledge if we already have
1176 been told to exit by delete_child. */
1177 if (cp
->status
== STATUS_READ_ERROR
|| !cp
->char_consumed
)
1180 /* Wait until our input is acknowledged before reading again */
1181 if (WaitForSingleObject (cp
->char_consumed
, INFINITE
) != WAIT_OBJECT_0
)
1183 DebPrint (("reader_thread.WaitForSingleObject failed with "
1184 "%lu for fd %ld\n", GetLastError (), cp
->fd
));
1187 /* delete_child sets status to STATUS_READ_ERROR when it wants
1189 if (cp
->status
== STATUS_READ_ERROR
)
1195 /* To avoid Emacs changing directory, we just record here the
1196 directory the new process should start in. This is set just before
1197 calling sys_spawnve, and is not generally valid at any other time.
1198 Note that this directory's name is UTF-8 encoded. */
1199 static char * process_dir
;
1202 create_child (char *exe
, char *cmdline
, char *env
, int is_gui_app
,
1203 pid_t
* pPid
, child_process
*cp
)
1206 SECURITY_ATTRIBUTES sec_attrs
;
1208 SECURITY_DESCRIPTOR sec_desc
;
1211 char dir
[ MAX_PATH
];
1215 if (cp
== NULL
) emacs_abort ();
1217 memset (&start
, 0, sizeof (start
));
1218 start
.cb
= sizeof (start
);
1221 if (NILP (Vw32_start_process_show_window
) && !is_gui_app
)
1222 start
.dwFlags
= STARTF_USESTDHANDLES
| STARTF_USESHOWWINDOW
;
1224 start
.dwFlags
= STARTF_USESTDHANDLES
;
1225 start
.wShowWindow
= SW_HIDE
;
1227 start
.hStdInput
= GetStdHandle (STD_INPUT_HANDLE
);
1228 start
.hStdOutput
= GetStdHandle (STD_OUTPUT_HANDLE
);
1229 start
.hStdError
= GetStdHandle (STD_ERROR_HANDLE
);
1230 #endif /* HAVE_NTGUI */
1233 /* Explicitly specify no security */
1234 if (!InitializeSecurityDescriptor (&sec_desc
, SECURITY_DESCRIPTOR_REVISION
))
1236 if (!SetSecurityDescriptorDacl (&sec_desc
, TRUE
, NULL
, FALSE
))
1239 sec_attrs
.nLength
= sizeof (sec_attrs
);
1240 sec_attrs
.lpSecurityDescriptor
= NULL
/* &sec_desc */;
1241 sec_attrs
.bInheritHandle
= FALSE
;
1243 filename_to_ansi (process_dir
, dir
);
1244 /* Can't use unixtodos_filename here, since that needs its file name
1245 argument encoded in UTF-8. OTOH, process_dir, which _is_ in
1246 UTF-8, points, to the directory computed by our caller, and we
1247 don't want to modify that, either. */
1248 for (p
= dir
; *p
; p
= CharNextA (p
))
1252 /* CreateProcess handles batch files as exe specially. This special
1253 handling fails when both the batch file and arguments are quoted.
1254 We pass NULL as exe to avoid the special handling. */
1255 if (exe
&& cmdline
[0] == '"' &&
1256 (ext
= strrchr (exe
, '.')) &&
1257 (xstrcasecmp (ext
, ".bat") == 0
1258 || xstrcasecmp (ext
, ".cmd") == 0))
1261 flags
= (!NILP (Vw32_start_process_share_console
)
1262 ? CREATE_NEW_PROCESS_GROUP
1263 : CREATE_NEW_CONSOLE
);
1264 if (NILP (Vw32_start_process_inherit_error_mode
))
1265 flags
|= CREATE_DEFAULT_ERROR_MODE
;
1266 if (!CreateProcessA (exe
, cmdline
, &sec_attrs
, NULL
, TRUE
,
1267 flags
, env
, dir
, &start
, &cp
->procinfo
))
1270 cp
->pid
= (int) cp
->procinfo
.dwProcessId
;
1272 /* Hack for Windows 95, which assigns large (ie negative) pids */
1281 DebPrint (("create_child.CreateProcess failed: %ld\n", GetLastError ()););
1285 /* create_child doesn't know what emacs's file handle will be for waiting
1286 on output from the child, so we need to make this additional call
1287 to register the handle with the process
1288 This way the select emulator knows how to match file handles with
1289 entries in child_procs. */
1291 register_child (pid_t pid
, int fd
)
1295 cp
= find_child_pid ((DWORD
)pid
);
1298 DebPrint (("register_child unable to find pid %lu\n", pid
));
1303 DebPrint (("register_child registered fd %d with pid %lu\n", fd
, pid
));
1308 /* thread is initially blocked until select is called; set status so
1309 that select will release thread */
1310 cp
->status
= STATUS_READ_ACKNOWLEDGED
;
1312 /* attach child_process to fd_info */
1313 if (fd_info
[fd
].cp
!= NULL
)
1315 DebPrint (("register_child: fd_info[%d] apparently in use!\n", fd
));
1319 fd_info
[fd
].cp
= cp
;
1322 /* Called from waitpid when a process exits. */
1324 reap_subprocess (child_process
*cp
)
1326 if (cp
->procinfo
.hProcess
)
1328 /* Reap the process */
1330 /* Process should have already died before we are called. */
1331 if (WaitForSingleObject (cp
->procinfo
.hProcess
, 0) != WAIT_OBJECT_0
)
1332 DebPrint (("reap_subprocess: child for fd %d has not died yet!", cp
->fd
));
1334 CloseHandle (cp
->procinfo
.hProcess
);
1335 cp
->procinfo
.hProcess
= NULL
;
1336 CloseHandle (cp
->procinfo
.hThread
);
1337 cp
->procinfo
.hThread
= NULL
;
1340 /* If cp->fd was not closed yet, we might be still reading the
1341 process output, so don't free its resources just yet. The call
1342 to delete_child on behalf of this subprocess will be made by
1343 sys_read when the subprocess output is fully read. */
1348 /* Wait for a child process specified by PID, or for any of our
1349 existing child processes (if PID is nonpositive) to die. When it
1350 does, close its handle. Return the pid of the process that died
1351 and fill in STATUS if non-NULL. */
1354 waitpid (pid_t pid
, int *status
, int options
)
1356 DWORD active
, retval
;
1358 child_process
*cp
, *cps
[MAX_CHILDREN
];
1359 HANDLE wait_hnd
[MAX_CHILDREN
];
1361 int dont_wait
= (options
& WNOHANG
) != 0;
1364 /* According to Posix:
1366 PID = -1 means status is requested for any child process.
1368 PID > 0 means status is requested for a single child process
1371 PID = 0 means status is requested for any child process whose
1372 process group ID is equal to that of the calling process. But
1373 since Windows has only a limited support for process groups (only
1374 for console processes and only for the purposes of passing
1375 Ctrl-BREAK signal to them), and since we have no documented way
1376 of determining whether a given process belongs to our group, we
1379 PID < -1 means status is requested for any child process whose
1380 process group ID is equal to the absolute value of PID. Again,
1381 since we don't support process groups, we treat that as -1. */
1386 /* We are requested to wait for a specific child. */
1387 for (cp
= child_procs
+ (child_proc_count
-1); cp
>= child_procs
; cp
--)
1389 /* Some child_procs might be sockets; ignore them. Also
1390 ignore subprocesses whose output is not yet completely
1392 if (CHILD_ACTIVE (cp
)
1393 && cp
->procinfo
.hProcess
1402 if (cp
->fd
< 0 || (fd_info
[cp
->fd
].flags
& FILE_AT_EOF
) != 0)
1404 wait_hnd
[nh
] = cp
->procinfo
.hProcess
;
1410 /* PID specifies our subprocess, but its status is not
1417 /* No such child process, or nothing to wait for, so fail. */
1424 for (cp
= child_procs
+ (child_proc_count
-1); cp
>= child_procs
; cp
--)
1426 if (CHILD_ACTIVE (cp
)
1427 && cp
->procinfo
.hProcess
1428 && (cp
->fd
< 0 || (fd_info
[cp
->fd
].flags
& FILE_AT_EOF
) != 0))
1430 wait_hnd
[nh
] = cp
->procinfo
.hProcess
;
1437 /* Nothing to wait on, so fail. */
1446 timeout_ms
= 1000; /* check for quit about once a second. */
1451 active
= WaitForMultipleObjects (nh
, wait_hnd
, FALSE
, timeout_ms
);
1452 } while (active
== WAIT_TIMEOUT
&& !dont_wait
);
1454 if (active
== WAIT_FAILED
)
1459 else if (active
== WAIT_TIMEOUT
&& dont_wait
)
1461 /* PID specifies our subprocess, but it didn't exit yet, so its
1462 status is not yet available. */
1464 DebPrint (("Wait: PID %d not reap yet\n", cp
->pid
));
1468 else if (active
>= WAIT_OBJECT_0
1469 && active
< WAIT_OBJECT_0
+MAXIMUM_WAIT_OBJECTS
)
1471 active
-= WAIT_OBJECT_0
;
1473 else if (active
>= WAIT_ABANDONED_0
1474 && active
< WAIT_ABANDONED_0
+MAXIMUM_WAIT_OBJECTS
)
1476 active
-= WAIT_ABANDONED_0
;
1481 if (!GetExitCodeProcess (wait_hnd
[active
], &retval
))
1483 DebPrint (("Wait.GetExitCodeProcess failed with %lu\n",
1487 if (retval
== STILL_ACTIVE
)
1489 /* Should never happen. */
1490 DebPrint (("Wait.WaitForMultipleObjects returned an active process\n"));
1491 if (pid
> 0 && dont_wait
)
1497 /* Massage the exit code from the process to match the format expected
1498 by the WIFSTOPPED et al macros in syswait.h. Only WIFSIGNALED and
1499 WIFEXITED are supported; WIFSTOPPED doesn't make sense under NT. */
1501 if (retval
== STATUS_CONTROL_C_EXIT
)
1506 if (pid
> 0 && active
!= 0)
1511 DebPrint (("Wait signaled with process pid %d\n", cp
->pid
));
1516 reap_subprocess (cp
);
1521 /* Old versions of w32api headers don't have separate 32-bit and
1522 64-bit defines, but the one they have matches the 32-bit variety. */
1523 #ifndef IMAGE_NT_OPTIONAL_HDR32_MAGIC
1524 # define IMAGE_NT_OPTIONAL_HDR32_MAGIC IMAGE_NT_OPTIONAL_HDR_MAGIC
1525 # define IMAGE_OPTIONAL_HEADER32 IMAGE_OPTIONAL_HEADER
1528 /* Implementation note: This function works with file names encoded in
1529 the current ANSI codepage. */
1531 w32_executable_type (char * filename
,
1533 int * is_cygnus_app
,
1537 file_data executable
;
1541 /* Default values in case we can't tell for sure. */
1542 *is_dos_app
= FALSE
;
1543 *is_cygnus_app
= FALSE
;
1544 *is_msys_app
= FALSE
;
1545 *is_gui_app
= FALSE
;
1547 if (!open_input_file (&executable
, filename
))
1550 p
= strrchr (filename
, '.');
1552 /* We can only identify DOS .com programs from the extension. */
1553 if (p
&& xstrcasecmp (p
, ".com") == 0)
1555 else if (p
&& (xstrcasecmp (p
, ".bat") == 0
1556 || xstrcasecmp (p
, ".cmd") == 0))
1558 /* A DOS shell script - it appears that CreateProcess is happy to
1559 accept this (somewhat surprisingly); presumably it looks at
1560 COMSPEC to determine what executable to actually invoke.
1561 Therefore, we have to do the same here as well. */
1562 /* Actually, I think it uses the program association for that
1563 extension, which is defined in the registry. */
1564 p
= egetenv ("COMSPEC");
1566 retval
= w32_executable_type (p
, is_dos_app
, is_cygnus_app
, is_msys_app
,
1571 /* Look for DOS .exe signature - if found, we must also check that
1572 it isn't really a 16- or 32-bit Windows exe, since both formats
1573 start with a DOS program stub. Note that 16-bit Windows
1574 executables use the OS/2 1.x format. */
1576 IMAGE_DOS_HEADER
* dos_header
;
1577 IMAGE_NT_HEADERS
* nt_header
;
1579 dos_header
= (PIMAGE_DOS_HEADER
) executable
.file_base
;
1580 if (dos_header
->e_magic
!= IMAGE_DOS_SIGNATURE
)
1583 nt_header
= (PIMAGE_NT_HEADERS
) ((unsigned char *) dos_header
+ dos_header
->e_lfanew
);
1585 if ((char *) nt_header
> (char *) dos_header
+ executable
.size
)
1587 /* Some dos headers (pkunzip) have bogus e_lfanew fields. */
1590 else if (nt_header
->Signature
!= IMAGE_NT_SIGNATURE
1591 && LOWORD (nt_header
->Signature
) != IMAGE_OS2_SIGNATURE
)
1595 else if (nt_header
->Signature
== IMAGE_NT_SIGNATURE
)
1597 IMAGE_DATA_DIRECTORY
*data_dir
= NULL
;
1598 if (nt_header
->OptionalHeader
.Magic
== IMAGE_NT_OPTIONAL_HDR32_MAGIC
)
1600 /* Ensure we are using the 32 bit structure. */
1601 IMAGE_OPTIONAL_HEADER32
*opt
1602 = (IMAGE_OPTIONAL_HEADER32
*) &(nt_header
->OptionalHeader
);
1603 data_dir
= opt
->DataDirectory
;
1604 *is_gui_app
= (opt
->Subsystem
== IMAGE_SUBSYSTEM_WINDOWS_GUI
);
1606 /* MingW 3.12 has the required 64 bit structs, but in case older
1607 versions don't, only check 64 bit exes if we know how. */
1608 #ifdef IMAGE_NT_OPTIONAL_HDR64_MAGIC
1609 else if (nt_header
->OptionalHeader
.Magic
1610 == IMAGE_NT_OPTIONAL_HDR64_MAGIC
)
1612 IMAGE_OPTIONAL_HEADER64
*opt
1613 = (IMAGE_OPTIONAL_HEADER64
*) &(nt_header
->OptionalHeader
);
1614 data_dir
= opt
->DataDirectory
;
1615 *is_gui_app
= (opt
->Subsystem
== IMAGE_SUBSYSTEM_WINDOWS_GUI
);
1620 /* Look for Cygwin DLL in the DLL import list. */
1621 IMAGE_DATA_DIRECTORY import_dir
=
1622 data_dir
[IMAGE_DIRECTORY_ENTRY_IMPORT
];
1623 IMAGE_IMPORT_DESCRIPTOR
* imports
=
1624 RVA_TO_PTR (import_dir
.VirtualAddress
,
1625 rva_to_section (import_dir
.VirtualAddress
,
1629 for ( ; imports
->Name
; imports
++)
1631 IMAGE_SECTION_HEADER
* section
=
1632 rva_to_section (imports
->Name
, nt_header
);
1633 char * dllname
= RVA_TO_PTR (imports
->Name
, section
,
1636 /* The exact name of the Cygwin DLL has changed with
1637 various releases, but hopefully this will be
1638 reasonably future-proof. */
1639 if (strncmp (dllname
, "cygwin", 6) == 0)
1641 *is_cygnus_app
= TRUE
;
1644 else if (strncmp (dllname
, "msys-", 5) == 0)
1646 /* This catches both MSYS 1.x and MSYS2
1647 executables (the DLL name is msys-1.0.dll and
1648 msys-2.0.dll, respectively). There doesn't
1649 seem to be a reason to distinguish between
1650 the two, for now. */
1651 *is_msys_app
= TRUE
;
1660 close_file_data (&executable
);
1665 compare_env (const void *strp1
, const void *strp2
)
1667 const char *str1
= *(const char **)strp1
, *str2
= *(const char **)strp2
;
1669 while (*str1
&& *str2
&& *str1
!= '=' && *str2
!= '=')
1671 /* Sort order in command.com/cmd.exe is based on uppercasing
1672 names, so do the same here. */
1673 if (toupper (*str1
) > toupper (*str2
))
1675 else if (toupper (*str1
) < toupper (*str2
))
1680 if (*str1
== '=' && *str2
== '=')
1682 else if (*str1
== '=')
1689 merge_and_sort_env (char **envp1
, char **envp2
, char **new_envp
)
1691 char **optr
, **nptr
;
1703 num
+= optr
- envp2
;
1705 qsort (new_envp
, num
, sizeof (char *), compare_env
);
1710 /* When a new child process is created we need to register it in our list,
1711 so intercept spawn requests. */
1713 sys_spawnve (int mode
, char *cmdname
, char **argv
, char **envp
)
1715 Lisp_Object program
, full
;
1716 char *cmdline
, *env
, *parg
, **targ
;
1720 int is_dos_app
, is_cygnus_app
, is_msys_app
, is_gui_app
;
1722 /* We pass our process ID to our children by setting up an environment
1723 variable in their environment. */
1724 char ppid_env_var_buffer
[64];
1725 char *extra_env
[] = {ppid_env_var_buffer
, NULL
};
1726 /* These are the characters that cause an argument to need quoting.
1727 Arguments with whitespace characters need quoting to prevent the
1728 argument being split into two or more. Arguments with wildcards
1729 are also quoted, for consistency with posix platforms, where wildcards
1730 are not expanded if we run the program directly without a shell.
1731 Some extra whitespace characters need quoting in Cygwin/MSYS programs,
1732 so this list is conditionally modified below. */
1733 char *sepchars
= " \t*?";
1734 /* This is for native w32 apps; modified below for Cygwin/MSUS apps. */
1735 char escape_char
= '\\';
1736 char cmdname_a
[MAX_PATH
];
1738 /* We don't care about the other modes */
1739 if (mode
!= _P_NOWAIT
)
1745 /* Handle executable names without an executable suffix. The caller
1746 already searched exec-path and verified the file is executable,
1747 but start-process doesn't do that for file names that are already
1748 absolute. So we double-check this here, just in case. */
1749 if (faccessat (AT_FDCWD
, cmdname
, X_OK
, AT_EACCESS
) != 0)
1751 struct gcpro gcpro1
;
1753 program
= build_string (cmdname
);
1756 openp (Vexec_path
, program
, Vexec_suffixes
, &full
, make_number (X_OK
), 0);
1763 program
= ENCODE_FILE (full
);
1764 cmdname
= SDATA (program
);
1768 char *p
= alloca (strlen (cmdname
) + 1);
1770 /* Don't change the command name we were passed by our caller
1771 (unixtodos_filename below will destructively mirror forward
1773 cmdname
= strcpy (p
, cmdname
);
1776 /* make sure argv[0] and cmdname are both in DOS format */
1777 unixtodos_filename (cmdname
);
1778 /* argv[0] was encoded by caller using ENCODE_FILE, so it is in
1779 UTF-8. All the other arguments are encoded by ENCODE_SYSTEM or
1780 some such, and are in some ANSI codepage. We need to have
1781 argv[0] encoded in ANSI codepage. */
1782 filename_to_ansi (cmdname
, cmdname_a
);
1783 /* We explicitly require that the command's file name be encodable
1784 in the current ANSI codepage, because we will be invoking it via
1786 if (_mbspbrk (cmdname_a
, "?"))
1791 /* From here on, CMDNAME is an ANSI-encoded string. */
1792 cmdname
= cmdname_a
;
1795 /* Determine whether program is a 16-bit DOS executable, or a 32-bit
1796 Windows executable that is implicitly linked to the Cygnus or
1797 MSYS dll (implying it was compiled with the Cygnus/MSYS GNU
1798 toolchain and hence relies on cygwin.dll or MSYS DLL to parse the
1799 command line - we use this to decide how to escape quote chars in
1800 command line args that must be quoted).
1802 Also determine whether it is a GUI app, so that we don't hide its
1803 initial window unless specifically requested. */
1804 w32_executable_type (cmdname
, &is_dos_app
, &is_cygnus_app
, &is_msys_app
,
1807 /* On Windows 95, if cmdname is a DOS app, we invoke a helper
1808 application to start it by specifying the helper app as cmdname,
1809 while leaving the real app name as argv[0]. */
1814 cmdname
= alloca (MAX_PATH
);
1815 if (egetenv ("CMDPROXY"))
1817 /* Implementation note: since process-environment, where
1818 'egetenv' looks, is encoded in the system codepage, we
1819 don't need to encode the cmdproxy file name if we get it
1820 from the environment. */
1821 strcpy (cmdname
, egetenv ("CMDPROXY"));
1825 char *q
= lispstpcpy (cmdname
,
1826 /* exec-directory needs to be encoded. */
1827 ansi_encode_filename (Vexec_directory
));
1828 /* If we are run from the source tree, use cmdproxy.exe from
1829 the same source tree. */
1830 for (p
= q
- 2; p
> cmdname
; p
= CharPrevA (cmdname
, p
))
1833 if (*p
== '/' && xstrcasecmp (p
, "/lib-src/") == 0)
1834 q
= stpcpy (p
, "/nt/");
1835 strcpy (q
, "cmdproxy.exe");
1838 /* Can't use unixtodos_filename here, since that needs its file
1839 name argument encoded in UTF-8. */
1840 for (p
= cmdname
; *p
; p
= CharNextA (p
))
1845 /* we have to do some conjuring here to put argv and envp into the
1846 form CreateProcess wants... argv needs to be a space separated/null
1847 terminated list of parameters, and envp is a null
1848 separated/double-null terminated list of parameters.
1850 Additionally, zero-length args and args containing whitespace or
1851 quote chars need to be wrapped in double quotes - for this to work,
1852 embedded quotes need to be escaped as well. The aim is to ensure
1853 the child process reconstructs the argv array we start with
1854 exactly, so we treat quotes at the beginning and end of arguments
1857 The w32 GNU-based library from Cygnus doubles quotes to escape
1858 them, while MSVC uses backslash for escaping. (Actually the MSVC
1859 startup code does attempt to recognize doubled quotes and accept
1860 them, but gets it wrong and ends up requiring three quotes to get a
1861 single embedded quote!) So by default we decide whether to use
1862 quote or backslash as the escape character based on whether the
1863 binary is apparently a Cygnus compiled app.
1865 Note that using backslash to escape embedded quotes requires
1866 additional special handling if an embedded quote is already
1867 preceded by backslash, or if an arg requiring quoting ends with
1868 backslash. In such cases, the run of escape characters needs to be
1869 doubled. For consistency, we apply this special handling as long
1870 as the escape character is not quote.
1872 Since we have no idea how large argv and envp are likely to be we
1873 figure out list lengths on the fly and allocate them. */
1875 if (!NILP (Vw32_quote_process_args
))
1878 /* Override escape char by binding w32-quote-process-args to
1879 desired character, or use t for auto-selection. */
1880 if (INTEGERP (Vw32_quote_process_args
))
1881 escape_char
= XINT (Vw32_quote_process_args
);
1883 escape_char
= (is_cygnus_app
|| is_msys_app
) ? '"' : '\\';
1886 /* Cygwin/MSYS apps need quoting a bit more often. */
1887 if (escape_char
== '"')
1888 sepchars
= "\r\n\t\f '";
1896 int need_quotes
= 0;
1897 int escape_char_run
= 0;
1903 if (escape_char
== '"' && *p
== '\\')
1904 /* If it's a Cygwin/MSYS app, \ needs to be escaped. */
1908 /* allow for embedded quotes to be escaped */
1911 /* handle the case where the embedded quote is already escaped */
1912 if (escape_char_run
> 0)
1914 /* To preserve the arg exactly, we need to double the
1915 preceding escape characters (plus adding one to
1916 escape the quote character itself). */
1917 arglen
+= escape_char_run
;
1920 else if (strchr (sepchars
, *p
) != NULL
)
1925 if (*p
== escape_char
&& escape_char
!= '"')
1928 escape_char_run
= 0;
1933 /* handle the case where the arg ends with an escape char - we
1934 must not let the enclosing quote be escaped. */
1935 if (escape_char_run
> 0)
1936 arglen
+= escape_char_run
;
1938 arglen
+= strlen (*targ
++) + 1;
1940 cmdline
= alloca (arglen
);
1946 int need_quotes
= 0;
1954 if ((strchr (sepchars
, *p
) != NULL
) || *p
== '"')
1959 int escape_char_run
= 0;
1965 /* last = p + strlen (p) - 1; */
1968 /* This version does not escape quotes if they occur at the
1969 beginning or end of the arg - this could lead to incorrect
1970 behavior when the arg itself represents a command line
1971 containing quoted args. I believe this was originally done
1972 as a hack to make some things work, before
1973 `w32-quote-process-args' was added. */
1976 if (*p
== '"' && p
> first
&& p
< last
)
1977 *parg
++ = escape_char
; /* escape embedded quotes */
1985 /* double preceding escape chars if any */
1986 while (escape_char_run
> 0)
1988 *parg
++ = escape_char
;
1991 /* escape all quote chars, even at beginning or end */
1992 *parg
++ = escape_char
;
1994 else if (escape_char
== '"' && *p
== '\\')
1998 if (*p
== escape_char
&& escape_char
!= '"')
2001 escape_char_run
= 0;
2003 /* double escape chars before enclosing quote */
2004 while (escape_char_run
> 0)
2006 *parg
++ = escape_char
;
2014 strcpy (parg
, *targ
);
2015 parg
+= strlen (*targ
);
2025 numenv
= 1; /* for end null */
2028 arglen
+= strlen (*targ
++) + 1;
2031 /* extra env vars... */
2032 sprintf (ppid_env_var_buffer
, "EM_PARENT_PROCESS_ID=%lu",
2033 GetCurrentProcessId ());
2034 arglen
+= strlen (ppid_env_var_buffer
) + 1;
2037 /* merge env passed in and extra env into one, and sort it. */
2038 targ
= (char **) alloca (numenv
* sizeof (char *));
2039 merge_and_sort_env (envp
, extra_env
, targ
);
2041 /* concatenate env entries. */
2042 env
= alloca (arglen
);
2046 strcpy (parg
, *targ
);
2047 parg
+= strlen (*targ
++);
2060 /* Now create the process. */
2061 if (!create_child (cmdname
, cmdline
, env
, is_gui_app
, &pid
, cp
))
2071 /* Emulate the select call
2072 Wait for available input on any of the given rfds, or timeout if
2073 a timeout is given and no input is detected
2074 wfds and efds are not supported and must be NULL.
2076 For simplicity, we detect the death of child processes here and
2077 synchronously call the SIGCHLD handler. Since it is possible for
2078 children to be created without a corresponding pipe handle from which
2079 to read output, we wait separately on the process handles as well as
2080 the char_avail events for each process pipe. We only call
2081 wait/reap_process when the process actually terminates.
2083 To reduce the number of places in which Emacs can be hung such that
2084 C-g is not able to interrupt it, we always wait on interrupt_handle
2085 (which is signaled by the input thread when C-g is detected). If we
2086 detect that we were woken up by C-g, we return -1 with errno set to
2087 EINTR as on Unix. */
2089 /* From w32console.c */
2090 extern HANDLE keyboard_handle
;
2092 /* From w32xfns.c */
2093 extern HANDLE interrupt_handle
;
2095 /* From process.c */
2096 extern int proc_buffered_char
[];
2099 sys_select (int nfds
, SELECT_TYPE
*rfds
, SELECT_TYPE
*wfds
, SELECT_TYPE
*efds
,
2100 struct timespec
*timeout
, void *ignored
)
2102 SELECT_TYPE orfds
, owfds
;
2103 DWORD timeout_ms
, start_time
;
2106 child_process
*cp
, *cps
[MAX_CHILDREN
];
2107 HANDLE wait_hnd
[MAXDESC
+ MAX_CHILDREN
];
2108 int fdindex
[MAXDESC
]; /* mapping from wait handles back to descriptors */
2111 timeout
? (timeout
->tv_sec
* 1000 + timeout
->tv_nsec
/ 1000000) : INFINITE
;
2113 /* If the descriptor sets are NULL but timeout isn't, then just Sleep. */
2114 if (rfds
== NULL
&& wfds
== NULL
&& efds
== NULL
&& timeout
!= NULL
)
2120 /* Otherwise, we only handle rfds and wfds, so fail otherwise. */
2121 if ((rfds
== NULL
&& wfds
== NULL
) || efds
!= NULL
)
2143 /* If interrupt_handle is available and valid, always wait on it, to
2144 detect C-g (quit). */
2146 if (interrupt_handle
&& interrupt_handle
!= INVALID_HANDLE_VALUE
)
2148 wait_hnd
[0] = interrupt_handle
;
2153 /* Build a list of pipe handles to wait on. */
2154 for (i
= 0; i
< nfds
; i
++)
2155 if (FD_ISSET (i
, &orfds
) || FD_ISSET (i
, &owfds
))
2159 if (keyboard_handle
)
2161 /* Handle stdin specially */
2162 wait_hnd
[nh
] = keyboard_handle
;
2167 /* Check for any emacs-generated input in the queue since
2168 it won't be detected in the wait */
2169 if (rfds
&& detect_input_pending ())
2174 else if (noninteractive
)
2176 if (handle_file_notifications (NULL
))
2182 /* Child process and socket/comm port input. */
2184 if (FD_ISSET (i
, &owfds
)
2186 && (fd_info
[i
].flags
&& FILE_CONNECT
) == 0)
2188 DebPrint (("sys_select: fd %d is in wfds, but FILE_CONNECT is reset!\n", i
));
2193 int current_status
= cp
->status
;
2195 if (current_status
== STATUS_READ_ACKNOWLEDGED
)
2197 /* Tell reader thread which file handle to use. */
2199 /* Zero out the error code. */
2201 /* Wake up the reader thread for this process */
2202 cp
->status
= STATUS_READ_READY
;
2203 if (!SetEvent (cp
->char_consumed
))
2204 DebPrint (("sys_select.SetEvent failed with "
2205 "%lu for fd %ld\n", GetLastError (), i
));
2208 #ifdef CHECK_INTERLOCK
2209 /* slightly crude cross-checking of interlock between threads */
2211 current_status
= cp
->status
;
2212 if (WaitForSingleObject (cp
->char_avail
, 0) == WAIT_OBJECT_0
)
2214 /* char_avail has been signaled, so status (which may
2215 have changed) should indicate read has completed
2216 but has not been acknowledged. */
2217 current_status
= cp
->status
;
2218 if (current_status
!= STATUS_READ_SUCCEEDED
2219 && current_status
!= STATUS_READ_FAILED
)
2220 DebPrint (("char_avail set, but read not completed: status %d\n",
2225 /* char_avail has not been signaled, so status should
2226 indicate that read is in progress; small possibility
2227 that read has completed but event wasn't yet signaled
2228 when we tested it (because a context switch occurred
2229 or if running on separate CPUs). */
2230 if (current_status
!= STATUS_READ_READY
2231 && current_status
!= STATUS_READ_IN_PROGRESS
2232 && current_status
!= STATUS_READ_SUCCEEDED
2233 && current_status
!= STATUS_READ_FAILED
)
2234 DebPrint (("char_avail reset, but read status is bad: %d\n",
2238 wait_hnd
[nh
] = cp
->char_avail
;
2240 if (!wait_hnd
[nh
]) emacs_abort ();
2243 DebPrint (("select waiting on child %d fd %d\n",
2244 cp
-child_procs
, i
));
2249 /* Unable to find something to wait on for this fd, skip */
2251 /* Note that this is not a fatal error, and can in fact
2252 happen in unusual circumstances. Specifically, if
2253 sys_spawnve fails, eg. because the program doesn't
2254 exist, and debug-on-error is t so Fsignal invokes a
2255 nested input loop, then the process output pipe is
2256 still included in input_wait_mask with no child_proc
2257 associated with it. (It is removed when the debugger
2258 exits the nested input loop and the error is thrown.) */
2260 DebPrint (("sys_select: fd %ld is invalid! ignoring\n", i
));
2266 /* Add handles of child processes. */
2268 for (cp
= child_procs
+ (child_proc_count
-1); cp
>= child_procs
; cp
--)
2269 /* Some child_procs might be sockets; ignore them. Also some
2270 children may have died already, but we haven't finished reading
2271 the process output; ignore them too. */
2272 if ((CHILD_ACTIVE (cp
) && cp
->procinfo
.hProcess
)
2274 || (fd_info
[cp
->fd
].flags
& FILE_SEND_SIGCHLD
) == 0
2275 || (fd_info
[cp
->fd
].flags
& FILE_AT_EOF
) != 0)
2278 wait_hnd
[nh
+ nc
] = cp
->procinfo
.hProcess
;
2283 /* Nothing to look for, so we didn't find anything */
2290 if (handle_file_notifications (NULL
))
2296 start_time
= GetTickCount ();
2298 /* Wait for input or child death to be signaled. If user input is
2299 allowed, then also accept window messages. */
2300 if (FD_ISSET (0, &orfds
))
2301 active
= MsgWaitForMultipleObjects (nh
+ nc
, wait_hnd
, FALSE
, timeout_ms
,
2304 active
= WaitForMultipleObjects (nh
+ nc
, wait_hnd
, FALSE
, timeout_ms
);
2306 if (active
== WAIT_FAILED
)
2308 DebPrint (("select.WaitForMultipleObjects (%d, %lu) failed with %lu\n",
2309 nh
+ nc
, timeout_ms
, GetLastError ()));
2310 /* don't return EBADF - this causes wait_reading_process_output to
2311 abort; WAIT_FAILED is returned when single-stepping under
2312 Windows 95 after switching thread focus in debugger, and
2313 possibly at other times. */
2317 else if (active
== WAIT_TIMEOUT
)
2321 if (handle_file_notifications (NULL
))
2326 else if (active
>= WAIT_OBJECT_0
2327 && active
< WAIT_OBJECT_0
+MAXIMUM_WAIT_OBJECTS
)
2329 active
-= WAIT_OBJECT_0
;
2331 else if (active
>= WAIT_ABANDONED_0
2332 && active
< WAIT_ABANDONED_0
+MAXIMUM_WAIT_OBJECTS
)
2334 active
-= WAIT_ABANDONED_0
;
2339 /* Loop over all handles after active (now officially documented as
2340 being the first signaled handle in the array). We do this to
2341 ensure fairness, so that all channels with data available will be
2342 processed - otherwise higher numbered channels could be starved. */
2345 if (active
== nh
+ nc
)
2347 /* There are messages in the lisp thread's queue; we must
2348 drain the queue now to ensure they are processed promptly,
2349 because if we don't do so, we will not be woken again until
2350 further messages arrive.
2352 NB. If ever we allow window message procedures to callback
2353 into lisp, we will need to ensure messages are dispatched
2354 at a safe time for lisp code to be run (*), and we may also
2355 want to provide some hooks in the dispatch loop to cater
2356 for modeless dialogs created by lisp (ie. to register
2357 window handles to pass to IsDialogMessage).
2359 (*) Note that MsgWaitForMultipleObjects above is an
2360 internal dispatch point for messages that are sent to
2361 windows created by this thread. */
2362 if (drain_message_queue ()
2363 /* If drain_message_queue returns non-zero, that means
2364 we received a WM_EMACS_FILENOTIFY message. If this
2365 is a TTY frame, we must signal the caller that keyboard
2366 input is available, so that w32_console_read_socket
2367 will be called to pick up the notifications. If we
2368 don't do that, file notifications will only work when
2369 the Emacs TTY frame has focus. */
2370 && FRAME_TERMCAP_P (SELECTED_FRAME ())
2371 /* they asked for stdin reads */
2372 && FD_ISSET (0, &orfds
)
2373 /* the stdin handle is valid */
2381 else if (active
>= nh
)
2383 cp
= cps
[active
- nh
];
2385 /* We cannot always signal SIGCHLD immediately; if we have not
2386 finished reading the process output, we must delay sending
2387 SIGCHLD until we do. */
2389 if (cp
->fd
>= 0 && (fd_info
[cp
->fd
].flags
& FILE_AT_EOF
) == 0)
2390 fd_info
[cp
->fd
].flags
|= FILE_SEND_SIGCHLD
;
2391 /* SIG_DFL for SIGCHLD is ignored */
2392 else if (sig_handlers
[SIGCHLD
] != SIG_DFL
&&
2393 sig_handlers
[SIGCHLD
] != SIG_IGN
)
2396 DebPrint (("select calling SIGCHLD handler for pid %d\n",
2399 sig_handlers
[SIGCHLD
] (SIGCHLD
);
2402 else if (fdindex
[active
] == -1)
2404 /* Quit (C-g) was detected. */
2408 else if (rfds
&& fdindex
[active
] == 0)
2410 /* Keyboard input available */
2416 /* Must be a socket or pipe - read ahead should have
2417 completed, either succeeding or failing. If this handle
2418 was waiting for an async 'connect', reset the connect
2419 flag, so it could read from now on. */
2420 if (wfds
&& (fd_info
[fdindex
[active
]].flags
& FILE_CONNECT
) != 0)
2422 cp
= fd_info
[fdindex
[active
]].cp
;
2425 /* Don't reset the FILE_CONNECT bit and don't
2426 acknowledge the read if the status is
2427 STATUS_CONNECT_FAILED or some other
2428 failure. That's because the thread exits in those
2429 cases, so it doesn't need the ACK, and we want to
2430 keep the FILE_CONNECT bit as evidence that the
2431 connect failed, to be checked in sys_read. */
2432 if (cp
->status
== STATUS_READ_SUCCEEDED
)
2434 fd_info
[cp
->fd
].flags
&= ~FILE_CONNECT
;
2435 cp
->status
= STATUS_READ_ACKNOWLEDGED
;
2437 ResetEvent (cp
->char_avail
);
2439 FD_SET (fdindex
[active
], wfds
);
2442 FD_SET (fdindex
[active
], rfds
);
2446 /* Even though wait_reading_process_output only reads from at most
2447 one channel, we must process all channels here so that we reap
2448 all children that have died. */
2449 while (++active
< nh
+ nc
)
2450 if (WaitForSingleObject (wait_hnd
[active
], 0) == WAIT_OBJECT_0
)
2452 } while (active
< nh
+ nc
);
2456 if (handle_file_notifications (NULL
))
2460 /* If no input has arrived and timeout hasn't expired, wait again. */
2463 DWORD elapsed
= GetTickCount () - start_time
;
2465 if (timeout_ms
> elapsed
) /* INFINITE is MAX_UINT */
2467 if (timeout_ms
!= INFINITE
)
2468 timeout_ms
-= elapsed
;
2469 goto count_children
;
2476 /* Substitute for certain kill () operations */
2478 static BOOL CALLBACK
2479 find_child_console (HWND hwnd
, LPARAM arg
)
2481 child_process
* cp
= (child_process
*) arg
;
2484 GetWindowThreadProcessId (hwnd
, &process_id
);
2485 if (process_id
== cp
->procinfo
.dwProcessId
)
2487 char window_class
[32];
2489 GetClassName (hwnd
, window_class
, sizeof (window_class
));
2490 if (strcmp (window_class
,
2491 (os_subtype
== OS_9X
)
2493 : "ConsoleWindowClass") == 0)
2503 /* Emulate 'kill', but only for other processes. */
2505 sys_kill (pid_t pid
, int sig
)
2509 int need_to_free
= 0;
2512 /* Each process is in its own process group. */
2516 /* Only handle signals that will result in the process dying */
2518 && sig
!= SIGINT
&& sig
!= SIGKILL
&& sig
!= SIGQUIT
&& sig
!= SIGHUP
)
2526 /* It will take _some_ time before PID 4 or less on Windows will
2533 proc_hand
= OpenProcess (PROCESS_QUERY_INFORMATION
, 0, pid
);
2534 if (proc_hand
== NULL
)
2536 DWORD err
= GetLastError ();
2540 case ERROR_ACCESS_DENIED
: /* existing process, but access denied */
2543 case ERROR_INVALID_PARAMETER
: /* process PID does not exist */
2549 CloseHandle (proc_hand
);
2553 cp
= find_child_pid (pid
);
2556 /* We were passed a PID of something other than our subprocess.
2557 If that is our own PID, we will send to ourself a message to
2558 close the selected frame, which does not necessarily
2559 terminates Emacs. But then we are not supposed to call
2560 sys_kill with our own PID. */
2561 proc_hand
= OpenProcess (PROCESS_TERMINATE
, 0, pid
);
2562 if (proc_hand
== NULL
)
2571 proc_hand
= cp
->procinfo
.hProcess
;
2572 pid
= cp
->procinfo
.dwProcessId
;
2574 /* Try to locate console window for process. */
2575 EnumWindows (find_child_console
, (LPARAM
) cp
);
2578 if (sig
== SIGINT
|| sig
== SIGQUIT
)
2580 if (NILP (Vw32_start_process_share_console
) && cp
&& cp
->hwnd
)
2582 BYTE control_scan_code
= (BYTE
) MapVirtualKey (VK_CONTROL
, 0);
2583 /* Fake Ctrl-C for SIGINT, and Ctrl-Break for SIGQUIT. */
2584 BYTE vk_break_code
= (sig
== SIGINT
) ? 'C' : VK_CANCEL
;
2585 BYTE break_scan_code
= (BYTE
) MapVirtualKey (vk_break_code
, 0);
2586 HWND foreground_window
;
2588 if (break_scan_code
== 0)
2590 /* Fake Ctrl-C for SIGQUIT if we can't manage Ctrl-Break. */
2591 vk_break_code
= 'C';
2592 break_scan_code
= (BYTE
) MapVirtualKey (vk_break_code
, 0);
2595 foreground_window
= GetForegroundWindow ();
2596 if (foreground_window
)
2598 /* NT 5.0, and apparently also Windows 98, will not allow
2599 a Window to be set to foreground directly without the
2600 user's involvement. The workaround is to attach
2601 ourselves to the thread that owns the foreground
2602 window, since that is the only thread that can set the
2603 foreground window. */
2604 DWORD foreground_thread
, child_thread
;
2606 GetWindowThreadProcessId (foreground_window
, NULL
);
2607 if (foreground_thread
== GetCurrentThreadId ()
2608 || !AttachThreadInput (GetCurrentThreadId (),
2609 foreground_thread
, TRUE
))
2610 foreground_thread
= 0;
2612 child_thread
= GetWindowThreadProcessId (cp
->hwnd
, NULL
);
2613 if (child_thread
== GetCurrentThreadId ()
2614 || !AttachThreadInput (GetCurrentThreadId (),
2615 child_thread
, TRUE
))
2618 /* Set the foreground window to the child. */
2619 if (SetForegroundWindow (cp
->hwnd
))
2621 /* Generate keystrokes as if user had typed Ctrl-Break or
2623 keybd_event (VK_CONTROL
, control_scan_code
, 0, 0);
2624 keybd_event (vk_break_code
, break_scan_code
,
2625 (vk_break_code
== 'C' ? 0 : KEYEVENTF_EXTENDEDKEY
), 0);
2626 keybd_event (vk_break_code
, break_scan_code
,
2627 (vk_break_code
== 'C' ? 0 : KEYEVENTF_EXTENDEDKEY
)
2628 | KEYEVENTF_KEYUP
, 0);
2629 keybd_event (VK_CONTROL
, control_scan_code
,
2630 KEYEVENTF_KEYUP
, 0);
2632 /* Sleep for a bit to give time for Emacs frame to respond
2633 to focus change events (if Emacs was active app). */
2636 SetForegroundWindow (foreground_window
);
2638 /* Detach from the foreground and child threads now that
2639 the foreground switching is over. */
2640 if (foreground_thread
)
2641 AttachThreadInput (GetCurrentThreadId (),
2642 foreground_thread
, FALSE
);
2644 AttachThreadInput (GetCurrentThreadId (),
2645 child_thread
, FALSE
);
2648 /* Ctrl-Break is NT equivalent of SIGINT. */
2649 else if (!GenerateConsoleCtrlEvent (CTRL_BREAK_EVENT
, pid
))
2651 DebPrint (("sys_kill.GenerateConsoleCtrlEvent return %d "
2652 "for pid %lu\n", GetLastError (), pid
));
2659 if (NILP (Vw32_start_process_share_console
) && cp
&& cp
->hwnd
)
2662 if (os_subtype
== OS_9X
)
2665 Another possibility is to try terminating the VDM out-right by
2666 calling the Shell VxD (id 0x17) V86 interface, function #4
2667 "SHELL_Destroy_VM", ie.
2673 First need to determine the current VM handle, and then arrange for
2674 the shellapi call to be made from the system vm (by using
2675 Switch_VM_and_callback).
2677 Could try to invoke DestroyVM through CallVxD.
2681 /* On Windows 95, posting WM_QUIT causes the 16-bit subsystem
2682 to hang when cmdproxy is used in conjunction with
2683 command.com for an interactive shell. Posting
2684 WM_CLOSE pops up a dialog that, when Yes is selected,
2685 does the same thing. TerminateProcess is also less
2686 than ideal in that subprocesses tend to stick around
2687 until the machine is shutdown, but at least it
2688 doesn't freeze the 16-bit subsystem. */
2689 PostMessage (cp
->hwnd
, WM_QUIT
, 0xff, 0);
2691 if (!TerminateProcess (proc_hand
, 0xff))
2693 DebPrint (("sys_kill.TerminateProcess returned %d "
2694 "for pid %lu\n", GetLastError (), pid
));
2701 PostMessage (cp
->hwnd
, WM_CLOSE
, 0, 0);
2703 /* Kill the process. On W32 this doesn't kill child processes
2704 so it doesn't work very well for shells which is why it's not
2705 used in every case. */
2706 else if (!TerminateProcess (proc_hand
, 0xff))
2708 DebPrint (("sys_kill.TerminateProcess returned %d "
2709 "for pid %lu\n", GetLastError (), pid
));
2716 CloseHandle (proc_hand
);
2721 /* The following two routines are used to manipulate stdin, stdout, and
2722 stderr of our child processes.
2724 Assuming that in, out, and err are *not* inheritable, we make them
2725 stdin, stdout, and stderr of the child as follows:
2727 - Save the parent's current standard handles.
2728 - Set the std handles to inheritable duplicates of the ones being passed in.
2729 (Note that _get_osfhandle() is an io.h procedure that retrieves the
2730 NT file handle for a crt file descriptor.)
2731 - Spawn the child, which inherits in, out, and err as stdin,
2732 stdout, and stderr. (see Spawnve)
2733 - Close the std handles passed to the child.
2734 - Reset the parent's standard handles to the saved handles.
2735 (see reset_standard_handles)
2736 We assume that the caller closes in, out, and err after calling us. */
2739 prepare_standard_handles (int in
, int out
, int err
, HANDLE handles
[3])
2742 HANDLE newstdin
, newstdout
, newstderr
;
2744 parent
= GetCurrentProcess ();
2746 handles
[0] = GetStdHandle (STD_INPUT_HANDLE
);
2747 handles
[1] = GetStdHandle (STD_OUTPUT_HANDLE
);
2748 handles
[2] = GetStdHandle (STD_ERROR_HANDLE
);
2750 /* make inheritable copies of the new handles */
2751 if (!DuplicateHandle (parent
,
2752 (HANDLE
) _get_osfhandle (in
),
2757 DUPLICATE_SAME_ACCESS
))
2758 report_file_error ("Duplicating input handle for child", Qnil
);
2760 if (!DuplicateHandle (parent
,
2761 (HANDLE
) _get_osfhandle (out
),
2766 DUPLICATE_SAME_ACCESS
))
2767 report_file_error ("Duplicating output handle for child", Qnil
);
2769 if (!DuplicateHandle (parent
,
2770 (HANDLE
) _get_osfhandle (err
),
2775 DUPLICATE_SAME_ACCESS
))
2776 report_file_error ("Duplicating error handle for child", Qnil
);
2778 /* and store them as our std handles */
2779 if (!SetStdHandle (STD_INPUT_HANDLE
, newstdin
))
2780 report_file_error ("Changing stdin handle", Qnil
);
2782 if (!SetStdHandle (STD_OUTPUT_HANDLE
, newstdout
))
2783 report_file_error ("Changing stdout handle", Qnil
);
2785 if (!SetStdHandle (STD_ERROR_HANDLE
, newstderr
))
2786 report_file_error ("Changing stderr handle", Qnil
);
2790 reset_standard_handles (int in
, int out
, int err
, HANDLE handles
[3])
2792 /* close the duplicated handles passed to the child */
2793 CloseHandle (GetStdHandle (STD_INPUT_HANDLE
));
2794 CloseHandle (GetStdHandle (STD_OUTPUT_HANDLE
));
2795 CloseHandle (GetStdHandle (STD_ERROR_HANDLE
));
2797 /* now restore parent's saved std handles */
2798 SetStdHandle (STD_INPUT_HANDLE
, handles
[0]);
2799 SetStdHandle (STD_OUTPUT_HANDLE
, handles
[1]);
2800 SetStdHandle (STD_ERROR_HANDLE
, handles
[2]);
2804 set_process_dir (char * dir
)
2809 /* To avoid problems with winsock implementations that work over dial-up
2810 connections causing or requiring a connection to exist while Emacs is
2811 running, Emacs no longer automatically loads winsock on startup if it
2812 is present. Instead, it will be loaded when open-network-stream is
2815 To allow full control over when winsock is loaded, we provide these
2816 two functions to dynamically load and unload winsock. This allows
2817 dial-up users to only be connected when they actually need to use
2821 extern HANDLE winsock_lib
;
2822 extern BOOL
term_winsock (void);
2823 extern BOOL
init_winsock (int load_now
);
2825 DEFUN ("w32-has-winsock", Fw32_has_winsock
, Sw32_has_winsock
, 0, 1, 0,
2826 doc
: /* Test for presence of the Windows socket library `winsock'.
2827 Returns non-nil if winsock support is present, nil otherwise.
2829 If the optional argument LOAD-NOW is non-nil, the winsock library is
2830 also loaded immediately if not already loaded. If winsock is loaded,
2831 the winsock local hostname is returned (since this may be different from
2832 the value of `system-name' and should supplant it), otherwise t is
2833 returned to indicate winsock support is present. */)
2834 (Lisp_Object load_now
)
2838 have_winsock
= init_winsock (!NILP (load_now
));
2841 if (winsock_lib
!= NULL
)
2843 /* Return new value for system-name. The best way to do this
2844 is to call init_system_name, saving and restoring the
2845 original value to avoid side-effects. */
2846 Lisp_Object orig_hostname
= Vsystem_name
;
2847 Lisp_Object hostname
;
2849 init_system_name ();
2850 hostname
= Vsystem_name
;
2851 Vsystem_name
= orig_hostname
;
2859 DEFUN ("w32-unload-winsock", Fw32_unload_winsock
, Sw32_unload_winsock
,
2861 doc
: /* Unload the Windows socket library `winsock' if loaded.
2862 This is provided to allow dial-up socket connections to be disconnected
2863 when no longer needed. Returns nil without unloading winsock if any
2864 socket connections still exist. */)
2867 return term_winsock () ? Qt
: Qnil
;
2871 /* Some miscellaneous functions that are Windows specific, but not GUI
2872 specific (ie. are applicable in terminal or batch mode as well). */
2874 DEFUN ("w32-short-file-name", Fw32_short_file_name
, Sw32_short_file_name
, 1, 1, 0,
2875 doc
: /* Return the short file name version (8.3) of the full path of FILENAME.
2876 If FILENAME does not exist, return nil.
2877 All path elements in FILENAME are converted to their short names. */)
2878 (Lisp_Object filename
)
2880 char shortname
[MAX_PATH
];
2882 CHECK_STRING (filename
);
2884 /* first expand it. */
2885 filename
= Fexpand_file_name (filename
, Qnil
);
2887 /* luckily, this returns the short version of each element in the path. */
2888 if (w32_get_short_filename (SDATA (ENCODE_FILE (filename
)),
2889 shortname
, MAX_PATH
) == 0)
2892 dostounix_filename (shortname
);
2894 /* No need to DECODE_FILE, because 8.3 names are pure ASCII. */
2895 return build_string (shortname
);
2899 DEFUN ("w32-long-file-name", Fw32_long_file_name
, Sw32_long_file_name
,
2901 doc
: /* Return the long file name version of the full path of FILENAME.
2902 If FILENAME does not exist, return nil.
2903 All path elements in FILENAME are converted to their long names. */)
2904 (Lisp_Object filename
)
2906 char longname
[ MAX_UTF8_PATH
];
2909 CHECK_STRING (filename
);
2911 if (SBYTES (filename
) == 2
2912 && *(SDATA (filename
) + 1) == ':')
2915 /* first expand it. */
2916 filename
= Fexpand_file_name (filename
, Qnil
);
2918 if (!w32_get_long_filename (SDATA (ENCODE_FILE (filename
)), longname
,
2922 dostounix_filename (longname
);
2924 /* If we were passed only a drive, make sure that a slash is not appended
2925 for consistency with directories. Allow for drive mapping via SUBST
2926 in case expand-file-name is ever changed to expand those. */
2927 if (drive_only
&& longname
[1] == ':' && longname
[2] == '/' && !longname
[3])
2930 return DECODE_FILE (build_unibyte_string (longname
));
2933 DEFUN ("w32-set-process-priority", Fw32_set_process_priority
,
2934 Sw32_set_process_priority
, 2, 2, 0,
2935 doc
: /* Set the priority of PROCESS to PRIORITY.
2936 If PROCESS is nil, the priority of Emacs is changed, otherwise the
2937 priority of the process whose pid is PROCESS is changed.
2938 PRIORITY should be one of the symbols high, normal, or low;
2939 any other symbol will be interpreted as normal.
2941 If successful, the return value is t, otherwise nil. */)
2942 (Lisp_Object process
, Lisp_Object priority
)
2944 HANDLE proc_handle
= GetCurrentProcess ();
2945 DWORD priority_class
= NORMAL_PRIORITY_CLASS
;
2946 Lisp_Object result
= Qnil
;
2948 CHECK_SYMBOL (priority
);
2950 if (!NILP (process
))
2955 CHECK_NUMBER (process
);
2957 /* Allow pid to be an internally generated one, or one obtained
2958 externally. This is necessary because real pids on Windows 95 are
2961 pid
= XINT (process
);
2962 cp
= find_child_pid (pid
);
2964 pid
= cp
->procinfo
.dwProcessId
;
2966 proc_handle
= OpenProcess (PROCESS_SET_INFORMATION
, FALSE
, pid
);
2969 if (EQ (priority
, Qhigh
))
2970 priority_class
= HIGH_PRIORITY_CLASS
;
2971 else if (EQ (priority
, Qlow
))
2972 priority_class
= IDLE_PRIORITY_CLASS
;
2974 if (proc_handle
!= NULL
)
2976 if (SetPriorityClass (proc_handle
, priority_class
))
2978 if (!NILP (process
))
2979 CloseHandle (proc_handle
);
2985 DEFUN ("w32-application-type", Fw32_application_type
,
2986 Sw32_application_type
, 1, 1, 0,
2987 doc
: /* Return the type of an MS-Windows PROGRAM.
2989 Knowing the type of an executable could be useful for formatting
2990 file names passed to it or for quoting its command-line arguments.
2992 PROGRAM should specify an executable file, including the extension.
2994 The value is one of the following:
2996 `dos' -- a DOS .com program or some other non-PE executable
2997 `cygwin' -- a Cygwin program that depends on Cygwin DLL
2998 `msys' -- an MSYS 1.x or MSYS2 program
2999 `w32-native' -- a native Windows application
3000 `unknown' -- a file that doesn't exist, or cannot be open, or whose
3001 name is not encodable in the current ANSI codepage.
3003 Note that for .bat and .cmd batch files the function returns the type
3004 of their command interpreter, as specified by the \"COMSPEC\"
3005 environment variable.
3007 This function returns `unknown' for programs whose file names
3008 include characters not supported by the current ANSI codepage, as
3009 such programs cannot be invoked by Emacs anyway. */)
3010 (Lisp_Object program
)
3012 int is_dos_app
, is_cygwin_app
, is_msys_app
, dummy
;
3013 Lisp_Object encoded_progname
;
3014 char *progname
, progname_a
[MAX_PATH
];
3016 program
= Fexpand_file_name (program
, Qnil
);
3017 encoded_progname
= ENCODE_FILE (program
);
3018 progname
= SDATA (encoded_progname
);
3019 unixtodos_filename (progname
);
3020 filename_to_ansi (progname
, progname_a
);
3021 /* Reject file names that cannot be encoded in the current ANSI
3023 if (_mbspbrk (progname_a
, "?"))
3026 if (w32_executable_type (progname_a
, &is_dos_app
, &is_cygwin_app
,
3027 &is_msys_app
, &dummy
) != 0)
3038 #ifdef HAVE_LANGINFO_CODESET
3039 /* Emulation of nl_langinfo. Used in fns.c:Flocale_info. */
3041 nl_langinfo (nl_item item
)
3043 /* Conversion of Posix item numbers to their Windows equivalents. */
3044 static const LCTYPE w32item
[] = {
3045 LOCALE_IDEFAULTANSICODEPAGE
,
3046 LOCALE_SDAYNAME1
, LOCALE_SDAYNAME2
, LOCALE_SDAYNAME3
,
3047 LOCALE_SDAYNAME4
, LOCALE_SDAYNAME5
, LOCALE_SDAYNAME6
, LOCALE_SDAYNAME7
,
3048 LOCALE_SMONTHNAME1
, LOCALE_SMONTHNAME2
, LOCALE_SMONTHNAME3
,
3049 LOCALE_SMONTHNAME4
, LOCALE_SMONTHNAME5
, LOCALE_SMONTHNAME6
,
3050 LOCALE_SMONTHNAME7
, LOCALE_SMONTHNAME8
, LOCALE_SMONTHNAME9
,
3051 LOCALE_SMONTHNAME10
, LOCALE_SMONTHNAME11
, LOCALE_SMONTHNAME12
3054 static char *nl_langinfo_buf
= NULL
;
3055 static int nl_langinfo_len
= 0;
3057 if (nl_langinfo_len
<= 0)
3058 nl_langinfo_buf
= xmalloc (nl_langinfo_len
= 1);
3060 if (item
< 0 || item
>= _NL_NUM
)
3061 nl_langinfo_buf
[0] = 0;
3064 LCID cloc
= GetThreadLocale ();
3065 int need_len
= GetLocaleInfo (cloc
, w32item
[item
] | LOCALE_USE_CP_ACP
,
3069 nl_langinfo_buf
[0] = 0;
3072 if (item
== CODESET
)
3074 need_len
+= 2; /* for the "cp" prefix */
3075 if (need_len
< 8) /* for the case we call GetACP */
3078 if (nl_langinfo_len
<= need_len
)
3079 nl_langinfo_buf
= xrealloc (nl_langinfo_buf
,
3080 nl_langinfo_len
= need_len
);
3081 if (!GetLocaleInfo (cloc
, w32item
[item
] | LOCALE_USE_CP_ACP
,
3082 nl_langinfo_buf
, nl_langinfo_len
))
3083 nl_langinfo_buf
[0] = 0;
3084 else if (item
== CODESET
)
3086 if (strcmp (nl_langinfo_buf
, "0") == 0 /* CP_ACP */
3087 || strcmp (nl_langinfo_buf
, "1") == 0) /* CP_OEMCP */
3088 sprintf (nl_langinfo_buf
, "cp%u", GetACP ());
3091 memmove (nl_langinfo_buf
+ 2, nl_langinfo_buf
,
3092 strlen (nl_langinfo_buf
) + 1);
3093 nl_langinfo_buf
[0] = 'c';
3094 nl_langinfo_buf
[1] = 'p';
3099 return nl_langinfo_buf
;
3101 #endif /* HAVE_LANGINFO_CODESET */
3103 DEFUN ("w32-get-locale-info", Fw32_get_locale_info
,
3104 Sw32_get_locale_info
, 1, 2, 0,
3105 doc
: /* Return information about the Windows locale LCID.
3106 By default, return a three letter locale code which encodes the default
3107 language as the first two characters, and the country or regional variant
3108 as the third letter. For example, ENU refers to `English (United States)',
3109 while ENC means `English (Canadian)'.
3111 If the optional argument LONGFORM is t, the long form of the locale
3112 name is returned, e.g. `English (United States)' instead; if LONGFORM
3113 is a number, it is interpreted as an LCTYPE constant and the corresponding
3114 locale information is returned.
3116 If LCID (a 16-bit number) is not a valid locale, the result is nil. */)
3117 (Lisp_Object lcid
, Lisp_Object longform
)
3121 char abbrev_name
[32] = { 0 };
3122 char full_name
[256] = { 0 };
3124 CHECK_NUMBER (lcid
);
3126 if (!IsValidLocale (XINT (lcid
), LCID_SUPPORTED
))
3129 if (NILP (longform
))
3131 got_abbrev
= GetLocaleInfo (XINT (lcid
),
3132 LOCALE_SABBREVLANGNAME
| LOCALE_USE_CP_ACP
,
3133 abbrev_name
, sizeof (abbrev_name
));
3135 return build_string (abbrev_name
);
3137 else if (EQ (longform
, Qt
))
3139 got_full
= GetLocaleInfo (XINT (lcid
),
3140 LOCALE_SLANGUAGE
| LOCALE_USE_CP_ACP
,
3141 full_name
, sizeof (full_name
));
3143 return DECODE_SYSTEM (build_string (full_name
));
3145 else if (NUMBERP (longform
))
3147 got_full
= GetLocaleInfo (XINT (lcid
),
3149 full_name
, sizeof (full_name
));
3150 /* GetLocaleInfo's return value includes the terminating null
3151 character, when the returned information is a string, whereas
3152 make_unibyte_string needs the string length without the
3153 terminating null. */
3155 return make_unibyte_string (full_name
, got_full
- 1);
3162 DEFUN ("w32-get-current-locale-id", Fw32_get_current_locale_id
,
3163 Sw32_get_current_locale_id
, 0, 0, 0,
3164 doc
: /* Return Windows locale id for current locale setting.
3165 This is a numerical value; use `w32-get-locale-info' to convert to a
3166 human-readable form. */)
3169 return make_number (GetThreadLocale ());
3173 int_from_hex (char * s
)
3176 static char hex
[] = "0123456789abcdefABCDEF";
3179 while (*s
&& (p
= strchr (hex
, *s
)) != NULL
)
3181 unsigned digit
= p
- hex
;
3184 val
= val
* 16 + digit
;
3190 /* We need to build a global list, since the EnumSystemLocale callback
3191 function isn't given a context pointer. */
3192 Lisp_Object Vw32_valid_locale_ids
;
3194 static BOOL CALLBACK ALIGN_STACK
3195 enum_locale_fn (LPTSTR localeNum
)
3197 DWORD id
= int_from_hex (localeNum
);
3198 Vw32_valid_locale_ids
= Fcons (make_number (id
), Vw32_valid_locale_ids
);
3202 DEFUN ("w32-get-valid-locale-ids", Fw32_get_valid_locale_ids
,
3203 Sw32_get_valid_locale_ids
, 0, 0, 0,
3204 doc
: /* Return list of all valid Windows locale ids.
3205 Each id is a numerical value; use `w32-get-locale-info' to convert to a
3206 human-readable form. */)
3209 Vw32_valid_locale_ids
= Qnil
;
3211 EnumSystemLocales (enum_locale_fn
, LCID_SUPPORTED
);
3213 Vw32_valid_locale_ids
= Fnreverse (Vw32_valid_locale_ids
);
3214 return Vw32_valid_locale_ids
;
3218 DEFUN ("w32-get-default-locale-id", Fw32_get_default_locale_id
, Sw32_get_default_locale_id
, 0, 1, 0,
3219 doc
: /* Return Windows locale id for default locale setting.
3220 By default, the system default locale setting is returned; if the optional
3221 parameter USERP is non-nil, the user default locale setting is returned.
3222 This is a numerical value; use `w32-get-locale-info' to convert to a
3223 human-readable form. */)
3227 return make_number (GetSystemDefaultLCID ());
3228 return make_number (GetUserDefaultLCID ());
3232 DEFUN ("w32-set-current-locale", Fw32_set_current_locale
, Sw32_set_current_locale
, 1, 1, 0,
3233 doc
: /* Make Windows locale LCID be the current locale setting for Emacs.
3234 If successful, the new locale id is returned, otherwise nil. */)
3237 CHECK_NUMBER (lcid
);
3239 if (!IsValidLocale (XINT (lcid
), LCID_SUPPORTED
))
3242 if (!SetThreadLocale (XINT (lcid
)))
3245 /* Need to set input thread locale if present. */
3246 if (dwWindowsThreadId
)
3247 /* Reply is not needed. */
3248 PostThreadMessage (dwWindowsThreadId
, WM_EMACS_SETLOCALE
, XINT (lcid
), 0);
3250 return make_number (GetThreadLocale ());
3254 /* We need to build a global list, since the EnumCodePages callback
3255 function isn't given a context pointer. */
3256 Lisp_Object Vw32_valid_codepages
;
3258 static BOOL CALLBACK ALIGN_STACK
3259 enum_codepage_fn (LPTSTR codepageNum
)
3261 DWORD id
= atoi (codepageNum
);
3262 Vw32_valid_codepages
= Fcons (make_number (id
), Vw32_valid_codepages
);
3266 DEFUN ("w32-get-valid-codepages", Fw32_get_valid_codepages
,
3267 Sw32_get_valid_codepages
, 0, 0, 0,
3268 doc
: /* Return list of all valid Windows codepages. */)
3271 Vw32_valid_codepages
= Qnil
;
3273 EnumSystemCodePages (enum_codepage_fn
, CP_SUPPORTED
);
3275 Vw32_valid_codepages
= Fnreverse (Vw32_valid_codepages
);
3276 return Vw32_valid_codepages
;
3280 DEFUN ("w32-get-console-codepage", Fw32_get_console_codepage
,
3281 Sw32_get_console_codepage
, 0, 0, 0,
3282 doc
: /* Return current Windows codepage for console input. */)
3285 return make_number (GetConsoleCP ());
3289 DEFUN ("w32-set-console-codepage", Fw32_set_console_codepage
,
3290 Sw32_set_console_codepage
, 1, 1, 0,
3291 doc
: /* Make Windows codepage CP be the codepage for Emacs tty keyboard input.
3292 This codepage setting affects keyboard input in tty mode.
3293 If successful, the new CP is returned, otherwise nil. */)
3298 if (!IsValidCodePage (XINT (cp
)))
3301 if (!SetConsoleCP (XINT (cp
)))
3304 return make_number (GetConsoleCP ());
3308 DEFUN ("w32-get-console-output-codepage", Fw32_get_console_output_codepage
,
3309 Sw32_get_console_output_codepage
, 0, 0, 0,
3310 doc
: /* Return current Windows codepage for console output. */)
3313 return make_number (GetConsoleOutputCP ());
3317 DEFUN ("w32-set-console-output-codepage", Fw32_set_console_output_codepage
,
3318 Sw32_set_console_output_codepage
, 1, 1, 0,
3319 doc
: /* Make Windows codepage CP be the codepage for Emacs console output.
3320 This codepage setting affects display in tty mode.
3321 If successful, the new CP is returned, otherwise nil. */)
3326 if (!IsValidCodePage (XINT (cp
)))
3329 if (!SetConsoleOutputCP (XINT (cp
)))
3332 return make_number (GetConsoleOutputCP ());
3336 DEFUN ("w32-get-codepage-charset", Fw32_get_codepage_charset
,
3337 Sw32_get_codepage_charset
, 1, 1, 0,
3338 doc
: /* Return charset ID corresponding to codepage CP.
3339 Returns nil if the codepage is not valid or its charset ID could
3342 Note that this function is only guaranteed to work with ANSI
3343 codepages; most console codepages are not supported and will
3352 if (!IsValidCodePage (XINT (cp
)))
3355 /* Going through a temporary DWORD_PTR variable avoids compiler warning
3356 about cast to pointer from integer of different size, when
3357 building --with-wide-int or building for 64bit. */
3359 if (TranslateCharsetInfo ((DWORD
*) dwcp
, &info
, TCI_SRCCODEPAGE
))
3360 return make_number (info
.ciCharset
);
3366 DEFUN ("w32-get-valid-keyboard-layouts", Fw32_get_valid_keyboard_layouts
,
3367 Sw32_get_valid_keyboard_layouts
, 0, 0, 0,
3368 doc
: /* Return list of Windows keyboard languages and layouts.
3369 The return value is a list of pairs of language id and layout id. */)
3372 int num_layouts
= GetKeyboardLayoutList (0, NULL
);
3373 HKL
* layouts
= (HKL
*) alloca (num_layouts
* sizeof (HKL
));
3374 Lisp_Object obj
= Qnil
;
3376 if (GetKeyboardLayoutList (num_layouts
, layouts
) == num_layouts
)
3378 while (--num_layouts
>= 0)
3380 HKL kl
= layouts
[num_layouts
];
3382 obj
= Fcons (Fcons (make_number (LOWORD (kl
)),
3383 make_number (HIWORD (kl
))),
3392 DEFUN ("w32-get-keyboard-layout", Fw32_get_keyboard_layout
,
3393 Sw32_get_keyboard_layout
, 0, 0, 0,
3394 doc
: /* Return current Windows keyboard language and layout.
3395 The return value is the cons of the language id and the layout id. */)
3398 HKL kl
= GetKeyboardLayout (dwWindowsThreadId
);
3400 return Fcons (make_number (LOWORD (kl
)),
3401 make_number (HIWORD (kl
)));
3405 DEFUN ("w32-set-keyboard-layout", Fw32_set_keyboard_layout
,
3406 Sw32_set_keyboard_layout
, 1, 1, 0,
3407 doc
: /* Make LAYOUT be the current keyboard layout for Emacs.
3408 The keyboard layout setting affects interpretation of keyboard input.
3409 If successful, the new layout id is returned, otherwise nil. */)
3410 (Lisp_Object layout
)
3414 CHECK_CONS (layout
);
3415 CHECK_NUMBER_CAR (layout
);
3416 CHECK_NUMBER_CDR (layout
);
3418 kl
= (HKL
) (UINT_PTR
) ((XINT (XCAR (layout
)) & 0xffff)
3419 | (XINT (XCDR (layout
)) << 16));
3421 /* Synchronize layout with input thread. */
3422 if (dwWindowsThreadId
)
3424 if (PostThreadMessage (dwWindowsThreadId
, WM_EMACS_SETKEYBOARDLAYOUT
,
3428 GetMessage (&msg
, NULL
, WM_EMACS_DONE
, WM_EMACS_DONE
);
3430 if (msg
.wParam
== 0)
3434 else if (!ActivateKeyboardLayout (kl
, 0))
3437 return Fw32_get_keyboard_layout ();
3440 /* Two variables to interface between get_lcid and the EnumLocales
3441 callback function below. */
3442 #ifndef LOCALE_NAME_MAX_LENGTH
3443 # define LOCALE_NAME_MAX_LENGTH 85
3445 static LCID found_lcid
;
3446 static char lname
[3 * LOCALE_NAME_MAX_LENGTH
+ 1 + 1];
3448 /* Callback function for EnumLocales. */
3449 static BOOL CALLBACK
3450 get_lcid_callback (LPTSTR locale_num_str
)
3453 char locval
[2 * LOCALE_NAME_MAX_LENGTH
+ 1 + 1];
3454 LCID try_lcid
= strtoul (locale_num_str
, &endp
, 16);
3456 if (GetLocaleInfo (try_lcid
, LOCALE_SABBREVLANGNAME
,
3457 locval
, LOCALE_NAME_MAX_LENGTH
))
3461 /* This is for when they only specify the language, as in "ENU". */
3462 if (stricmp (locval
, lname
) == 0)
3464 found_lcid
= try_lcid
;
3467 locval_len
= strlen (locval
);
3468 strcpy (locval
+ locval_len
, "_");
3469 if (GetLocaleInfo (try_lcid
, LOCALE_SABBREVCTRYNAME
,
3470 locval
+ locval_len
+ 1, LOCALE_NAME_MAX_LENGTH
))
3472 locval_len
= strlen (locval
);
3473 if (strnicmp (locval
, lname
, locval_len
) == 0
3474 && (lname
[locval_len
] == '.'
3475 || lname
[locval_len
] == '\0'))
3477 found_lcid
= try_lcid
;
3485 /* Return the Locale ID (LCID) number given the locale's name, a
3486 string, in LOCALE_NAME. This works by enumerating all the locales
3487 supported by the system, until we find one whose name matches
3490 get_lcid (const char *locale_name
)
3492 /* A simple cache. */
3493 static LCID last_lcid
;
3494 static char last_locale
[1000];
3496 /* The code below is not thread-safe, as it uses static variables.
3497 But this function is called only from the Lisp thread. */
3498 if (last_lcid
> 0 && strcmp (locale_name
, last_locale
) == 0)
3501 strncpy (lname
, locale_name
, sizeof (lname
) - 1);
3502 lname
[sizeof (lname
) - 1] = '\0';
3504 EnumSystemLocales (get_lcid_callback
, LCID_SUPPORTED
);
3507 last_lcid
= found_lcid
;
3508 strcpy (last_locale
, locale_name
);
3513 #ifndef _NSLCMPERROR
3514 # define _NSLCMPERROR INT_MAX
3516 #ifndef LINGUISTIC_IGNORECASE
3517 # define LINGUISTIC_IGNORECASE 0x00000010
3520 typedef int (WINAPI
*CompareStringW_Proc
)
3521 (LCID
, DWORD
, LPCWSTR
, int, LPCWSTR
, int);
3524 w32_compare_strings (const char *s1
, const char *s2
, char *locname
,
3527 LCID lcid
= GetThreadLocale ();
3528 wchar_t *string1_w
, *string2_w
;
3530 extern BOOL g_b_init_compare_string_w
;
3531 static CompareStringW_Proc pCompareStringW
;
3536 /* The LCID machinery doesn't seem to support the "C" locale, so we
3537 need to do that by hand. */
3539 && ((locname
[0] == 'C' && (locname
[1] == '\0' || locname
[1] == '.'))
3540 || strcmp (locname
, "POSIX") == 0))
3541 return (ignore_case
? stricmp (s1
, s2
) : strcmp (s1
, s2
));
3543 if (!g_b_init_compare_string_w
)
3545 if (os_subtype
== OS_9X
)
3548 (CompareStringW_Proc
) GetProcAddress (LoadLibrary ("Unicows.dll"),
3550 if (!pCompareStringW
)
3553 /* This return value is compatible with wcscoll and
3554 other MS CRT functions. */
3555 return _NSLCMPERROR
;
3559 pCompareStringW
= CompareStringW
;
3561 g_b_init_compare_string_w
= 1;
3564 needed
= pMultiByteToWideChar (CP_UTF8
, MB_ERR_INVALID_CHARS
, s1
, -1, NULL
, 0);
3567 SAFE_NALLOCA (string1_w
, 1, needed
+ 1);
3568 pMultiByteToWideChar (CP_UTF8
, MB_ERR_INVALID_CHARS
, s1
, -1,
3574 return _NSLCMPERROR
;
3577 needed
= pMultiByteToWideChar (CP_UTF8
, MB_ERR_INVALID_CHARS
, s2
, -1, NULL
, 0);
3580 SAFE_NALLOCA (string2_w
, 1, needed
+ 1);
3581 pMultiByteToWideChar (CP_UTF8
, MB_ERR_INVALID_CHARS
, s2
, -1,
3588 return _NSLCMPERROR
;
3593 /* Convert locale name string to LCID. We don't want to use
3594 LocaleNameToLCID because (a) it is only available since
3595 Vista, and (b) it doesn't accept locale names returned by
3596 'setlocale' and 'GetLocaleInfo'. */
3597 LCID new_lcid
= get_lcid (locname
);
3602 error ("Invalid locale %s: Invalid argument", locname
);
3607 /* NORM_IGNORECASE ignores any tertiary distinction, not just
3608 case variants. LINGUISTIC_IGNORECASE is more selective, and
3609 is sensitive to the locale's language, but it is not
3610 available before Vista. */
3611 if (w32_major_version
>= 6)
3612 flags
|= LINGUISTIC_IGNORECASE
;
3614 flags
|= NORM_IGNORECASE
;
3616 /* This approximates what glibc collation functions do when the
3617 locale's codeset is UTF-8. */
3618 if (!NILP (Vw32_collate_ignore_punctuation
))
3619 flags
|= NORM_IGNORESYMBOLS
;
3620 val
= pCompareStringW (lcid
, flags
, string1_w
, -1, string2_w
, -1);
3625 return _NSLCMPERROR
;
3632 syms_of_ntproc (void)
3634 DEFSYM (Qhigh
, "high");
3635 DEFSYM (Qlow
, "low");
3636 DEFSYM (Qcygwin
, "cygwin");
3637 DEFSYM (Qmsys
, "msys");
3638 DEFSYM (Qw32_native
, "w32-native");
3640 defsubr (&Sw32_has_winsock
);
3641 defsubr (&Sw32_unload_winsock
);
3643 defsubr (&Sw32_short_file_name
);
3644 defsubr (&Sw32_long_file_name
);
3645 defsubr (&Sw32_set_process_priority
);
3646 defsubr (&Sw32_application_type
);
3647 defsubr (&Sw32_get_locale_info
);
3648 defsubr (&Sw32_get_current_locale_id
);
3649 defsubr (&Sw32_get_default_locale_id
);
3650 defsubr (&Sw32_get_valid_locale_ids
);
3651 defsubr (&Sw32_set_current_locale
);
3653 defsubr (&Sw32_get_console_codepage
);
3654 defsubr (&Sw32_set_console_codepage
);
3655 defsubr (&Sw32_get_console_output_codepage
);
3656 defsubr (&Sw32_set_console_output_codepage
);
3657 defsubr (&Sw32_get_valid_codepages
);
3658 defsubr (&Sw32_get_codepage_charset
);
3660 defsubr (&Sw32_get_valid_keyboard_layouts
);
3661 defsubr (&Sw32_get_keyboard_layout
);
3662 defsubr (&Sw32_set_keyboard_layout
);
3664 DEFVAR_LISP ("w32-quote-process-args", Vw32_quote_process_args
,
3665 doc
: /* Non-nil enables quoting of process arguments to ensure correct parsing.
3666 Because Windows does not directly pass argv arrays to child processes,
3667 programs have to reconstruct the argv array by parsing the command
3668 line string. For an argument to contain a space, it must be enclosed
3669 in double quotes or it will be parsed as multiple arguments.
3671 If the value is a character, that character will be used to escape any
3672 quote characters that appear, otherwise a suitable escape character
3673 will be chosen based on the type of the program. */);
3674 Vw32_quote_process_args
= Qt
;
3676 DEFVAR_LISP ("w32-start-process-show-window",
3677 Vw32_start_process_show_window
,
3678 doc
: /* When nil, new child processes hide their windows.
3679 When non-nil, they show their window in the method of their choice.
3680 This variable doesn't affect GUI applications, which will never be hidden. */);
3681 Vw32_start_process_show_window
= Qnil
;
3683 DEFVAR_LISP ("w32-start-process-share-console",
3684 Vw32_start_process_share_console
,
3685 doc
: /* When nil, new child processes are given a new console.
3686 When non-nil, they share the Emacs console; this has the limitation of
3687 allowing only one DOS subprocess to run at a time (whether started directly
3688 or indirectly by Emacs), and preventing Emacs from cleanly terminating the
3689 subprocess group, but may allow Emacs to interrupt a subprocess that doesn't
3690 otherwise respond to interrupts from Emacs. */);
3691 Vw32_start_process_share_console
= Qnil
;
3693 DEFVAR_LISP ("w32-start-process-inherit-error-mode",
3694 Vw32_start_process_inherit_error_mode
,
3695 doc
: /* When nil, new child processes revert to the default error mode.
3696 When non-nil, they inherit their error mode setting from Emacs, which stops
3697 them blocking when trying to access unmounted drives etc. */);
3698 Vw32_start_process_inherit_error_mode
= Qt
;
3700 DEFVAR_INT ("w32-pipe-read-delay", w32_pipe_read_delay
,
3701 doc
: /* Forced delay before reading subprocess output.
3702 This is done to improve the buffering of subprocess output, by
3703 avoiding the inefficiency of frequently reading small amounts of data.
3705 If positive, the value is the number of milliseconds to sleep before
3706 reading the subprocess output. If negative, the magnitude is the number
3707 of time slices to wait (effectively boosting the priority of the child
3708 process temporarily). A value of zero disables waiting entirely. */);
3709 w32_pipe_read_delay
= 50;
3711 DEFVAR_LISP ("w32-downcase-file-names", Vw32_downcase_file_names
,
3712 doc
: /* Non-nil means convert all-upper case file names to lower case.
3713 This applies when performing completions and file name expansion.
3714 Note that the value of this setting also affects remote file names,
3715 so you probably don't want to set to non-nil if you use case-sensitive
3716 filesystems via ange-ftp. */);
3717 Vw32_downcase_file_names
= Qnil
;
3720 DEFVAR_LISP ("w32-generate-fake-inodes", Vw32_generate_fake_inodes
,
3721 doc
: /* Non-nil means attempt to fake realistic inode values.
3722 This works by hashing the truename of files, and should detect
3723 aliasing between long and short (8.3 DOS) names, but can have
3724 false positives because of hash collisions. Note that determining
3725 the truename of a file can be slow. */);
3726 Vw32_generate_fake_inodes
= Qnil
;
3729 DEFVAR_LISP ("w32-get-true-file-attributes", Vw32_get_true_file_attributes
,
3730 doc
: /* Non-nil means determine accurate file attributes in `file-attributes'.
3731 This option controls whether to issue additional system calls to determine
3732 accurate link counts, file type, and ownership information. It is more
3733 useful for files on NTFS volumes, where hard links and file security are
3734 supported, than on volumes of the FAT family.
3736 Without these system calls, link count will always be reported as 1 and file
3737 ownership will be attributed to the current user.
3738 The default value `local' means only issue these system calls for files
3739 on local fixed drives. A value of nil means never issue them.
3740 Any other non-nil value means do this even on remote and removable drives
3741 where the performance impact may be noticeable even on modern hardware. */);
3742 Vw32_get_true_file_attributes
= Qlocal
;
3744 DEFVAR_LISP ("w32-collate-ignore-punctuation",
3745 Vw32_collate_ignore_punctuation
,
3746 doc
: /* Non-nil causes string collation functions ignore punctuation on MS-Windows.
3747 On Posix platforms, `string-collate-lessp' and `string-collate-equalp'
3748 ignore punctuation characters when they compare strings, if the
3749 locale's codeset is UTF-8, as in \"en_US.UTF-8\". Binding this option
3750 to a non-nil value will achieve a similar effect on MS-Windows, where
3751 locales with UTF-8 codeset are not supported.
3753 Note that setting this to non-nil will also ignore blanks and symbols
3754 in the strings. So do NOT use this option when comparing file names
3755 for equality, only when you need to sort them. */);
3756 Vw32_collate_ignore_punctuation
= Qnil
;
3758 staticpro (&Vw32_valid_locale_ids
);
3759 staticpro (&Vw32_valid_codepages
);
3761 /* end of w32proc.c */