1 /* Process support for GNU Emacs on the Microsoft Windows API.
2 Copyright (C) 1992, 1995, 1999-2013 Free Software Foundation, Inc.
4 This file is part of GNU Emacs.
6 GNU Emacs is free software: you can redistribute it and/or modify
7 it under the terms of the GNU General Public License as published by
8 the Free Software Foundation, either version 3 of the License, or
9 (at your option) any later version.
11 GNU Emacs is distributed in the hope that it will be useful,
12 but WITHOUT ANY WARRANTY; without even the implied warranty of
13 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14 GNU General Public License for more details.
16 You should have received a copy of the GNU General Public License
17 along with GNU Emacs. If not, see <http://www.gnu.org/licenses/>. */
20 Drew Bliss Oct 14, 1993
21 Adapted from alarm.c by Tim Fleehart
33 /* must include CRT headers *before* config.h */
44 /* This definition is missing from mingw32 headers. */
45 extern BOOL WINAPI
IsValidLocale (LCID
, DWORD
);
48 #ifdef HAVE_LANGINFO_CODESET
55 #include "w32common.h"
60 #include "syssignal.h"
62 #include "dispextern.h" /* for xstrcasecmp */
65 #define RVA_TO_PTR(var,section,filedata) \
66 ((void *)((section)->PointerToRawData \
67 + ((DWORD_PTR)(var) - (section)->VirtualAddress) \
68 + (filedata).file_base))
70 Lisp_Object Qhigh
, Qlow
;
72 /* Signal handlers...SIG_DFL == 0 so this is initialized correctly. */
73 static signal_handler sig_handlers
[NSIG
];
75 static sigset_t sig_mask
;
77 static CRITICAL_SECTION crit_sig
;
79 /* Improve on the CRT 'signal' implementation so that we could record
80 the SIGCHLD handler and fake interval timers. */
82 sys_signal (int sig
, signal_handler handler
)
86 /* SIGCHLD is needed for supporting subprocesses, see sys_kill
87 below. SIGALRM and SIGPROF are used by setitimer. All the
88 others are the only ones supported by the MS runtime. */
89 if (!(sig
== SIGCHLD
|| sig
== SIGSEGV
|| sig
== SIGILL
90 || sig
== SIGFPE
|| sig
== SIGABRT
|| sig
== SIGTERM
91 || sig
== SIGALRM
|| sig
== SIGPROF
))
96 old
= sig_handlers
[sig
];
97 /* SIGABRT is treated specially because w32.c installs term_ntproc
98 as its handler, so we don't want to override that afterwards.
99 Aborting Emacs works specially anyway: either by calling
100 emacs_abort directly or through terminate_due_to_signal, which
101 calls emacs_abort through emacs_raise. */
102 if (!(sig
== SIGABRT
&& old
== term_ntproc
))
104 sig_handlers
[sig
] = handler
;
105 if (!(sig
== SIGCHLD
|| sig
== SIGALRM
|| sig
== SIGPROF
))
106 signal (sig
, handler
);
111 /* Emulate sigaction. */
113 sigaction (int sig
, const struct sigaction
*act
, struct sigaction
*oact
)
115 signal_handler old
= SIG_DFL
;
119 old
= sys_signal (sig
, act
->sa_handler
);
121 old
= sig_handlers
[sig
];
130 oact
->sa_handler
= old
;
132 oact
->sa_mask
= empty_mask
;
137 /* Emulate signal sets and blocking of signals used by timers. */
140 sigemptyset (sigset_t
*set
)
147 sigaddset (sigset_t
*set
, int signo
)
154 if (signo
< 0 || signo
>= NSIG
)
160 *set
|= (1U << signo
);
166 sigfillset (sigset_t
*set
)
179 sigprocmask (int how
, const sigset_t
*set
, sigset_t
*oset
)
181 if (!(how
== SIG_BLOCK
|| how
== SIG_UNBLOCK
|| how
== SIG_SETMASK
))
202 /* FIXME: Catch signals that are blocked and reissue them when
203 they are unblocked. Important for SIGALRM and SIGPROF only. */
212 pthread_sigmask (int how
, const sigset_t
*set
, sigset_t
*oset
)
214 if (sigprocmask (how
, set
, oset
) == -1)
220 sigismember (const sigset_t
*set
, int signo
)
222 if (signo
< 0 || signo
>= NSIG
)
227 if (signo
> sizeof (*set
) * BITS_PER_CHAR
)
230 return (*set
& (1U << signo
)) != 0;
234 setpgrp (int pid
, int gid
)
246 setpgid (pid_t pid
, pid_t pgid
)
251 /* Emulations of interval timers.
253 Limitations: only ITIMER_REAL and ITIMER_PROF are supported.
255 Implementation: a separate thread is started for each timer type,
256 the thread calls the appropriate signal handler when the timer
257 expires, after stopping the thread which installed the timer. */
260 volatile ULONGLONG expire
;
261 volatile ULONGLONG reload
;
262 volatile int terminate
;
264 HANDLE caller_thread
;
268 static ULONGLONG ticks_now
;
269 static struct itimer_data real_itimer
, prof_itimer
;
270 static ULONGLONG clocks_min
;
271 /* If non-zero, itimers are disabled. Used during shutdown, when we
272 delete the critical sections used by the timer threads. */
273 static int disable_itimers
;
275 static CRITICAL_SECTION crit_real
, crit_prof
;
277 /* GetThreadTimes is not available on Windows 9X and possibly also on 2K. */
278 typedef BOOL (WINAPI
*GetThreadTimes_Proc
) (
280 LPFILETIME lpCreationTime
,
281 LPFILETIME lpExitTime
,
282 LPFILETIME lpKernelTime
,
283 LPFILETIME lpUserTime
);
285 static GetThreadTimes_Proc s_pfn_Get_Thread_Times
;
287 #define MAX_SINGLE_SLEEP 30
288 #define TIMER_TICKS_PER_SEC 1000
290 /* Return a suitable time value, in 1-ms units, for THREAD, a handle
291 to a thread. If THREAD is NULL or an invalid handle, return the
292 current wall-clock time since January 1, 1601 (UTC). Otherwise,
293 return the sum of kernel and user times used by THREAD since it was
294 created, plus its creation time. */
296 w32_get_timer_time (HANDLE thread
)
299 int use_system_time
= 1;
300 /* The functions below return times in 100-ns units. */
301 const int tscale
= 10 * TIMER_TICKS_PER_SEC
;
303 if (thread
&& thread
!= INVALID_HANDLE_VALUE
304 && s_pfn_Get_Thread_Times
!= NULL
)
306 FILETIME creation_ftime
, exit_ftime
, kernel_ftime
, user_ftime
;
307 ULARGE_INTEGER temp_creation
, temp_kernel
, temp_user
;
309 if (s_pfn_Get_Thread_Times (thread
, &creation_ftime
, &exit_ftime
,
310 &kernel_ftime
, &user_ftime
))
313 temp_creation
.LowPart
= creation_ftime
.dwLowDateTime
;
314 temp_creation
.HighPart
= creation_ftime
.dwHighDateTime
;
315 temp_kernel
.LowPart
= kernel_ftime
.dwLowDateTime
;
316 temp_kernel
.HighPart
= kernel_ftime
.dwHighDateTime
;
317 temp_user
.LowPart
= user_ftime
.dwLowDateTime
;
318 temp_user
.HighPart
= user_ftime
.dwHighDateTime
;
320 temp_creation
.QuadPart
/ tscale
+ temp_kernel
.QuadPart
/ tscale
321 + temp_user
.QuadPart
/ tscale
;
324 DebPrint (("GetThreadTimes failed with error code %lu\n",
330 FILETIME current_ftime
;
333 GetSystemTimeAsFileTime (¤t_ftime
);
335 temp
.LowPart
= current_ftime
.dwLowDateTime
;
336 temp
.HighPart
= current_ftime
.dwHighDateTime
;
338 retval
= temp
.QuadPart
/ tscale
;
344 /* Thread function for a timer thread. */
346 timer_loop (LPVOID arg
)
348 struct itimer_data
*itimer
= (struct itimer_data
*)arg
;
349 int which
= itimer
->type
;
350 int sig
= (which
== ITIMER_REAL
) ? SIGALRM
: SIGPROF
;
351 CRITICAL_SECTION
*crit
= (which
== ITIMER_REAL
) ? &crit_real
: &crit_prof
;
352 const DWORD max_sleep
= MAX_SINGLE_SLEEP
* 1000 / TIMER_TICKS_PER_SEC
;
353 HANDLE hth
= (which
== ITIMER_REAL
) ? NULL
: itimer
->caller_thread
;
358 signal_handler handler
;
359 ULONGLONG now
, expire
, reload
;
361 /* Load new values if requested by setitimer. */
362 EnterCriticalSection (crit
);
363 expire
= itimer
->expire
;
364 reload
= itimer
->reload
;
365 LeaveCriticalSection (crit
);
366 if (itimer
->terminate
)
376 if (expire
> (now
= w32_get_timer_time (hth
)))
377 sleep_time
= expire
- now
;
380 /* Don't sleep too long at a time, to be able to see the
381 termination flag without too long a delay. */
382 while (sleep_time
> max_sleep
)
384 if (itimer
->terminate
)
387 EnterCriticalSection (crit
);
388 expire
= itimer
->expire
;
389 LeaveCriticalSection (crit
);
391 (expire
> (now
= w32_get_timer_time (hth
))) ? expire
- now
: 0;
393 if (itimer
->terminate
)
397 Sleep (sleep_time
* 1000 / TIMER_TICKS_PER_SEC
);
398 /* Always sleep past the expiration time, to make sure we
399 never call the handler _before_ the expiration time,
400 always slightly after it. Sleep(5) makes sure we don't
401 hog the CPU by calling 'w32_get_timer_time' with high
402 frequency, and also let other threads work. */
403 while (w32_get_timer_time (hth
) < expire
)
407 EnterCriticalSection (crit
);
408 expire
= itimer
->expire
;
409 LeaveCriticalSection (crit
);
414 handler
= sig_handlers
[sig
];
415 if (!(handler
== SIG_DFL
|| handler
== SIG_IGN
|| handler
== SIG_ERR
)
416 /* FIXME: Don't ignore masked signals. Instead, record that
417 they happened and reissue them when the signal is
419 && !sigismember (&sig_mask
, sig
)
420 /* Simulate masking of SIGALRM and SIGPROF when processing
422 && !fatal_error_in_progress
423 && itimer
->caller_thread
)
425 /* Simulate a signal delivered to the thread which installed
426 the timer, by suspending that thread while the handler
428 HANDLE th
= itimer
->caller_thread
;
429 DWORD result
= SuspendThread (th
);
431 if (result
== (DWORD
)-1)
438 /* Update expiration time and loop. */
439 EnterCriticalSection (crit
);
440 expire
= itimer
->expire
;
443 LeaveCriticalSection (crit
);
446 reload
= itimer
->reload
;
449 now
= w32_get_timer_time (hth
);
452 ULONGLONG lag
= now
- expire
;
454 /* If we missed some opportunities (presumably while
455 sleeping or while the signal handler ran), skip
458 expire
= now
- (lag
% reload
);
464 expire
= 0; /* become idle */
465 itimer
->expire
= expire
;
466 LeaveCriticalSection (crit
);
472 stop_timer_thread (int which
)
474 struct itimer_data
*itimer
=
475 (which
== ITIMER_REAL
) ? &real_itimer
: &prof_itimer
;
477 DWORD err
, exit_code
= 255;
480 /* Signal the thread that it should terminate. */
481 itimer
->terminate
= 1;
483 if (itimer
->timer_thread
== NULL
)
486 /* Wait for the timer thread to terminate voluntarily, then kill it
487 if it doesn't. This loop waits twice more than the maximum
488 amount of time a timer thread sleeps, see above. */
489 for (i
= 0; i
< MAX_SINGLE_SLEEP
/ 5; i
++)
491 if (!((status
= GetExitCodeThread (itimer
->timer_thread
, &exit_code
))
492 && exit_code
== STILL_ACTIVE
))
496 if ((status
== FALSE
&& (err
= GetLastError ()) == ERROR_INVALID_HANDLE
)
497 || exit_code
== STILL_ACTIVE
)
499 if (!(status
== FALSE
&& err
== ERROR_INVALID_HANDLE
))
500 TerminateThread (itimer
->timer_thread
, 0);
504 CloseHandle (itimer
->timer_thread
);
505 itimer
->timer_thread
= NULL
;
506 if (itimer
->caller_thread
)
508 CloseHandle (itimer
->caller_thread
);
509 itimer
->caller_thread
= NULL
;
513 /* This is called at shutdown time from term_ntproc. */
517 if (real_itimer
.timer_thread
)
518 stop_timer_thread (ITIMER_REAL
);
519 if (prof_itimer
.timer_thread
)
520 stop_timer_thread (ITIMER_PROF
);
522 /* We are going to delete the critical sections, so timers cannot
526 DeleteCriticalSection (&crit_real
);
527 DeleteCriticalSection (&crit_prof
);
528 DeleteCriticalSection (&crit_sig
);
531 /* This is called at initialization time from init_ntproc. */
535 /* GetThreadTimes is not available on all versions of Windows, so
536 need to probe for its availability dynamically, and call it
537 through a pointer. */
538 s_pfn_Get_Thread_Times
= NULL
; /* in case dumped Emacs comes with a value */
539 if (os_subtype
!= OS_9X
)
540 s_pfn_Get_Thread_Times
=
541 (GetThreadTimes_Proc
)GetProcAddress (GetModuleHandle ("kernel32.dll"),
544 /* Make sure we start with zeroed out itimer structures, since
545 dumping may have left there traces of threads long dead. */
546 memset (&real_itimer
, 0, sizeof real_itimer
);
547 memset (&prof_itimer
, 0, sizeof prof_itimer
);
549 InitializeCriticalSection (&crit_real
);
550 InitializeCriticalSection (&crit_prof
);
551 InitializeCriticalSection (&crit_sig
);
557 start_timer_thread (int which
)
561 struct itimer_data
*itimer
=
562 (which
== ITIMER_REAL
) ? &real_itimer
: &prof_itimer
;
564 if (itimer
->timer_thread
565 && GetExitCodeThread (itimer
->timer_thread
, &exit_code
)
566 && exit_code
== STILL_ACTIVE
)
569 /* Clean up after possibly exited thread. */
570 if (itimer
->timer_thread
)
572 CloseHandle (itimer
->timer_thread
);
573 itimer
->timer_thread
= NULL
;
575 if (itimer
->caller_thread
)
577 CloseHandle (itimer
->caller_thread
);
578 itimer
->caller_thread
= NULL
;
581 /* Start a new thread. */
582 if (!DuplicateHandle (GetCurrentProcess (), GetCurrentThread (),
583 GetCurrentProcess (), &th
, 0, FALSE
,
584 DUPLICATE_SAME_ACCESS
))
589 itimer
->terminate
= 0;
590 itimer
->type
= which
;
591 itimer
->caller_thread
= th
;
592 /* Request that no more than 64KB of stack be reserved for this
593 thread, to avoid reserving too much memory, which would get in
594 the way of threads we start to wait for subprocesses. See also
596 itimer
->timer_thread
= CreateThread (NULL
, 64 * 1024, timer_loop
,
597 (void *)itimer
, 0x00010000, NULL
);
599 if (!itimer
->timer_thread
)
601 CloseHandle (itimer
->caller_thread
);
602 itimer
->caller_thread
= NULL
;
607 /* This is needed to make sure that the timer thread running for
608 profiling gets CPU as soon as the Sleep call terminates. */
609 if (which
== ITIMER_PROF
)
610 SetThreadPriority (itimer
->timer_thread
, THREAD_PRIORITY_TIME_CRITICAL
);
615 /* Most of the code of getitimer and setitimer (but not of their
616 subroutines) was shamelessly stolen from itimer.c in the DJGPP
617 library, see www.delorie.com/djgpp. */
619 getitimer (int which
, struct itimerval
*value
)
621 volatile ULONGLONG
*t_expire
;
622 volatile ULONGLONG
*t_reload
;
623 ULONGLONG expire
, reload
;
625 CRITICAL_SECTION
*crit
;
626 struct itimer_data
*itimer
;
637 if (which
!= ITIMER_REAL
&& which
!= ITIMER_PROF
)
643 itimer
= (which
== ITIMER_REAL
) ? &real_itimer
: &prof_itimer
;
645 ticks_now
= w32_get_timer_time ((which
== ITIMER_REAL
)
647 : GetCurrentThread ());
649 t_expire
= &itimer
->expire
;
650 t_reload
= &itimer
->reload
;
651 crit
= (which
== ITIMER_REAL
) ? &crit_real
: &crit_prof
;
653 EnterCriticalSection (crit
);
656 LeaveCriticalSection (crit
);
661 value
->it_value
.tv_sec
= expire
/ TIMER_TICKS_PER_SEC
;
663 (expire
% TIMER_TICKS_PER_SEC
) * (__int64
)1000000 / TIMER_TICKS_PER_SEC
;
664 value
->it_value
.tv_usec
= usecs
;
665 value
->it_interval
.tv_sec
= reload
/ TIMER_TICKS_PER_SEC
;
667 (reload
% TIMER_TICKS_PER_SEC
) * (__int64
)1000000 / TIMER_TICKS_PER_SEC
;
668 value
->it_interval
.tv_usec
= usecs
;
674 setitimer(int which
, struct itimerval
*value
, struct itimerval
*ovalue
)
676 volatile ULONGLONG
*t_expire
, *t_reload
;
677 ULONGLONG expire
, reload
, expire_old
, reload_old
;
679 CRITICAL_SECTION
*crit
;
680 struct itimerval tem
, *ptem
;
685 /* Posix systems expect timer values smaller than the resolution of
686 the system clock be rounded up to the clock resolution. First
687 time we are called, measure the clock tick resolution. */
692 for (t1
= w32_get_timer_time (NULL
);
693 (t2
= w32_get_timer_time (NULL
)) == t1
; )
695 clocks_min
= t2
- t1
;
703 if (getitimer (which
, ptem
)) /* also sets ticks_now */
704 return -1; /* errno already set */
707 (which
== ITIMER_REAL
) ? &real_itimer
.expire
: &prof_itimer
.expire
;
709 (which
== ITIMER_REAL
) ? &real_itimer
.reload
: &prof_itimer
.reload
;
711 crit
= (which
== ITIMER_REAL
) ? &crit_real
: &crit_prof
;
714 || (value
->it_value
.tv_sec
== 0 && value
->it_value
.tv_usec
== 0))
716 EnterCriticalSection (crit
);
717 /* Disable the timer. */
720 LeaveCriticalSection (crit
);
724 reload
= value
->it_interval
.tv_sec
* TIMER_TICKS_PER_SEC
;
726 usecs
= value
->it_interval
.tv_usec
;
727 if (value
->it_interval
.tv_sec
== 0
728 && usecs
&& usecs
* TIMER_TICKS_PER_SEC
< clocks_min
* 1000000)
732 usecs
*= TIMER_TICKS_PER_SEC
;
733 reload
+= usecs
/ 1000000;
736 expire
= value
->it_value
.tv_sec
* TIMER_TICKS_PER_SEC
;
737 usecs
= value
->it_value
.tv_usec
;
738 if (value
->it_value
.tv_sec
== 0
739 && usecs
* TIMER_TICKS_PER_SEC
< clocks_min
* 1000000)
743 usecs
*= TIMER_TICKS_PER_SEC
;
744 expire
+= usecs
/ 1000000;
749 EnterCriticalSection (crit
);
750 expire_old
= *t_expire
;
751 reload_old
= *t_reload
;
752 if (!(expire
== expire_old
&& reload
== reload_old
))
757 LeaveCriticalSection (crit
);
759 return start_timer_thread (which
);
765 #ifdef HAVE_SETITIMER
766 struct itimerval new_values
, old_values
;
768 new_values
.it_value
.tv_sec
= seconds
;
769 new_values
.it_value
.tv_usec
= 0;
770 new_values
.it_interval
.tv_sec
= new_values
.it_interval
.tv_usec
= 0;
772 if (setitimer (ITIMER_REAL
, &new_values
, &old_values
) < 0)
774 return old_values
.it_value
.tv_sec
;
780 /* Defined in <process.h> which conflicts with the local copy */
783 /* Child process management list. */
784 int child_proc_count
= 0;
785 child_process child_procs
[ MAX_CHILDREN
];
786 child_process
*dead_child
= NULL
;
788 static DWORD WINAPI
reader_thread (void *arg
);
790 /* Find an unused process slot. */
797 for (cp
= child_procs
+ (child_proc_count
-1); cp
>= child_procs
; cp
--)
798 if (!CHILD_ACTIVE (cp
) && cp
->procinfo
.hProcess
== NULL
)
800 if (child_proc_count
== MAX_CHILDREN
)
803 child_process
*dead_cp
;
805 DebPrint (("new_child: No vacant slots, looking for dead processes\n"));
806 for (cp
= child_procs
+ (child_proc_count
-1); cp
>= child_procs
; cp
--)
807 if (!CHILD_ACTIVE (cp
) && cp
->procinfo
.hProcess
)
811 if (!GetExitCodeProcess (cp
->procinfo
.hProcess
, &status
))
813 DebPrint (("new_child.GetExitCodeProcess: error %lu for PID %lu\n",
814 GetLastError (), cp
->procinfo
.dwProcessId
));
815 status
= STILL_ACTIVE
;
817 if (status
!= STILL_ACTIVE
818 || WaitForSingleObject (cp
->procinfo
.hProcess
, 0) == WAIT_OBJECT_0
)
820 DebPrint (("new_child: Freeing slot of dead process %d, fd %d\n",
821 cp
->procinfo
.dwProcessId
, cp
->fd
));
822 CloseHandle (cp
->procinfo
.hProcess
);
823 cp
->procinfo
.hProcess
= NULL
;
824 CloseHandle (cp
->procinfo
.hThread
);
825 cp
->procinfo
.hThread
= NULL
;
826 /* Free up to 2 dead slots at a time, so that if we
827 have a lot of them, they will eventually all be
828 freed when the tornado ends. */
840 if (child_proc_count
== MAX_CHILDREN
)
842 cp
= &child_procs
[child_proc_count
++];
845 memset (cp
, 0, sizeof (*cp
));
848 cp
->procinfo
.hProcess
= NULL
;
849 cp
->status
= STATUS_READ_ERROR
;
851 /* use manual reset event so that select() will function properly */
852 cp
->char_avail
= CreateEvent (NULL
, TRUE
, FALSE
, NULL
);
855 cp
->char_consumed
= CreateEvent (NULL
, FALSE
, FALSE
, NULL
);
856 if (cp
->char_consumed
)
858 /* The 0x00010000 flag is STACK_SIZE_PARAM_IS_A_RESERVATION.
859 It means that the 64K stack we are requesting in the 2nd
860 argument is how much memory should be reserved for the
861 stack. If we don't use this flag, the memory requested
862 by the 2nd argument is the amount actually _committed_,
863 but Windows reserves 8MB of memory for each thread's
864 stack. (The 8MB figure comes from the -stack
865 command-line argument we pass to the linker when building
866 Emacs, but that's because we need a large stack for
867 Emacs's main thread.) Since we request 2GB of reserved
868 memory at startup (see w32heap.c), which is close to the
869 maximum memory available for a 32-bit process on Windows,
870 the 8MB reservation for each thread causes failures in
871 starting subprocesses, because we create a thread running
872 reader_thread for each subprocess. As 8MB of stack is
873 way too much for reader_thread, forcing Windows to
874 reserve less wins the day. */
875 cp
->thrd
= CreateThread (NULL
, 64 * 1024, reader_thread
, cp
,
886 delete_child (child_process
*cp
)
890 /* Should not be deleting a child that is still needed. */
891 for (i
= 0; i
< MAXDESC
; i
++)
892 if (fd_info
[i
].cp
== cp
)
895 if (!CHILD_ACTIVE (cp
) && cp
->procinfo
.hProcess
== NULL
)
898 /* reap thread if necessary */
903 if (GetExitCodeThread (cp
->thrd
, &rc
) && rc
== STILL_ACTIVE
)
905 /* let the thread exit cleanly if possible */
906 cp
->status
= STATUS_READ_ERROR
;
907 SetEvent (cp
->char_consumed
);
909 /* We used to forcibly terminate the thread here, but it
910 is normally unnecessary, and in abnormal cases, the worst that
911 will happen is we have an extra idle thread hanging around
912 waiting for the zombie process. */
913 if (WaitForSingleObject (cp
->thrd
, 1000) != WAIT_OBJECT_0
)
915 DebPrint (("delete_child.WaitForSingleObject (thread) failed "
916 "with %lu for fd %ld\n", GetLastError (), cp
->fd
));
917 TerminateThread (cp
->thrd
, 0);
921 CloseHandle (cp
->thrd
);
926 CloseHandle (cp
->char_avail
);
927 cp
->char_avail
= NULL
;
929 if (cp
->char_consumed
)
931 CloseHandle (cp
->char_consumed
);
932 cp
->char_consumed
= NULL
;
935 /* update child_proc_count (highest numbered slot in use plus one) */
936 if (cp
== child_procs
+ child_proc_count
- 1)
938 for (i
= child_proc_count
-1; i
>= 0; i
--)
939 if (CHILD_ACTIVE (&child_procs
[i
])
940 || child_procs
[i
].procinfo
.hProcess
!= NULL
)
942 child_proc_count
= i
+ 1;
947 child_proc_count
= 0;
950 /* Find a child by pid. */
951 static child_process
*
952 find_child_pid (DWORD pid
)
956 for (cp
= child_procs
+ (child_proc_count
-1); cp
>= child_procs
; cp
--)
957 if ((CHILD_ACTIVE (cp
) || cp
->procinfo
.hProcess
!= NULL
)
964 /* Thread proc for child process and socket reader threads. Each thread
965 is normally blocked until woken by select() to check for input by
966 reading one char. When the read completes, char_avail is signaled
967 to wake up the select emulator and the thread blocks itself again. */
969 reader_thread (void *arg
)
974 cp
= (child_process
*)arg
;
976 /* We have to wait for the go-ahead before we can start */
978 || WaitForSingleObject (cp
->char_consumed
, INFINITE
) != WAIT_OBJECT_0
986 if (fd_info
[cp
->fd
].flags
& FILE_LISTEN
)
987 rc
= _sys_wait_accept (cp
->fd
);
989 rc
= _sys_read_ahead (cp
->fd
);
991 if (!CHILD_ACTIVE (cp
) && cp
->procinfo
.hProcess
&& cp
->fd
>= 0)
993 /* Somebody already called delete_child on this child, since
994 only delete_child zeroes out cp->char_avail. This means
995 no one will read from cp->fd and will not set the
996 FILE_AT_EOF flag, therefore preventing sys_select from
997 noticing that the process died. Set the flag here
999 fd_info
[cp
->fd
].flags
|= FILE_AT_EOF
;
1002 /* The name char_avail is a misnomer - it really just means the
1003 read-ahead has completed, whether successfully or not. */
1004 if (!SetEvent (cp
->char_avail
))
1006 DebPrint (("reader_thread.SetEvent(0x%x) failed with %lu for fd %ld (PID %d)\n",
1007 (DWORD_PTR
)cp
->char_avail
, GetLastError (),
1012 if (rc
== STATUS_READ_ERROR
)
1015 /* If the read died, the child has died so let the thread die */
1016 if (rc
== STATUS_READ_FAILED
)
1019 /* Wait until our input is acknowledged before reading again */
1020 if (WaitForSingleObject (cp
->char_consumed
, INFINITE
) != WAIT_OBJECT_0
)
1022 DebPrint (("reader_thread.WaitForSingleObject failed with "
1023 "%lu for fd %ld\n", GetLastError (), cp
->fd
));
1030 /* To avoid Emacs changing directory, we just record here the directory
1031 the new process should start in. This is set just before calling
1032 sys_spawnve, and is not generally valid at any other time. */
1033 static char * process_dir
;
1036 create_child (char *exe
, char *cmdline
, char *env
, int is_gui_app
,
1037 int * pPid
, child_process
*cp
)
1040 SECURITY_ATTRIBUTES sec_attrs
;
1042 SECURITY_DESCRIPTOR sec_desc
;
1045 char dir
[ MAXPATHLEN
];
1047 if (cp
== NULL
) emacs_abort ();
1049 memset (&start
, 0, sizeof (start
));
1050 start
.cb
= sizeof (start
);
1053 if (NILP (Vw32_start_process_show_window
) && !is_gui_app
)
1054 start
.dwFlags
= STARTF_USESTDHANDLES
| STARTF_USESHOWWINDOW
;
1056 start
.dwFlags
= STARTF_USESTDHANDLES
;
1057 start
.wShowWindow
= SW_HIDE
;
1059 start
.hStdInput
= GetStdHandle (STD_INPUT_HANDLE
);
1060 start
.hStdOutput
= GetStdHandle (STD_OUTPUT_HANDLE
);
1061 start
.hStdError
= GetStdHandle (STD_ERROR_HANDLE
);
1062 #endif /* HAVE_NTGUI */
1065 /* Explicitly specify no security */
1066 if (!InitializeSecurityDescriptor (&sec_desc
, SECURITY_DESCRIPTOR_REVISION
))
1068 if (!SetSecurityDescriptorDacl (&sec_desc
, TRUE
, NULL
, FALSE
))
1071 sec_attrs
.nLength
= sizeof (sec_attrs
);
1072 sec_attrs
.lpSecurityDescriptor
= NULL
/* &sec_desc */;
1073 sec_attrs
.bInheritHandle
= FALSE
;
1075 strcpy (dir
, process_dir
);
1076 unixtodos_filename (dir
);
1078 flags
= (!NILP (Vw32_start_process_share_console
)
1079 ? CREATE_NEW_PROCESS_GROUP
1080 : CREATE_NEW_CONSOLE
);
1081 if (NILP (Vw32_start_process_inherit_error_mode
))
1082 flags
|= CREATE_DEFAULT_ERROR_MODE
;
1083 if (!CreateProcess (exe
, cmdline
, &sec_attrs
, NULL
, TRUE
,
1084 flags
, env
, dir
, &start
, &cp
->procinfo
))
1087 cp
->pid
= (int) cp
->procinfo
.dwProcessId
;
1089 /* Hack for Windows 95, which assigns large (ie negative) pids */
1093 /* pid must fit in a Lisp_Int */
1094 cp
->pid
= cp
->pid
& INTMASK
;
1101 DebPrint (("create_child.CreateProcess failed: %ld\n", GetLastError ()););
1105 /* create_child doesn't know what emacs' file handle will be for waiting
1106 on output from the child, so we need to make this additional call
1107 to register the handle with the process
1108 This way the select emulator knows how to match file handles with
1109 entries in child_procs. */
1111 register_child (int pid
, int fd
)
1115 cp
= find_child_pid (pid
);
1118 DebPrint (("register_child unable to find pid %lu\n", pid
));
1123 DebPrint (("register_child registered fd %d with pid %lu\n", fd
, pid
));
1128 /* thread is initially blocked until select is called; set status so
1129 that select will release thread */
1130 cp
->status
= STATUS_READ_ACKNOWLEDGED
;
1132 /* attach child_process to fd_info */
1133 if (fd_info
[fd
].cp
!= NULL
)
1135 DebPrint (("register_child: fd_info[%d] apparently in use!\n", fd
));
1139 fd_info
[fd
].cp
= cp
;
1142 /* When a process dies its pipe will break so the reader thread will
1143 signal failure to the select emulator.
1144 The select emulator then calls this routine to clean up.
1145 Since the thread signaled failure we can assume it is exiting. */
1147 reap_subprocess (child_process
*cp
)
1149 if (cp
->procinfo
.hProcess
)
1151 /* Reap the process */
1153 /* Process should have already died before we are called. */
1154 if (WaitForSingleObject (cp
->procinfo
.hProcess
, 0) != WAIT_OBJECT_0
)
1155 DebPrint (("reap_subprocess: child fpr fd %d has not died yet!", cp
->fd
));
1157 CloseHandle (cp
->procinfo
.hProcess
);
1158 cp
->procinfo
.hProcess
= NULL
;
1159 CloseHandle (cp
->procinfo
.hThread
);
1160 cp
->procinfo
.hThread
= NULL
;
1163 /* For asynchronous children, the child_proc resources will be freed
1164 when the last pipe read descriptor is closed; for synchronous
1165 children, we must explicitly free the resources now because
1166 register_child has not been called. */
1171 /* Reset the flag set by reader_thread. */
1172 fd_info
[cp
->fd
].flags
&= ~FILE_AT_EOF
;
1176 /* Wait for any of our existing child processes to die
1177 When it does, close its handle
1178 Return the pid and fill in the status if non-NULL. */
1181 sys_wait (int *status
)
1183 DWORD active
, retval
;
1186 child_process
*cp
, *cps
[MAX_CHILDREN
];
1187 HANDLE wait_hnd
[MAX_CHILDREN
];
1190 if (dead_child
!= NULL
)
1192 /* We want to wait for a specific child */
1193 wait_hnd
[nh
] = dead_child
->procinfo
.hProcess
;
1194 cps
[nh
] = dead_child
;
1195 if (!wait_hnd
[nh
]) emacs_abort ();
1202 for (cp
= child_procs
+ (child_proc_count
-1); cp
>= child_procs
; cp
--)
1203 /* some child_procs might be sockets; ignore them */
1204 if (CHILD_ACTIVE (cp
) && cp
->procinfo
.hProcess
1205 && (cp
->fd
< 0 || (fd_info
[cp
->fd
].flags
& FILE_AT_EOF
) != 0))
1207 wait_hnd
[nh
] = cp
->procinfo
.hProcess
;
1215 /* Nothing to wait on, so fail */
1222 /* Check for quit about once a second. */
1224 active
= WaitForMultipleObjects (nh
, wait_hnd
, FALSE
, 1000);
1225 } while (active
== WAIT_TIMEOUT
);
1227 if (active
== WAIT_FAILED
)
1232 else if (active
>= WAIT_OBJECT_0
1233 && active
< WAIT_OBJECT_0
+MAXIMUM_WAIT_OBJECTS
)
1235 active
-= WAIT_OBJECT_0
;
1237 else if (active
>= WAIT_ABANDONED_0
1238 && active
< WAIT_ABANDONED_0
+MAXIMUM_WAIT_OBJECTS
)
1240 active
-= WAIT_ABANDONED_0
;
1246 if (!GetExitCodeProcess (wait_hnd
[active
], &retval
))
1248 DebPrint (("Wait.GetExitCodeProcess failed with %lu\n",
1252 if (retval
== STILL_ACTIVE
)
1254 /* Should never happen */
1255 DebPrint (("Wait.WaitForMultipleObjects returned an active process\n"));
1260 /* Massage the exit code from the process to match the format expected
1261 by the WIFSTOPPED et al macros in syswait.h. Only WIFSIGNALED and
1262 WIFEXITED are supported; WIFSTOPPED doesn't make sense under NT. */
1264 if (retval
== STATUS_CONTROL_C_EXIT
)
1272 DebPrint (("Wait signaled with process pid %d\n", cp
->pid
));
1279 else if (synch_process_alive
)
1281 synch_process_alive
= 0;
1283 /* Report the status of the synchronous process. */
1284 if (WIFEXITED (retval
))
1285 synch_process_retcode
= WEXITSTATUS (retval
);
1286 else if (WIFSIGNALED (retval
))
1288 int code
= WTERMSIG (retval
);
1289 const char *signame
;
1291 synchronize_system_messages_locale ();
1292 signame
= strsignal (code
);
1295 signame
= "unknown";
1297 synch_process_death
= signame
;
1300 reap_subprocess (cp
);
1303 reap_subprocess (cp
);
1308 /* Old versions of w32api headers don't have separate 32-bit and
1309 64-bit defines, but the one they have matches the 32-bit variety. */
1310 #ifndef IMAGE_NT_OPTIONAL_HDR32_MAGIC
1311 # define IMAGE_NT_OPTIONAL_HDR32_MAGIC IMAGE_NT_OPTIONAL_HDR_MAGIC
1312 # define IMAGE_OPTIONAL_HEADER32 IMAGE_OPTIONAL_HEADER
1316 w32_executable_type (char * filename
,
1318 int * is_cygnus_app
,
1321 file_data executable
;
1324 /* Default values in case we can't tell for sure. */
1325 *is_dos_app
= FALSE
;
1326 *is_cygnus_app
= FALSE
;
1327 *is_gui_app
= FALSE
;
1329 if (!open_input_file (&executable
, filename
))
1332 p
= strrchr (filename
, '.');
1334 /* We can only identify DOS .com programs from the extension. */
1335 if (p
&& xstrcasecmp (p
, ".com") == 0)
1337 else if (p
&& (xstrcasecmp (p
, ".bat") == 0
1338 || xstrcasecmp (p
, ".cmd") == 0))
1340 /* A DOS shell script - it appears that CreateProcess is happy to
1341 accept this (somewhat surprisingly); presumably it looks at
1342 COMSPEC to determine what executable to actually invoke.
1343 Therefore, we have to do the same here as well. */
1344 /* Actually, I think it uses the program association for that
1345 extension, which is defined in the registry. */
1346 p
= egetenv ("COMSPEC");
1348 w32_executable_type (p
, is_dos_app
, is_cygnus_app
, is_gui_app
);
1352 /* Look for DOS .exe signature - if found, we must also check that
1353 it isn't really a 16- or 32-bit Windows exe, since both formats
1354 start with a DOS program stub. Note that 16-bit Windows
1355 executables use the OS/2 1.x format. */
1357 IMAGE_DOS_HEADER
* dos_header
;
1358 IMAGE_NT_HEADERS
* nt_header
;
1360 dos_header
= (PIMAGE_DOS_HEADER
) executable
.file_base
;
1361 if (dos_header
->e_magic
!= IMAGE_DOS_SIGNATURE
)
1364 nt_header
= (PIMAGE_NT_HEADERS
) ((unsigned char *) dos_header
+ dos_header
->e_lfanew
);
1366 if ((char *) nt_header
> (char *) dos_header
+ executable
.size
)
1368 /* Some dos headers (pkunzip) have bogus e_lfanew fields. */
1371 else if (nt_header
->Signature
!= IMAGE_NT_SIGNATURE
1372 && LOWORD (nt_header
->Signature
) != IMAGE_OS2_SIGNATURE
)
1376 else if (nt_header
->Signature
== IMAGE_NT_SIGNATURE
)
1378 IMAGE_DATA_DIRECTORY
*data_dir
= NULL
;
1379 if (nt_header
->OptionalHeader
.Magic
== IMAGE_NT_OPTIONAL_HDR32_MAGIC
)
1381 /* Ensure we are using the 32 bit structure. */
1382 IMAGE_OPTIONAL_HEADER32
*opt
1383 = (IMAGE_OPTIONAL_HEADER32
*) &(nt_header
->OptionalHeader
);
1384 data_dir
= opt
->DataDirectory
;
1385 *is_gui_app
= (opt
->Subsystem
== IMAGE_SUBSYSTEM_WINDOWS_GUI
);
1387 /* MingW 3.12 has the required 64 bit structs, but in case older
1388 versions don't, only check 64 bit exes if we know how. */
1389 #ifdef IMAGE_NT_OPTIONAL_HDR64_MAGIC
1390 else if (nt_header
->OptionalHeader
.Magic
1391 == IMAGE_NT_OPTIONAL_HDR64_MAGIC
)
1393 IMAGE_OPTIONAL_HEADER64
*opt
1394 = (IMAGE_OPTIONAL_HEADER64
*) &(nt_header
->OptionalHeader
);
1395 data_dir
= opt
->DataDirectory
;
1396 *is_gui_app
= (opt
->Subsystem
== IMAGE_SUBSYSTEM_WINDOWS_GUI
);
1401 /* Look for cygwin.dll in DLL import list. */
1402 IMAGE_DATA_DIRECTORY import_dir
=
1403 data_dir
[IMAGE_DIRECTORY_ENTRY_IMPORT
];
1404 IMAGE_IMPORT_DESCRIPTOR
* imports
;
1405 IMAGE_SECTION_HEADER
* section
;
1407 section
= rva_to_section (import_dir
.VirtualAddress
, nt_header
);
1408 imports
= RVA_TO_PTR (import_dir
.VirtualAddress
, section
,
1411 for ( ; imports
->Name
; imports
++)
1413 char * dllname
= RVA_TO_PTR (imports
->Name
, section
,
1416 /* The exact name of the cygwin dll has changed with
1417 various releases, but hopefully this will be reasonably
1419 if (strncmp (dllname
, "cygwin", 6) == 0)
1421 *is_cygnus_app
= TRUE
;
1430 close_file_data (&executable
);
1434 compare_env (const void *strp1
, const void *strp2
)
1436 const char *str1
= *(const char **)strp1
, *str2
= *(const char **)strp2
;
1438 while (*str1
&& *str2
&& *str1
!= '=' && *str2
!= '=')
1440 /* Sort order in command.com/cmd.exe is based on uppercasing
1441 names, so do the same here. */
1442 if (toupper (*str1
) > toupper (*str2
))
1444 else if (toupper (*str1
) < toupper (*str2
))
1449 if (*str1
== '=' && *str2
== '=')
1451 else if (*str1
== '=')
1458 merge_and_sort_env (char **envp1
, char **envp2
, char **new_envp
)
1460 char **optr
, **nptr
;
1472 num
+= optr
- envp2
;
1474 qsort (new_envp
, num
, sizeof (char *), compare_env
);
1479 /* When a new child process is created we need to register it in our list,
1480 so intercept spawn requests. */
1482 sys_spawnve (int mode
, char *cmdname
, char **argv
, char **envp
)
1484 Lisp_Object program
, full
;
1485 char *cmdline
, *env
, *parg
, **targ
;
1489 int is_dos_app
, is_cygnus_app
, is_gui_app
;
1491 /* We pass our process ID to our children by setting up an environment
1492 variable in their environment. */
1493 char ppid_env_var_buffer
[64];
1494 char *extra_env
[] = {ppid_env_var_buffer
, NULL
};
1495 /* These are the characters that cause an argument to need quoting.
1496 Arguments with whitespace characters need quoting to prevent the
1497 argument being split into two or more. Arguments with wildcards
1498 are also quoted, for consistency with posix platforms, where wildcards
1499 are not expanded if we run the program directly without a shell.
1500 Some extra whitespace characters need quoting in Cygwin programs,
1501 so this list is conditionally modified below. */
1502 char *sepchars
= " \t*?";
1503 /* This is for native w32 apps; modified below for Cygwin apps. */
1504 char escape_char
= '\\';
1506 /* We don't care about the other modes */
1507 if (mode
!= _P_NOWAIT
)
1513 /* Handle executable names without an executable suffix. */
1514 program
= build_string (cmdname
);
1515 if (NILP (Ffile_executable_p (program
)))
1517 struct gcpro gcpro1
;
1521 openp (Vexec_path
, program
, Vexec_suffixes
, &full
, make_number (X_OK
));
1531 /* make sure argv[0] and cmdname are both in DOS format */
1532 cmdname
= SDATA (program
);
1533 unixtodos_filename (cmdname
);
1536 /* Determine whether program is a 16-bit DOS executable, or a 32-bit Windows
1537 executable that is implicitly linked to the Cygnus dll (implying it
1538 was compiled with the Cygnus GNU toolchain and hence relies on
1539 cygwin.dll to parse the command line - we use this to decide how to
1540 escape quote chars in command line args that must be quoted).
1542 Also determine whether it is a GUI app, so that we don't hide its
1543 initial window unless specifically requested. */
1544 w32_executable_type (cmdname
, &is_dos_app
, &is_cygnus_app
, &is_gui_app
);
1546 /* On Windows 95, if cmdname is a DOS app, we invoke a helper
1547 application to start it by specifying the helper app as cmdname,
1548 while leaving the real app name as argv[0]. */
1551 cmdname
= alloca (MAXPATHLEN
);
1552 if (egetenv ("CMDPROXY"))
1553 strcpy (cmdname
, egetenv ("CMDPROXY"));
1556 strcpy (cmdname
, SDATA (Vinvocation_directory
));
1557 strcat (cmdname
, "cmdproxy.exe");
1559 unixtodos_filename (cmdname
);
1562 /* we have to do some conjuring here to put argv and envp into the
1563 form CreateProcess wants... argv needs to be a space separated/null
1564 terminated list of parameters, and envp is a null
1565 separated/double-null terminated list of parameters.
1567 Additionally, zero-length args and args containing whitespace or
1568 quote chars need to be wrapped in double quotes - for this to work,
1569 embedded quotes need to be escaped as well. The aim is to ensure
1570 the child process reconstructs the argv array we start with
1571 exactly, so we treat quotes at the beginning and end of arguments
1574 The w32 GNU-based library from Cygnus doubles quotes to escape
1575 them, while MSVC uses backslash for escaping. (Actually the MSVC
1576 startup code does attempt to recognize doubled quotes and accept
1577 them, but gets it wrong and ends up requiring three quotes to get a
1578 single embedded quote!) So by default we decide whether to use
1579 quote or backslash as the escape character based on whether the
1580 binary is apparently a Cygnus compiled app.
1582 Note that using backslash to escape embedded quotes requires
1583 additional special handling if an embedded quote is already
1584 preceded by backslash, or if an arg requiring quoting ends with
1585 backslash. In such cases, the run of escape characters needs to be
1586 doubled. For consistency, we apply this special handling as long
1587 as the escape character is not quote.
1589 Since we have no idea how large argv and envp are likely to be we
1590 figure out list lengths on the fly and allocate them. */
1592 if (!NILP (Vw32_quote_process_args
))
1595 /* Override escape char by binding w32-quote-process-args to
1596 desired character, or use t for auto-selection. */
1597 if (INTEGERP (Vw32_quote_process_args
))
1598 escape_char
= XINT (Vw32_quote_process_args
);
1600 escape_char
= is_cygnus_app
? '"' : '\\';
1603 /* Cygwin apps needs quoting a bit more often. */
1604 if (escape_char
== '"')
1605 sepchars
= "\r\n\t\f '";
1613 int need_quotes
= 0;
1614 int escape_char_run
= 0;
1620 if (escape_char
== '"' && *p
== '\\')
1621 /* If it's a Cygwin app, \ needs to be escaped. */
1625 /* allow for embedded quotes to be escaped */
1628 /* handle the case where the embedded quote is already escaped */
1629 if (escape_char_run
> 0)
1631 /* To preserve the arg exactly, we need to double the
1632 preceding escape characters (plus adding one to
1633 escape the quote character itself). */
1634 arglen
+= escape_char_run
;
1637 else if (strchr (sepchars
, *p
) != NULL
)
1642 if (*p
== escape_char
&& escape_char
!= '"')
1645 escape_char_run
= 0;
1650 /* handle the case where the arg ends with an escape char - we
1651 must not let the enclosing quote be escaped. */
1652 if (escape_char_run
> 0)
1653 arglen
+= escape_char_run
;
1655 arglen
+= strlen (*targ
++) + 1;
1657 cmdline
= alloca (arglen
);
1663 int need_quotes
= 0;
1671 if ((strchr (sepchars
, *p
) != NULL
) || *p
== '"')
1676 int escape_char_run
= 0;
1682 last
= p
+ strlen (p
) - 1;
1685 /* This version does not escape quotes if they occur at the
1686 beginning or end of the arg - this could lead to incorrect
1687 behavior when the arg itself represents a command line
1688 containing quoted args. I believe this was originally done
1689 as a hack to make some things work, before
1690 `w32-quote-process-args' was added. */
1693 if (*p
== '"' && p
> first
&& p
< last
)
1694 *parg
++ = escape_char
; /* escape embedded quotes */
1702 /* double preceding escape chars if any */
1703 while (escape_char_run
> 0)
1705 *parg
++ = escape_char
;
1708 /* escape all quote chars, even at beginning or end */
1709 *parg
++ = escape_char
;
1711 else if (escape_char
== '"' && *p
== '\\')
1715 if (*p
== escape_char
&& escape_char
!= '"')
1718 escape_char_run
= 0;
1720 /* double escape chars before enclosing quote */
1721 while (escape_char_run
> 0)
1723 *parg
++ = escape_char
;
1731 strcpy (parg
, *targ
);
1732 parg
+= strlen (*targ
);
1742 numenv
= 1; /* for end null */
1745 arglen
+= strlen (*targ
++) + 1;
1748 /* extra env vars... */
1749 sprintf (ppid_env_var_buffer
, "EM_PARENT_PROCESS_ID=%lu",
1750 GetCurrentProcessId ());
1751 arglen
+= strlen (ppid_env_var_buffer
) + 1;
1754 /* merge env passed in and extra env into one, and sort it. */
1755 targ
= (char **) alloca (numenv
* sizeof (char *));
1756 merge_and_sort_env (envp
, extra_env
, targ
);
1758 /* concatenate env entries. */
1759 env
= alloca (arglen
);
1763 strcpy (parg
, *targ
);
1764 parg
+= strlen (*targ
++);
1777 /* Now create the process. */
1778 if (!create_child (cmdname
, cmdline
, env
, is_gui_app
, &pid
, cp
))
1788 /* Emulate the select call
1789 Wait for available input on any of the given rfds, or timeout if
1790 a timeout is given and no input is detected
1791 wfds and efds are not supported and must be NULL.
1793 For simplicity, we detect the death of child processes here and
1794 synchronously call the SIGCHLD handler. Since it is possible for
1795 children to be created without a corresponding pipe handle from which
1796 to read output, we wait separately on the process handles as well as
1797 the char_avail events for each process pipe. We only call
1798 wait/reap_process when the process actually terminates.
1800 To reduce the number of places in which Emacs can be hung such that
1801 C-g is not able to interrupt it, we always wait on interrupt_handle
1802 (which is signaled by the input thread when C-g is detected). If we
1803 detect that we were woken up by C-g, we return -1 with errno set to
1804 EINTR as on Unix. */
1806 /* From w32console.c */
1807 extern HANDLE keyboard_handle
;
1809 /* From w32xfns.c */
1810 extern HANDLE interrupt_handle
;
1812 /* From process.c */
1813 extern int proc_buffered_char
[];
1816 sys_select (int nfds
, SELECT_TYPE
*rfds
, SELECT_TYPE
*wfds
, SELECT_TYPE
*efds
,
1817 EMACS_TIME
*timeout
, void *ignored
)
1820 DWORD timeout_ms
, start_time
;
1823 child_process
*cp
, *cps
[MAX_CHILDREN
];
1824 HANDLE wait_hnd
[MAXDESC
+ MAX_CHILDREN
];
1825 int fdindex
[MAXDESC
]; /* mapping from wait handles back to descriptors */
1828 timeout
? (timeout
->tv_sec
* 1000 + timeout
->tv_nsec
/ 1000000) : INFINITE
;
1830 /* If the descriptor sets are NULL but timeout isn't, then just Sleep. */
1831 if (rfds
== NULL
&& wfds
== NULL
&& efds
== NULL
&& timeout
!= NULL
)
1837 /* Otherwise, we only handle rfds, so fail otherwise. */
1838 if (rfds
== NULL
|| wfds
!= NULL
|| efds
!= NULL
)
1848 /* Always wait on interrupt_handle, to detect C-g (quit). */
1849 wait_hnd
[0] = interrupt_handle
;
1852 /* Build a list of pipe handles to wait on. */
1854 for (i
= 0; i
< nfds
; i
++)
1855 if (FD_ISSET (i
, &orfds
))
1859 if (keyboard_handle
)
1861 /* Handle stdin specially */
1862 wait_hnd
[nh
] = keyboard_handle
;
1867 /* Check for any emacs-generated input in the queue since
1868 it won't be detected in the wait */
1869 if (detect_input_pending ())
1877 /* Child process and socket input */
1881 int current_status
= cp
->status
;
1883 if (current_status
== STATUS_READ_ACKNOWLEDGED
)
1885 /* Tell reader thread which file handle to use. */
1887 /* Wake up the reader thread for this process */
1888 cp
->status
= STATUS_READ_READY
;
1889 if (!SetEvent (cp
->char_consumed
))
1890 DebPrint (("nt_select.SetEvent failed with "
1891 "%lu for fd %ld\n", GetLastError (), i
));
1894 #ifdef CHECK_INTERLOCK
1895 /* slightly crude cross-checking of interlock between threads */
1897 current_status
= cp
->status
;
1898 if (WaitForSingleObject (cp
->char_avail
, 0) == WAIT_OBJECT_0
)
1900 /* char_avail has been signaled, so status (which may
1901 have changed) should indicate read has completed
1902 but has not been acknowledged. */
1903 current_status
= cp
->status
;
1904 if (current_status
!= STATUS_READ_SUCCEEDED
1905 && current_status
!= STATUS_READ_FAILED
)
1906 DebPrint (("char_avail set, but read not completed: status %d\n",
1911 /* char_avail has not been signaled, so status should
1912 indicate that read is in progress; small possibility
1913 that read has completed but event wasn't yet signaled
1914 when we tested it (because a context switch occurred
1915 or if running on separate CPUs). */
1916 if (current_status
!= STATUS_READ_READY
1917 && current_status
!= STATUS_READ_IN_PROGRESS
1918 && current_status
!= STATUS_READ_SUCCEEDED
1919 && current_status
!= STATUS_READ_FAILED
)
1920 DebPrint (("char_avail reset, but read status is bad: %d\n",
1924 wait_hnd
[nh
] = cp
->char_avail
;
1926 if (!wait_hnd
[nh
]) emacs_abort ();
1929 DebPrint (("select waiting on child %d fd %d\n",
1930 cp
-child_procs
, i
));
1935 /* Unable to find something to wait on for this fd, skip */
1937 /* Note that this is not a fatal error, and can in fact
1938 happen in unusual circumstances. Specifically, if
1939 sys_spawnve fails, eg. because the program doesn't
1940 exist, and debug-on-error is t so Fsignal invokes a
1941 nested input loop, then the process output pipe is
1942 still included in input_wait_mask with no child_proc
1943 associated with it. (It is removed when the debugger
1944 exits the nested input loop and the error is thrown.) */
1946 DebPrint (("sys_select: fd %ld is invalid! ignoring\n", i
));
1952 /* Add handles of child processes. */
1954 for (cp
= child_procs
+ (child_proc_count
-1); cp
>= child_procs
; cp
--)
1955 /* Some child_procs might be sockets; ignore them. Also some
1956 children may have died already, but we haven't finished reading
1957 the process output; ignore them too. */
1958 if ((CHILD_ACTIVE (cp
) || cp
->procinfo
.hProcess
)
1960 || (fd_info
[cp
->fd
].flags
& FILE_SEND_SIGCHLD
) == 0
1961 || (fd_info
[cp
->fd
].flags
& FILE_AT_EOF
) != 0)
1964 wait_hnd
[nh
+ nc
] = cp
->procinfo
.hProcess
;
1969 /* Nothing to look for, so we didn't find anything */
1977 start_time
= GetTickCount ();
1979 /* Wait for input or child death to be signaled. If user input is
1980 allowed, then also accept window messages. */
1981 if (FD_ISSET (0, &orfds
))
1982 active
= MsgWaitForMultipleObjects (nh
+ nc
, wait_hnd
, FALSE
, timeout_ms
,
1985 active
= WaitForMultipleObjects (nh
+ nc
, wait_hnd
, FALSE
, timeout_ms
);
1987 if (active
== WAIT_FAILED
)
1989 DebPrint (("select.WaitForMultipleObjects (%d, %lu) failed with %lu\n",
1990 nh
+ nc
, timeout_ms
, GetLastError ()));
1991 /* don't return EBADF - this causes wait_reading_process_output to
1992 abort; WAIT_FAILED is returned when single-stepping under
1993 Windows 95 after switching thread focus in debugger, and
1994 possibly at other times. */
1998 else if (active
== WAIT_TIMEOUT
)
2002 else if (active
>= WAIT_OBJECT_0
2003 && active
< WAIT_OBJECT_0
+MAXIMUM_WAIT_OBJECTS
)
2005 active
-= WAIT_OBJECT_0
;
2007 else if (active
>= WAIT_ABANDONED_0
2008 && active
< WAIT_ABANDONED_0
+MAXIMUM_WAIT_OBJECTS
)
2010 active
-= WAIT_ABANDONED_0
;
2015 /* Loop over all handles after active (now officially documented as
2016 being the first signaled handle in the array). We do this to
2017 ensure fairness, so that all channels with data available will be
2018 processed - otherwise higher numbered channels could be starved. */
2021 if (active
== nh
+ nc
)
2023 /* There are messages in the lisp thread's queue; we must
2024 drain the queue now to ensure they are processed promptly,
2025 because if we don't do so, we will not be woken again until
2026 further messages arrive.
2028 NB. If ever we allow window message procedures to callback
2029 into lisp, we will need to ensure messages are dispatched
2030 at a safe time for lisp code to be run (*), and we may also
2031 want to provide some hooks in the dispatch loop to cater
2032 for modeless dialogs created by lisp (ie. to register
2033 window handles to pass to IsDialogMessage).
2035 (*) Note that MsgWaitForMultipleObjects above is an
2036 internal dispatch point for messages that are sent to
2037 windows created by this thread. */
2038 drain_message_queue ();
2040 else if (active
>= nh
)
2042 cp
= cps
[active
- nh
];
2044 /* We cannot always signal SIGCHLD immediately; if we have not
2045 finished reading the process output, we must delay sending
2046 SIGCHLD until we do. */
2048 if (cp
->fd
>= 0 && (fd_info
[cp
->fd
].flags
& FILE_AT_EOF
) == 0)
2049 fd_info
[cp
->fd
].flags
|= FILE_SEND_SIGCHLD
;
2050 /* SIG_DFL for SIGCHLD is ignore */
2051 else if (sig_handlers
[SIGCHLD
] != SIG_DFL
&&
2052 sig_handlers
[SIGCHLD
] != SIG_IGN
)
2055 DebPrint (("select calling SIGCHLD handler for pid %d\n",
2059 sig_handlers
[SIGCHLD
] (SIGCHLD
);
2063 else if (fdindex
[active
] == -1)
2065 /* Quit (C-g) was detected. */
2069 else if (fdindex
[active
] == 0)
2071 /* Keyboard input available */
2077 /* must be a socket or pipe - read ahead should have
2078 completed, either succeeding or failing. */
2079 FD_SET (fdindex
[active
], rfds
);
2083 /* Even though wait_reading_process_output only reads from at most
2084 one channel, we must process all channels here so that we reap
2085 all children that have died. */
2086 while (++active
< nh
+ nc
)
2087 if (WaitForSingleObject (wait_hnd
[active
], 0) == WAIT_OBJECT_0
)
2089 } while (active
< nh
+ nc
);
2091 /* If no input has arrived and timeout hasn't expired, wait again. */
2094 DWORD elapsed
= GetTickCount () - start_time
;
2096 if (timeout_ms
> elapsed
) /* INFINITE is MAX_UINT */
2098 if (timeout_ms
!= INFINITE
)
2099 timeout_ms
-= elapsed
;
2100 goto count_children
;
2107 /* Substitute for certain kill () operations */
2109 static BOOL CALLBACK
2110 find_child_console (HWND hwnd
, LPARAM arg
)
2112 child_process
* cp
= (child_process
*) arg
;
2116 thread_id
= GetWindowThreadProcessId (hwnd
, &process_id
);
2117 if (process_id
== cp
->procinfo
.dwProcessId
)
2119 char window_class
[32];
2121 GetClassName (hwnd
, window_class
, sizeof (window_class
));
2122 if (strcmp (window_class
,
2123 (os_subtype
== OS_9X
)
2125 : "ConsoleWindowClass") == 0)
2135 /* Emulate 'kill', but only for other processes. */
2137 sys_kill (int pid
, int sig
)
2141 int need_to_free
= 0;
2144 /* Only handle signals that will result in the process dying */
2145 if (sig
!= SIGINT
&& sig
!= SIGKILL
&& sig
!= SIGQUIT
&& sig
!= SIGHUP
)
2151 cp
= find_child_pid (pid
);
2154 /* We were passed a PID of something other than our subprocess.
2155 If that is our own PID, we will send to ourself a message to
2156 close the selected frame, which does not necessarily
2157 terminates Emacs. But then we are not supposed to call
2158 sys_kill with our own PID. */
2159 proc_hand
= OpenProcess (PROCESS_TERMINATE
, 0, pid
);
2160 if (proc_hand
== NULL
)
2169 proc_hand
= cp
->procinfo
.hProcess
;
2170 pid
= cp
->procinfo
.dwProcessId
;
2172 /* Try to locate console window for process. */
2173 EnumWindows (find_child_console
, (LPARAM
) cp
);
2176 if (sig
== SIGINT
|| sig
== SIGQUIT
)
2178 if (NILP (Vw32_start_process_share_console
) && cp
&& cp
->hwnd
)
2180 BYTE control_scan_code
= (BYTE
) MapVirtualKey (VK_CONTROL
, 0);
2181 /* Fake Ctrl-C for SIGINT, and Ctrl-Break for SIGQUIT. */
2182 BYTE vk_break_code
= (sig
== SIGINT
) ? 'C' : VK_CANCEL
;
2183 BYTE break_scan_code
= (BYTE
) MapVirtualKey (vk_break_code
, 0);
2184 HWND foreground_window
;
2186 if (break_scan_code
== 0)
2188 /* Fake Ctrl-C for SIGQUIT if we can't manage Ctrl-Break. */
2189 vk_break_code
= 'C';
2190 break_scan_code
= (BYTE
) MapVirtualKey (vk_break_code
, 0);
2193 foreground_window
= GetForegroundWindow ();
2194 if (foreground_window
)
2196 /* NT 5.0, and apparently also Windows 98, will not allow
2197 a Window to be set to foreground directly without the
2198 user's involvement. The workaround is to attach
2199 ourselves to the thread that owns the foreground
2200 window, since that is the only thread that can set the
2201 foreground window. */
2202 DWORD foreground_thread
, child_thread
;
2204 GetWindowThreadProcessId (foreground_window
, NULL
);
2205 if (foreground_thread
== GetCurrentThreadId ()
2206 || !AttachThreadInput (GetCurrentThreadId (),
2207 foreground_thread
, TRUE
))
2208 foreground_thread
= 0;
2210 child_thread
= GetWindowThreadProcessId (cp
->hwnd
, NULL
);
2211 if (child_thread
== GetCurrentThreadId ()
2212 || !AttachThreadInput (GetCurrentThreadId (),
2213 child_thread
, TRUE
))
2216 /* Set the foreground window to the child. */
2217 if (SetForegroundWindow (cp
->hwnd
))
2219 /* Generate keystrokes as if user had typed Ctrl-Break or
2221 keybd_event (VK_CONTROL
, control_scan_code
, 0, 0);
2222 keybd_event (vk_break_code
, break_scan_code
,
2223 (vk_break_code
== 'C' ? 0 : KEYEVENTF_EXTENDEDKEY
), 0);
2224 keybd_event (vk_break_code
, break_scan_code
,
2225 (vk_break_code
== 'C' ? 0 : KEYEVENTF_EXTENDEDKEY
)
2226 | KEYEVENTF_KEYUP
, 0);
2227 keybd_event (VK_CONTROL
, control_scan_code
,
2228 KEYEVENTF_KEYUP
, 0);
2230 /* Sleep for a bit to give time for Emacs frame to respond
2231 to focus change events (if Emacs was active app). */
2234 SetForegroundWindow (foreground_window
);
2236 /* Detach from the foreground and child threads now that
2237 the foreground switching is over. */
2238 if (foreground_thread
)
2239 AttachThreadInput (GetCurrentThreadId (),
2240 foreground_thread
, FALSE
);
2242 AttachThreadInput (GetCurrentThreadId (),
2243 child_thread
, FALSE
);
2246 /* Ctrl-Break is NT equivalent of SIGINT. */
2247 else if (!GenerateConsoleCtrlEvent (CTRL_BREAK_EVENT
, pid
))
2249 DebPrint (("sys_kill.GenerateConsoleCtrlEvent return %d "
2250 "for pid %lu\n", GetLastError (), pid
));
2257 if (NILP (Vw32_start_process_share_console
) && cp
&& cp
->hwnd
)
2260 if (os_subtype
== OS_9X
)
2263 Another possibility is to try terminating the VDM out-right by
2264 calling the Shell VxD (id 0x17) V86 interface, function #4
2265 "SHELL_Destroy_VM", ie.
2271 First need to determine the current VM handle, and then arrange for
2272 the shellapi call to be made from the system vm (by using
2273 Switch_VM_and_callback).
2275 Could try to invoke DestroyVM through CallVxD.
2279 /* On Windows 95, posting WM_QUIT causes the 16-bit subsystem
2280 to hang when cmdproxy is used in conjunction with
2281 command.com for an interactive shell. Posting
2282 WM_CLOSE pops up a dialog that, when Yes is selected,
2283 does the same thing. TerminateProcess is also less
2284 than ideal in that subprocesses tend to stick around
2285 until the machine is shutdown, but at least it
2286 doesn't freeze the 16-bit subsystem. */
2287 PostMessage (cp
->hwnd
, WM_QUIT
, 0xff, 0);
2289 if (!TerminateProcess (proc_hand
, 0xff))
2291 DebPrint (("sys_kill.TerminateProcess returned %d "
2292 "for pid %lu\n", GetLastError (), pid
));
2299 PostMessage (cp
->hwnd
, WM_CLOSE
, 0, 0);
2301 /* Kill the process. On W32 this doesn't kill child processes
2302 so it doesn't work very well for shells which is why it's not
2303 used in every case. */
2304 else if (!TerminateProcess (proc_hand
, 0xff))
2306 DebPrint (("sys_kill.TerminateProcess returned %d "
2307 "for pid %lu\n", GetLastError (), pid
));
2314 CloseHandle (proc_hand
);
2319 /* The following two routines are used to manipulate stdin, stdout, and
2320 stderr of our child processes.
2322 Assuming that in, out, and err are *not* inheritable, we make them
2323 stdin, stdout, and stderr of the child as follows:
2325 - Save the parent's current standard handles.
2326 - Set the std handles to inheritable duplicates of the ones being passed in.
2327 (Note that _get_osfhandle() is an io.h procedure that retrieves the
2328 NT file handle for a crt file descriptor.)
2329 - Spawn the child, which inherits in, out, and err as stdin,
2330 stdout, and stderr. (see Spawnve)
2331 - Close the std handles passed to the child.
2332 - Reset the parent's standard handles to the saved handles.
2333 (see reset_standard_handles)
2334 We assume that the caller closes in, out, and err after calling us. */
2337 prepare_standard_handles (int in
, int out
, int err
, HANDLE handles
[3])
2340 HANDLE newstdin
, newstdout
, newstderr
;
2342 parent
= GetCurrentProcess ();
2344 handles
[0] = GetStdHandle (STD_INPUT_HANDLE
);
2345 handles
[1] = GetStdHandle (STD_OUTPUT_HANDLE
);
2346 handles
[2] = GetStdHandle (STD_ERROR_HANDLE
);
2348 /* make inheritable copies of the new handles */
2349 if (!DuplicateHandle (parent
,
2350 (HANDLE
) _get_osfhandle (in
),
2355 DUPLICATE_SAME_ACCESS
))
2356 report_file_error ("Duplicating input handle for child", Qnil
);
2358 if (!DuplicateHandle (parent
,
2359 (HANDLE
) _get_osfhandle (out
),
2364 DUPLICATE_SAME_ACCESS
))
2365 report_file_error ("Duplicating output handle for child", Qnil
);
2367 if (!DuplicateHandle (parent
,
2368 (HANDLE
) _get_osfhandle (err
),
2373 DUPLICATE_SAME_ACCESS
))
2374 report_file_error ("Duplicating error handle for child", Qnil
);
2376 /* and store them as our std handles */
2377 if (!SetStdHandle (STD_INPUT_HANDLE
, newstdin
))
2378 report_file_error ("Changing stdin handle", Qnil
);
2380 if (!SetStdHandle (STD_OUTPUT_HANDLE
, newstdout
))
2381 report_file_error ("Changing stdout handle", Qnil
);
2383 if (!SetStdHandle (STD_ERROR_HANDLE
, newstderr
))
2384 report_file_error ("Changing stderr handle", Qnil
);
2388 reset_standard_handles (int in
, int out
, int err
, HANDLE handles
[3])
2390 /* close the duplicated handles passed to the child */
2391 CloseHandle (GetStdHandle (STD_INPUT_HANDLE
));
2392 CloseHandle (GetStdHandle (STD_OUTPUT_HANDLE
));
2393 CloseHandle (GetStdHandle (STD_ERROR_HANDLE
));
2395 /* now restore parent's saved std handles */
2396 SetStdHandle (STD_INPUT_HANDLE
, handles
[0]);
2397 SetStdHandle (STD_OUTPUT_HANDLE
, handles
[1]);
2398 SetStdHandle (STD_ERROR_HANDLE
, handles
[2]);
2402 set_process_dir (char * dir
)
2407 /* To avoid problems with winsock implementations that work over dial-up
2408 connections causing or requiring a connection to exist while Emacs is
2409 running, Emacs no longer automatically loads winsock on startup if it
2410 is present. Instead, it will be loaded when open-network-stream is
2413 To allow full control over when winsock is loaded, we provide these
2414 two functions to dynamically load and unload winsock. This allows
2415 dial-up users to only be connected when they actually need to use
2419 extern HANDLE winsock_lib
;
2420 extern BOOL
term_winsock (void);
2421 extern BOOL
init_winsock (int load_now
);
2423 DEFUN ("w32-has-winsock", Fw32_has_winsock
, Sw32_has_winsock
, 0, 1, 0,
2424 doc
: /* Test for presence of the Windows socket library `winsock'.
2425 Returns non-nil if winsock support is present, nil otherwise.
2427 If the optional argument LOAD-NOW is non-nil, the winsock library is
2428 also loaded immediately if not already loaded. If winsock is loaded,
2429 the winsock local hostname is returned (since this may be different from
2430 the value of `system-name' and should supplant it), otherwise t is
2431 returned to indicate winsock support is present. */)
2432 (Lisp_Object load_now
)
2436 have_winsock
= init_winsock (!NILP (load_now
));
2439 if (winsock_lib
!= NULL
)
2441 /* Return new value for system-name. The best way to do this
2442 is to call init_system_name, saving and restoring the
2443 original value to avoid side-effects. */
2444 Lisp_Object orig_hostname
= Vsystem_name
;
2445 Lisp_Object hostname
;
2447 init_system_name ();
2448 hostname
= Vsystem_name
;
2449 Vsystem_name
= orig_hostname
;
2457 DEFUN ("w32-unload-winsock", Fw32_unload_winsock
, Sw32_unload_winsock
,
2459 doc
: /* Unload the Windows socket library `winsock' if loaded.
2460 This is provided to allow dial-up socket connections to be disconnected
2461 when no longer needed. Returns nil without unloading winsock if any
2462 socket connections still exist. */)
2465 return term_winsock () ? Qt
: Qnil
;
2469 /* Some miscellaneous functions that are Windows specific, but not GUI
2470 specific (ie. are applicable in terminal or batch mode as well). */
2472 DEFUN ("w32-short-file-name", Fw32_short_file_name
, Sw32_short_file_name
, 1, 1, 0,
2473 doc
: /* Return the short file name version (8.3) of the full path of FILENAME.
2474 If FILENAME does not exist, return nil.
2475 All path elements in FILENAME are converted to their short names. */)
2476 (Lisp_Object filename
)
2478 char shortname
[MAX_PATH
];
2480 CHECK_STRING (filename
);
2482 /* first expand it. */
2483 filename
= Fexpand_file_name (filename
, Qnil
);
2485 /* luckily, this returns the short version of each element in the path. */
2486 if (GetShortPathName (SDATA (ENCODE_FILE (filename
)), shortname
, MAX_PATH
) == 0)
2489 dostounix_filename (shortname
);
2491 return build_string (shortname
);
2495 DEFUN ("w32-long-file-name", Fw32_long_file_name
, Sw32_long_file_name
,
2497 doc
: /* Return the long file name version of the full path of FILENAME.
2498 If FILENAME does not exist, return nil.
2499 All path elements in FILENAME are converted to their long names. */)
2500 (Lisp_Object filename
)
2502 char longname
[ MAX_PATH
];
2505 CHECK_STRING (filename
);
2507 if (SBYTES (filename
) == 2
2508 && *(SDATA (filename
) + 1) == ':')
2511 /* first expand it. */
2512 filename
= Fexpand_file_name (filename
, Qnil
);
2514 if (!w32_get_long_filename (SDATA (ENCODE_FILE (filename
)), longname
, MAX_PATH
))
2517 dostounix_filename (longname
);
2519 /* If we were passed only a drive, make sure that a slash is not appended
2520 for consistency with directories. Allow for drive mapping via SUBST
2521 in case expand-file-name is ever changed to expand those. */
2522 if (drive_only
&& longname
[1] == ':' && longname
[2] == '/' && !longname
[3])
2525 return DECODE_FILE (build_string (longname
));
2528 DEFUN ("w32-set-process-priority", Fw32_set_process_priority
,
2529 Sw32_set_process_priority
, 2, 2, 0,
2530 doc
: /* Set the priority of PROCESS to PRIORITY.
2531 If PROCESS is nil, the priority of Emacs is changed, otherwise the
2532 priority of the process whose pid is PROCESS is changed.
2533 PRIORITY should be one of the symbols high, normal, or low;
2534 any other symbol will be interpreted as normal.
2536 If successful, the return value is t, otherwise nil. */)
2537 (Lisp_Object process
, Lisp_Object priority
)
2539 HANDLE proc_handle
= GetCurrentProcess ();
2540 DWORD priority_class
= NORMAL_PRIORITY_CLASS
;
2541 Lisp_Object result
= Qnil
;
2543 CHECK_SYMBOL (priority
);
2545 if (!NILP (process
))
2550 CHECK_NUMBER (process
);
2552 /* Allow pid to be an internally generated one, or one obtained
2553 externally. This is necessary because real pids on Windows 95 are
2556 pid
= XINT (process
);
2557 cp
= find_child_pid (pid
);
2559 pid
= cp
->procinfo
.dwProcessId
;
2561 proc_handle
= OpenProcess (PROCESS_SET_INFORMATION
, FALSE
, pid
);
2564 if (EQ (priority
, Qhigh
))
2565 priority_class
= HIGH_PRIORITY_CLASS
;
2566 else if (EQ (priority
, Qlow
))
2567 priority_class
= IDLE_PRIORITY_CLASS
;
2569 if (proc_handle
!= NULL
)
2571 if (SetPriorityClass (proc_handle
, priority_class
))
2573 if (!NILP (process
))
2574 CloseHandle (proc_handle
);
2580 #ifdef HAVE_LANGINFO_CODESET
2581 /* Emulation of nl_langinfo. Used in fns.c:Flocale_info. */
2583 nl_langinfo (nl_item item
)
2585 /* Conversion of Posix item numbers to their Windows equivalents. */
2586 static const LCTYPE w32item
[] = {
2587 LOCALE_IDEFAULTANSICODEPAGE
,
2588 LOCALE_SDAYNAME1
, LOCALE_SDAYNAME2
, LOCALE_SDAYNAME3
,
2589 LOCALE_SDAYNAME4
, LOCALE_SDAYNAME5
, LOCALE_SDAYNAME6
, LOCALE_SDAYNAME7
,
2590 LOCALE_SMONTHNAME1
, LOCALE_SMONTHNAME2
, LOCALE_SMONTHNAME3
,
2591 LOCALE_SMONTHNAME4
, LOCALE_SMONTHNAME5
, LOCALE_SMONTHNAME6
,
2592 LOCALE_SMONTHNAME7
, LOCALE_SMONTHNAME8
, LOCALE_SMONTHNAME9
,
2593 LOCALE_SMONTHNAME10
, LOCALE_SMONTHNAME11
, LOCALE_SMONTHNAME12
2596 static char *nl_langinfo_buf
= NULL
;
2597 static int nl_langinfo_len
= 0;
2599 if (nl_langinfo_len
<= 0)
2600 nl_langinfo_buf
= xmalloc (nl_langinfo_len
= 1);
2602 if (item
< 0 || item
>= _NL_NUM
)
2603 nl_langinfo_buf
[0] = 0;
2606 LCID cloc
= GetThreadLocale ();
2607 int need_len
= GetLocaleInfo (cloc
, w32item
[item
] | LOCALE_USE_CP_ACP
,
2611 nl_langinfo_buf
[0] = 0;
2614 if (item
== CODESET
)
2616 need_len
+= 2; /* for the "cp" prefix */
2617 if (need_len
< 8) /* for the case we call GetACP */
2620 if (nl_langinfo_len
<= need_len
)
2621 nl_langinfo_buf
= xrealloc (nl_langinfo_buf
,
2622 nl_langinfo_len
= need_len
);
2623 if (!GetLocaleInfo (cloc
, w32item
[item
] | LOCALE_USE_CP_ACP
,
2624 nl_langinfo_buf
, nl_langinfo_len
))
2625 nl_langinfo_buf
[0] = 0;
2626 else if (item
== CODESET
)
2628 if (strcmp (nl_langinfo_buf
, "0") == 0 /* CP_ACP */
2629 || strcmp (nl_langinfo_buf
, "1") == 0) /* CP_OEMCP */
2630 sprintf (nl_langinfo_buf
, "cp%u", GetACP ());
2633 memmove (nl_langinfo_buf
+ 2, nl_langinfo_buf
,
2634 strlen (nl_langinfo_buf
) + 1);
2635 nl_langinfo_buf
[0] = 'c';
2636 nl_langinfo_buf
[1] = 'p';
2641 return nl_langinfo_buf
;
2643 #endif /* HAVE_LANGINFO_CODESET */
2645 DEFUN ("w32-get-locale-info", Fw32_get_locale_info
,
2646 Sw32_get_locale_info
, 1, 2, 0,
2647 doc
: /* Return information about the Windows locale LCID.
2648 By default, return a three letter locale code which encodes the default
2649 language as the first two characters, and the country or regional variant
2650 as the third letter. For example, ENU refers to `English (United States)',
2651 while ENC means `English (Canadian)'.
2653 If the optional argument LONGFORM is t, the long form of the locale
2654 name is returned, e.g. `English (United States)' instead; if LONGFORM
2655 is a number, it is interpreted as an LCTYPE constant and the corresponding
2656 locale information is returned.
2658 If LCID (a 16-bit number) is not a valid locale, the result is nil. */)
2659 (Lisp_Object lcid
, Lisp_Object longform
)
2663 char abbrev_name
[32] = { 0 };
2664 char full_name
[256] = { 0 };
2666 CHECK_NUMBER (lcid
);
2668 if (!IsValidLocale (XINT (lcid
), LCID_SUPPORTED
))
2671 if (NILP (longform
))
2673 got_abbrev
= GetLocaleInfo (XINT (lcid
),
2674 LOCALE_SABBREVLANGNAME
| LOCALE_USE_CP_ACP
,
2675 abbrev_name
, sizeof (abbrev_name
));
2677 return build_string (abbrev_name
);
2679 else if (EQ (longform
, Qt
))
2681 got_full
= GetLocaleInfo (XINT (lcid
),
2682 LOCALE_SLANGUAGE
| LOCALE_USE_CP_ACP
,
2683 full_name
, sizeof (full_name
));
2685 return DECODE_SYSTEM (build_string (full_name
));
2687 else if (NUMBERP (longform
))
2689 got_full
= GetLocaleInfo (XINT (lcid
),
2691 full_name
, sizeof (full_name
));
2692 /* GetLocaleInfo's return value includes the terminating null
2693 character, when the returned information is a string, whereas
2694 make_unibyte_string needs the string length without the
2695 terminating null. */
2697 return make_unibyte_string (full_name
, got_full
- 1);
2704 DEFUN ("w32-get-current-locale-id", Fw32_get_current_locale_id
,
2705 Sw32_get_current_locale_id
, 0, 0, 0,
2706 doc
: /* Return Windows locale id for current locale setting.
2707 This is a numerical value; use `w32-get-locale-info' to convert to a
2708 human-readable form. */)
2711 return make_number (GetThreadLocale ());
2715 int_from_hex (char * s
)
2718 static char hex
[] = "0123456789abcdefABCDEF";
2721 while (*s
&& (p
= strchr (hex
, *s
)) != NULL
)
2723 unsigned digit
= p
- hex
;
2726 val
= val
* 16 + digit
;
2732 /* We need to build a global list, since the EnumSystemLocale callback
2733 function isn't given a context pointer. */
2734 Lisp_Object Vw32_valid_locale_ids
;
2736 static BOOL CALLBACK
2737 enum_locale_fn (LPTSTR localeNum
)
2739 DWORD id
= int_from_hex (localeNum
);
2740 Vw32_valid_locale_ids
= Fcons (make_number (id
), Vw32_valid_locale_ids
);
2744 DEFUN ("w32-get-valid-locale-ids", Fw32_get_valid_locale_ids
,
2745 Sw32_get_valid_locale_ids
, 0, 0, 0,
2746 doc
: /* Return list of all valid Windows locale ids.
2747 Each id is a numerical value; use `w32-get-locale-info' to convert to a
2748 human-readable form. */)
2751 Vw32_valid_locale_ids
= Qnil
;
2753 EnumSystemLocales (enum_locale_fn
, LCID_SUPPORTED
);
2755 Vw32_valid_locale_ids
= Fnreverse (Vw32_valid_locale_ids
);
2756 return Vw32_valid_locale_ids
;
2760 DEFUN ("w32-get-default-locale-id", Fw32_get_default_locale_id
, Sw32_get_default_locale_id
, 0, 1, 0,
2761 doc
: /* Return Windows locale id for default locale setting.
2762 By default, the system default locale setting is returned; if the optional
2763 parameter USERP is non-nil, the user default locale setting is returned.
2764 This is a numerical value; use `w32-get-locale-info' to convert to a
2765 human-readable form. */)
2769 return make_number (GetSystemDefaultLCID ());
2770 return make_number (GetUserDefaultLCID ());
2774 DEFUN ("w32-set-current-locale", Fw32_set_current_locale
, Sw32_set_current_locale
, 1, 1, 0,
2775 doc
: /* Make Windows locale LCID be the current locale setting for Emacs.
2776 If successful, the new locale id is returned, otherwise nil. */)
2779 CHECK_NUMBER (lcid
);
2781 if (!IsValidLocale (XINT (lcid
), LCID_SUPPORTED
))
2784 if (!SetThreadLocale (XINT (lcid
)))
2787 /* Need to set input thread locale if present. */
2788 if (dwWindowsThreadId
)
2789 /* Reply is not needed. */
2790 PostThreadMessage (dwWindowsThreadId
, WM_EMACS_SETLOCALE
, XINT (lcid
), 0);
2792 return make_number (GetThreadLocale ());
2796 /* We need to build a global list, since the EnumCodePages callback
2797 function isn't given a context pointer. */
2798 Lisp_Object Vw32_valid_codepages
;
2800 static BOOL CALLBACK
2801 enum_codepage_fn (LPTSTR codepageNum
)
2803 DWORD id
= atoi (codepageNum
);
2804 Vw32_valid_codepages
= Fcons (make_number (id
), Vw32_valid_codepages
);
2808 DEFUN ("w32-get-valid-codepages", Fw32_get_valid_codepages
,
2809 Sw32_get_valid_codepages
, 0, 0, 0,
2810 doc
: /* Return list of all valid Windows codepages. */)
2813 Vw32_valid_codepages
= Qnil
;
2815 EnumSystemCodePages (enum_codepage_fn
, CP_SUPPORTED
);
2817 Vw32_valid_codepages
= Fnreverse (Vw32_valid_codepages
);
2818 return Vw32_valid_codepages
;
2822 DEFUN ("w32-get-console-codepage", Fw32_get_console_codepage
,
2823 Sw32_get_console_codepage
, 0, 0, 0,
2824 doc
: /* Return current Windows codepage for console input. */)
2827 return make_number (GetConsoleCP ());
2831 DEFUN ("w32-set-console-codepage", Fw32_set_console_codepage
,
2832 Sw32_set_console_codepage
, 1, 1, 0,
2833 doc
: /* Make Windows codepage CP be the codepage for Emacs tty keyboard input.
2834 This codepage setting affects keyboard input in tty mode.
2835 If successful, the new CP is returned, otherwise nil. */)
2840 if (!IsValidCodePage (XINT (cp
)))
2843 if (!SetConsoleCP (XINT (cp
)))
2846 return make_number (GetConsoleCP ());
2850 DEFUN ("w32-get-console-output-codepage", Fw32_get_console_output_codepage
,
2851 Sw32_get_console_output_codepage
, 0, 0, 0,
2852 doc
: /* Return current Windows codepage for console output. */)
2855 return make_number (GetConsoleOutputCP ());
2859 DEFUN ("w32-set-console-output-codepage", Fw32_set_console_output_codepage
,
2860 Sw32_set_console_output_codepage
, 1, 1, 0,
2861 doc
: /* Make Windows codepage CP be the codepage for Emacs console output.
2862 This codepage setting affects display in tty mode.
2863 If successful, the new CP is returned, otherwise nil. */)
2868 if (!IsValidCodePage (XINT (cp
)))
2871 if (!SetConsoleOutputCP (XINT (cp
)))
2874 return make_number (GetConsoleOutputCP ());
2878 DEFUN ("w32-get-codepage-charset", Fw32_get_codepage_charset
,
2879 Sw32_get_codepage_charset
, 1, 1, 0,
2880 doc
: /* Return charset ID corresponding to codepage CP.
2881 Returns nil if the codepage is not valid. */)
2888 if (!IsValidCodePage (XINT (cp
)))
2891 if (TranslateCharsetInfo ((DWORD
*) XINT (cp
), &info
, TCI_SRCCODEPAGE
))
2892 return make_number (info
.ciCharset
);
2898 DEFUN ("w32-get-valid-keyboard-layouts", Fw32_get_valid_keyboard_layouts
,
2899 Sw32_get_valid_keyboard_layouts
, 0, 0, 0,
2900 doc
: /* Return list of Windows keyboard languages and layouts.
2901 The return value is a list of pairs of language id and layout id. */)
2904 int num_layouts
= GetKeyboardLayoutList (0, NULL
);
2905 HKL
* layouts
= (HKL
*) alloca (num_layouts
* sizeof (HKL
));
2906 Lisp_Object obj
= Qnil
;
2908 if (GetKeyboardLayoutList (num_layouts
, layouts
) == num_layouts
)
2910 while (--num_layouts
>= 0)
2912 DWORD kl
= (DWORD
) layouts
[num_layouts
];
2914 obj
= Fcons (Fcons (make_number (kl
& 0xffff),
2915 make_number ((kl
>> 16) & 0xffff)),
2924 DEFUN ("w32-get-keyboard-layout", Fw32_get_keyboard_layout
,
2925 Sw32_get_keyboard_layout
, 0, 0, 0,
2926 doc
: /* Return current Windows keyboard language and layout.
2927 The return value is the cons of the language id and the layout id. */)
2930 DWORD kl
= (DWORD
) GetKeyboardLayout (dwWindowsThreadId
);
2932 return Fcons (make_number (kl
& 0xffff),
2933 make_number ((kl
>> 16) & 0xffff));
2937 DEFUN ("w32-set-keyboard-layout", Fw32_set_keyboard_layout
,
2938 Sw32_set_keyboard_layout
, 1, 1, 0,
2939 doc
: /* Make LAYOUT be the current keyboard layout for Emacs.
2940 The keyboard layout setting affects interpretation of keyboard input.
2941 If successful, the new layout id is returned, otherwise nil. */)
2942 (Lisp_Object layout
)
2946 CHECK_CONS (layout
);
2947 CHECK_NUMBER_CAR (layout
);
2948 CHECK_NUMBER_CDR (layout
);
2950 kl
= (XINT (XCAR (layout
)) & 0xffff)
2951 | (XINT (XCDR (layout
)) << 16);
2953 /* Synchronize layout with input thread. */
2954 if (dwWindowsThreadId
)
2956 if (PostThreadMessage (dwWindowsThreadId
, WM_EMACS_SETKEYBOARDLAYOUT
,
2960 GetMessage (&msg
, NULL
, WM_EMACS_DONE
, WM_EMACS_DONE
);
2962 if (msg
.wParam
== 0)
2966 else if (!ActivateKeyboardLayout ((HKL
) kl
, 0))
2969 return Fw32_get_keyboard_layout ();
2974 syms_of_ntproc (void)
2976 DEFSYM (Qhigh
, "high");
2977 DEFSYM (Qlow
, "low");
2979 defsubr (&Sw32_has_winsock
);
2980 defsubr (&Sw32_unload_winsock
);
2982 defsubr (&Sw32_short_file_name
);
2983 defsubr (&Sw32_long_file_name
);
2984 defsubr (&Sw32_set_process_priority
);
2985 defsubr (&Sw32_get_locale_info
);
2986 defsubr (&Sw32_get_current_locale_id
);
2987 defsubr (&Sw32_get_default_locale_id
);
2988 defsubr (&Sw32_get_valid_locale_ids
);
2989 defsubr (&Sw32_set_current_locale
);
2991 defsubr (&Sw32_get_console_codepage
);
2992 defsubr (&Sw32_set_console_codepage
);
2993 defsubr (&Sw32_get_console_output_codepage
);
2994 defsubr (&Sw32_set_console_output_codepage
);
2995 defsubr (&Sw32_get_valid_codepages
);
2996 defsubr (&Sw32_get_codepage_charset
);
2998 defsubr (&Sw32_get_valid_keyboard_layouts
);
2999 defsubr (&Sw32_get_keyboard_layout
);
3000 defsubr (&Sw32_set_keyboard_layout
);
3002 DEFVAR_LISP ("w32-quote-process-args", Vw32_quote_process_args
,
3003 doc
: /* Non-nil enables quoting of process arguments to ensure correct parsing.
3004 Because Windows does not directly pass argv arrays to child processes,
3005 programs have to reconstruct the argv array by parsing the command
3006 line string. For an argument to contain a space, it must be enclosed
3007 in double quotes or it will be parsed as multiple arguments.
3009 If the value is a character, that character will be used to escape any
3010 quote characters that appear, otherwise a suitable escape character
3011 will be chosen based on the type of the program. */);
3012 Vw32_quote_process_args
= Qt
;
3014 DEFVAR_LISP ("w32-start-process-show-window",
3015 Vw32_start_process_show_window
,
3016 doc
: /* When nil, new child processes hide their windows.
3017 When non-nil, they show their window in the method of their choice.
3018 This variable doesn't affect GUI applications, which will never be hidden. */);
3019 Vw32_start_process_show_window
= Qnil
;
3021 DEFVAR_LISP ("w32-start-process-share-console",
3022 Vw32_start_process_share_console
,
3023 doc
: /* When nil, new child processes are given a new console.
3024 When non-nil, they share the Emacs console; this has the limitation of
3025 allowing only one DOS subprocess to run at a time (whether started directly
3026 or indirectly by Emacs), and preventing Emacs from cleanly terminating the
3027 subprocess group, but may allow Emacs to interrupt a subprocess that doesn't
3028 otherwise respond to interrupts from Emacs. */);
3029 Vw32_start_process_share_console
= Qnil
;
3031 DEFVAR_LISP ("w32-start-process-inherit-error-mode",
3032 Vw32_start_process_inherit_error_mode
,
3033 doc
: /* When nil, new child processes revert to the default error mode.
3034 When non-nil, they inherit their error mode setting from Emacs, which stops
3035 them blocking when trying to access unmounted drives etc. */);
3036 Vw32_start_process_inherit_error_mode
= Qt
;
3038 DEFVAR_INT ("w32-pipe-read-delay", w32_pipe_read_delay
,
3039 doc
: /* Forced delay before reading subprocess output.
3040 This is done to improve the buffering of subprocess output, by
3041 avoiding the inefficiency of frequently reading small amounts of data.
3043 If positive, the value is the number of milliseconds to sleep before
3044 reading the subprocess output. If negative, the magnitude is the number
3045 of time slices to wait (effectively boosting the priority of the child
3046 process temporarily). A value of zero disables waiting entirely. */);
3047 w32_pipe_read_delay
= 50;
3049 DEFVAR_LISP ("w32-downcase-file-names", Vw32_downcase_file_names
,
3050 doc
: /* Non-nil means convert all-upper case file names to lower case.
3051 This applies when performing completions and file name expansion.
3052 Note that the value of this setting also affects remote file names,
3053 so you probably don't want to set to non-nil if you use case-sensitive
3054 filesystems via ange-ftp. */);
3055 Vw32_downcase_file_names
= Qnil
;
3058 DEFVAR_LISP ("w32-generate-fake-inodes", Vw32_generate_fake_inodes
,
3059 doc
: /* Non-nil means attempt to fake realistic inode values.
3060 This works by hashing the truename of files, and should detect
3061 aliasing between long and short (8.3 DOS) names, but can have
3062 false positives because of hash collisions. Note that determining
3063 the truename of a file can be slow. */);
3064 Vw32_generate_fake_inodes
= Qnil
;
3067 DEFVAR_LISP ("w32-get-true-file-attributes", Vw32_get_true_file_attributes
,
3068 doc
: /* Non-nil means determine accurate file attributes in `file-attributes'.
3069 This option controls whether to issue additional system calls to determine
3070 accurate link counts, file type, and ownership information. It is more
3071 useful for files on NTFS volumes, where hard links and file security are
3072 supported, than on volumes of the FAT family.
3074 Without these system calls, link count will always be reported as 1 and file
3075 ownership will be attributed to the current user.
3076 The default value `local' means only issue these system calls for files
3077 on local fixed drives. A value of nil means never issue them.
3078 Any other non-nil value means do this even on remote and removable drives
3079 where the performance impact may be noticeable even on modern hardware. */);
3080 Vw32_get_true_file_attributes
= Qlocal
;
3082 staticpro (&Vw32_valid_locale_ids
);
3083 staticpro (&Vw32_valid_codepages
);
3085 /* end of w32proc.c */