Merge from origin/emacs-24
[emacs.git] / src / w32proc.c
blob74731db24268f71d56213711069668d00a0049ff
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>
26 #include <stdio.h>
27 #include <stdlib.h>
28 #include <errno.h>
29 #include <ctype.h>
30 #include <io.h>
31 #include <fcntl.h>
32 #include <signal.h>
33 #include <sys/file.h>
34 #include <mbstring.h>
35 #include <locale.h>
37 /* must include CRT headers *before* config.h */
38 #include <config.h>
40 #undef signal
41 #undef wait
42 #undef spawnve
43 #undef select
44 #undef kill
46 #include <windows.h>
47 #if defined(__GNUC__) && !defined(__MINGW64__)
48 /* This definition is missing from mingw.org headers, but not MinGW64
49 headers. */
50 extern BOOL WINAPI IsValidLocale (LCID, DWORD);
51 #endif
53 #ifdef HAVE_LANGINFO_CODESET
54 #include <nl_types.h>
55 #include <langinfo.h>
56 #endif
58 #include "lisp.h"
59 #include "w32.h"
60 #include "w32common.h"
61 #include "w32heap.h"
62 #include "systime.h"
63 #include "syswait.h"
64 #include "process.h"
65 #include "syssignal.h"
66 #include "w32term.h"
67 #include "dispextern.h" /* for xstrcasecmp */
68 #include "coding.h"
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. */
84 signal_handler
85 sys_signal (int sig, signal_handler handler)
87 signal_handler old;
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))
96 errno = EINVAL;
97 return SIG_ERR;
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);
111 return old;
114 /* Emulate sigaction. */
116 sigaction (int sig, const struct sigaction *act, struct sigaction *oact)
118 signal_handler old = SIG_DFL;
119 int retval = 0;
121 if (act)
122 old = sys_signal (sig, act->sa_handler);
123 else if (oact)
124 old = sig_handlers[sig];
126 if (old == SIG_ERR)
128 errno = EINVAL;
129 retval = -1;
131 if (oact)
133 oact->sa_handler = old;
134 oact->sa_flags = 0;
135 oact->sa_mask = empty_mask;
137 return retval;
140 /* Emulate signal sets and blocking of signals used by timers. */
143 sigemptyset (sigset_t *set)
145 *set = 0;
146 return 0;
150 sigaddset (sigset_t *set, int signo)
152 if (!set)
154 errno = EINVAL;
155 return -1;
157 if (signo < 0 || signo >= NSIG)
159 errno = EINVAL;
160 return -1;
163 *set |= (1U << signo);
165 return 0;
169 sigfillset (sigset_t *set)
171 if (!set)
173 errno = EINVAL;
174 return -1;
177 *set = 0xFFFFFFFF;
178 return 0;
182 sigprocmask (int how, const sigset_t *set, sigset_t *oset)
184 if (!(how == SIG_BLOCK || how == SIG_UNBLOCK || how == SIG_SETMASK))
186 errno = EINVAL;
187 return -1;
190 if (oset)
191 *oset = sig_mask;
193 if (!set)
194 return 0;
196 switch (how)
198 case SIG_BLOCK:
199 sig_mask |= *set;
200 break;
201 case SIG_SETMASK:
202 sig_mask = *set;
203 break;
204 case SIG_UNBLOCK:
205 /* FIXME: Catch signals that are blocked and reissue them when
206 they are unblocked. Important for SIGALRM and SIGPROF only. */
207 sig_mask &= ~(*set);
208 break;
211 return 0;
215 pthread_sigmask (int how, const sigset_t *set, sigset_t *oset)
217 if (sigprocmask (how, set, oset) == -1)
218 return EINVAL;
219 return 0;
223 sigismember (const sigset_t *set, int signo)
225 if (signo < 0 || signo >= NSIG)
227 errno = EINVAL;
228 return -1;
230 if (signo > sizeof (*set) * BITS_PER_CHAR)
231 emacs_abort ();
233 return (*set & (1U << signo)) != 0;
236 pid_t
237 getpgrp (void)
239 return getpid ();
242 pid_t
243 tcgetpgrp (int fd)
245 return getpid ();
249 setpgid (pid_t pid, pid_t pgid)
251 return 0;
254 pid_t
255 setsid (void)
257 return getpid ();
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. */
268 struct itimer_data {
269 volatile ULONGLONG expire;
270 volatile ULONGLONG reload;
271 volatile int terminate;
272 int type;
273 HANDLE caller_thread;
274 HANDLE timer_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) (
288 HANDLE hThread,
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. */
304 static ULONGLONG
305 w32_get_timer_time (HANDLE thread)
307 ULONGLONG retval;
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))
321 use_system_time = 0;
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;
328 retval =
329 temp_creation.QuadPart / tscale + temp_kernel.QuadPart / tscale
330 + temp_user.QuadPart / tscale;
332 else
333 DebPrint (("GetThreadTimes failed with error code %lu\n",
334 GetLastError ()));
337 if (use_system_time)
339 FILETIME current_ftime;
340 ULARGE_INTEGER temp;
342 GetSystemTimeAsFileTime (&current_ftime);
344 temp.LowPart = current_ftime.dwLowDateTime;
345 temp.HighPart = current_ftime.dwHighDateTime;
347 retval = temp.QuadPart / tscale;
350 return retval;
353 /* Thread function for a timer thread. */
354 static DWORD WINAPI
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;
364 while (1)
366 DWORD sleep_time;
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)
376 return 0;
378 if (expire == 0)
380 /* We are idle. */
381 Sleep (max_sleep);
382 continue;
385 if (expire > (now = w32_get_timer_time (hth)))
386 sleep_time = expire - now;
387 else
388 sleep_time = 0;
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)
394 return 0;
395 Sleep (max_sleep);
396 EnterCriticalSection (crit);
397 expire = itimer->expire;
398 LeaveCriticalSection (crit);
399 sleep_time =
400 (expire > (now = w32_get_timer_time (hth))) ? expire - now : 0;
402 if (itimer->terminate)
403 return 0;
404 if (sleep_time > 0)
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)
413 Sleep (5);
416 EnterCriticalSection (crit);
417 expire = itimer->expire;
418 LeaveCriticalSection (crit);
419 if (expire == 0)
420 continue;
422 /* Time's up. */
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
427 unblocked. */
428 && !sigismember (&sig_mask, sig)
429 /* Simulate masking of SIGALRM and SIGPROF when processing
430 fatal signals. */
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
436 runs. */
437 HANDLE th = itimer->caller_thread;
438 DWORD result = SuspendThread (th);
440 if (result == (DWORD)-1)
441 return 2;
443 handler (sig);
444 ResumeThread (th);
447 /* Update expiration time and loop. */
448 EnterCriticalSection (crit);
449 expire = itimer->expire;
450 if (expire == 0)
452 LeaveCriticalSection (crit);
453 continue;
455 reload = itimer->reload;
456 if (reload > 0)
458 now = w32_get_timer_time (hth);
459 if (expire <= now)
461 ULONGLONG lag = now - expire;
463 /* If we missed some opportunities (presumably while
464 sleeping or while the signal handler ran), skip
465 them. */
466 if (lag > reload)
467 expire = now - (lag % reload);
469 expire += reload;
472 else
473 expire = 0; /* become idle */
474 itimer->expire = expire;
475 LeaveCriticalSection (crit);
477 return 0;
480 static void
481 stop_timer_thread (int which)
483 struct itimer_data *itimer =
484 (which == ITIMER_REAL) ? &real_itimer : &prof_itimer;
485 int i;
486 DWORD err, exit_code = 255;
487 BOOL status;
489 /* Signal the thread that it should terminate. */
490 itimer->terminate = 1;
492 if (itimer->timer_thread == NULL)
493 return;
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))
502 break;
503 Sleep (10);
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);
512 /* Clean up. */
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. */
523 void
524 term_timers (void)
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
532 work after this. */
533 disable_itimers = 1;
535 DeleteCriticalSection (&crit_real);
536 DeleteCriticalSection (&crit_prof);
537 DeleteCriticalSection (&crit_sig);
540 /* This is called at initialization time from init_ntproc. */
541 void
542 init_timers (void)
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"),
551 "GetThreadTimes");
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);
562 disable_itimers = 0;
565 static int
566 start_timer_thread (int which)
568 DWORD exit_code, tid;
569 HANDLE th;
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)
576 return 0;
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))
595 errno = ESRCH;
596 return -1;
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
604 new_child below. */
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;
612 errno = EAGAIN;
613 return -1;
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);
621 return 0;
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;
633 __int64 usecs;
634 CRITICAL_SECTION *crit;
635 struct itimer_data *itimer;
637 if (disable_itimers)
638 return -1;
640 if (!value)
642 errno = EFAULT;
643 return -1;
646 if (which != ITIMER_REAL && which != ITIMER_PROF)
648 errno = EINVAL;
649 return -1;
652 itimer = (which == ITIMER_REAL) ? &real_itimer : &prof_itimer;
654 ticks_now = w32_get_timer_time ((which == ITIMER_REAL)
655 ? NULL
656 : GetCurrentThread ());
658 t_expire = &itimer->expire;
659 t_reload = &itimer->reload;
660 crit = (which == ITIMER_REAL) ? &crit_real : &crit_prof;
662 EnterCriticalSection (crit);
663 reload = *t_reload;
664 expire = *t_expire;
665 LeaveCriticalSection (crit);
667 if (expire)
668 expire -= ticks_now;
670 value->it_value.tv_sec = expire / TIMER_TICKS_PER_SEC;
671 usecs =
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;
675 usecs =
676 (reload % TIMER_TICKS_PER_SEC) * (__int64)1000000 / TIMER_TICKS_PER_SEC;
677 value->it_interval.tv_usec= usecs;
679 return 0;
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;
687 __int64 usecs;
688 CRITICAL_SECTION *crit;
689 struct itimerval tem, *ptem;
691 if (disable_itimers)
692 return -1;
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. */
697 if (!clocks_min)
699 ULONGLONG t1, t2;
701 for (t1 = w32_get_timer_time (NULL);
702 (t2 = w32_get_timer_time (NULL)) == t1; )
704 clocks_min = t2 - t1;
707 if (ovalue)
708 ptem = ovalue;
709 else
710 ptem = &tem;
712 if (getitimer (which, ptem)) /* also sets ticks_now */
713 return -1; /* errno already set */
715 t_expire =
716 (which == ITIMER_REAL) ? &real_itimer.expire : &prof_itimer.expire;
717 t_reload =
718 (which == ITIMER_REAL) ? &real_itimer.reload : &prof_itimer.reload;
720 crit = (which == ITIMER_REAL) ? &crit_real : &crit_prof;
722 if (!value
723 || (value->it_value.tv_sec == 0 && value->it_value.tv_usec == 0))
725 EnterCriticalSection (crit);
726 /* Disable the timer. */
727 *t_expire = 0;
728 *t_reload = 0;
729 LeaveCriticalSection (crit);
730 return 0;
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)
738 reload = clocks_min;
739 else
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)
749 expire = clocks_min;
750 else
752 usecs *= TIMER_TICKS_PER_SEC;
753 expire += usecs / 1000000;
756 expire += ticks_now;
758 EnterCriticalSection (crit);
759 expire_old = *t_expire;
760 reload_old = *t_reload;
761 if (!(expire == expire_old && reload == reload_old))
763 *t_reload = reload;
764 *t_expire = expire;
766 LeaveCriticalSection (crit);
768 return start_timer_thread (which);
772 alarm (int seconds)
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)
782 return 0;
783 return old_values.it_value.tv_sec;
784 #else
785 return seconds;
786 #endif
789 /* Defined in <process.h> which conflicts with the local copy */
790 #define _P_NOWAIT 1
792 /* Child process management list. */
793 int child_proc_count = 0;
794 child_process child_procs[ MAX_CHILDREN ];
796 static DWORD WINAPI reader_thread (void *arg);
798 /* Find an unused process slot. */
799 child_process *
800 new_child (void)
802 child_process *cp;
803 DWORD id;
805 for (cp = child_procs + (child_proc_count-1); cp >= child_procs; cp--)
806 if (!CHILD_ACTIVE (cp) && cp->procinfo.hProcess == NULL)
807 goto Initialize;
808 if (child_proc_count == MAX_CHILDREN)
810 int i = 0;
811 child_process *dead_cp = NULL;
813 DebPrint (("new_child: No vacant slots, looking for dead processes\n"));
814 for (cp = child_procs + (child_proc_count-1); cp >= child_procs; cp--)
815 if (!CHILD_ACTIVE (cp) && cp->procinfo.hProcess)
817 DWORD status = 0;
819 if (!GetExitCodeProcess (cp->procinfo.hProcess, &status))
821 DebPrint (("new_child.GetExitCodeProcess: error %lu for PID %lu\n",
822 GetLastError (), cp->procinfo.dwProcessId));
823 status = STILL_ACTIVE;
825 if (status != STILL_ACTIVE
826 || WaitForSingleObject (cp->procinfo.hProcess, 0) == WAIT_OBJECT_0)
828 DebPrint (("new_child: Freeing slot of dead process %d, fd %d\n",
829 cp->procinfo.dwProcessId, cp->fd));
830 CloseHandle (cp->procinfo.hProcess);
831 cp->procinfo.hProcess = NULL;
832 CloseHandle (cp->procinfo.hThread);
833 cp->procinfo.hThread = NULL;
834 /* Free up to 2 dead slots at a time, so that if we
835 have a lot of them, they will eventually all be
836 freed when the tornado ends. */
837 if (i == 0)
838 dead_cp = cp;
839 else
840 break;
841 i++;
844 if (dead_cp)
846 cp = dead_cp;
847 goto Initialize;
850 if (child_proc_count == MAX_CHILDREN)
851 return NULL;
852 cp = &child_procs[child_proc_count++];
854 Initialize:
855 /* Last opportunity to avoid leaking handles before we forget them
856 for good. */
857 if (cp->procinfo.hProcess)
858 CloseHandle (cp->procinfo.hProcess);
859 if (cp->procinfo.hThread)
860 CloseHandle (cp->procinfo.hThread);
861 memset (cp, 0, sizeof (*cp));
862 cp->fd = -1;
863 cp->pid = -1;
864 cp->procinfo.hProcess = NULL;
865 cp->status = STATUS_READ_ERROR;
867 /* use manual reset event so that select() will function properly */
868 cp->char_avail = CreateEvent (NULL, TRUE, FALSE, NULL);
869 if (cp->char_avail)
871 cp->char_consumed = CreateEvent (NULL, FALSE, FALSE, NULL);
872 if (cp->char_consumed)
874 /* The 0x00010000 flag is STACK_SIZE_PARAM_IS_A_RESERVATION.
875 It means that the 64K stack we are requesting in the 2nd
876 argument is how much memory should be reserved for the
877 stack. If we don't use this flag, the memory requested
878 by the 2nd argument is the amount actually _committed_,
879 but Windows reserves 8MB of memory for each thread's
880 stack. (The 8MB figure comes from the -stack
881 command-line argument we pass to the linker when building
882 Emacs, but that's because we need a large stack for
883 Emacs's main thread.) Since we request 2GB of reserved
884 memory at startup (see w32heap.c), which is close to the
885 maximum memory available for a 32-bit process on Windows,
886 the 8MB reservation for each thread causes failures in
887 starting subprocesses, because we create a thread running
888 reader_thread for each subprocess. As 8MB of stack is
889 way too much for reader_thread, forcing Windows to
890 reserve less wins the day. */
891 cp->thrd = CreateThread (NULL, 64 * 1024, reader_thread, cp,
892 0x00010000, &id);
893 if (cp->thrd)
894 return cp;
897 delete_child (cp);
898 return NULL;
901 void
902 delete_child (child_process *cp)
904 int i;
906 /* Should not be deleting a child that is still needed. */
907 for (i = 0; i < MAXDESC; i++)
908 if (fd_info[i].cp == cp)
909 emacs_abort ();
911 if (!CHILD_ACTIVE (cp) && cp->procinfo.hProcess == NULL)
912 return;
914 /* reap thread if necessary */
915 if (cp->thrd)
917 DWORD rc;
919 if (GetExitCodeThread (cp->thrd, &rc) && rc == STILL_ACTIVE)
921 /* let the thread exit cleanly if possible */
922 cp->status = STATUS_READ_ERROR;
923 SetEvent (cp->char_consumed);
924 #if 0
925 /* We used to forcibly terminate the thread here, but it
926 is normally unnecessary, and in abnormal cases, the worst that
927 will happen is we have an extra idle thread hanging around
928 waiting for the zombie process. */
929 if (WaitForSingleObject (cp->thrd, 1000) != WAIT_OBJECT_0)
931 DebPrint (("delete_child.WaitForSingleObject (thread) failed "
932 "with %lu for fd %ld\n", GetLastError (), cp->fd));
933 TerminateThread (cp->thrd, 0);
935 #endif
937 CloseHandle (cp->thrd);
938 cp->thrd = NULL;
940 if (cp->char_avail)
942 CloseHandle (cp->char_avail);
943 cp->char_avail = NULL;
945 if (cp->char_consumed)
947 CloseHandle (cp->char_consumed);
948 cp->char_consumed = NULL;
951 /* update child_proc_count (highest numbered slot in use plus one) */
952 if (cp == child_procs + child_proc_count - 1)
954 for (i = child_proc_count-1; i >= 0; i--)
955 if (CHILD_ACTIVE (&child_procs[i])
956 || child_procs[i].procinfo.hProcess != NULL)
958 child_proc_count = i + 1;
959 break;
962 if (i < 0)
963 child_proc_count = 0;
966 /* Find a child by pid. */
967 static child_process *
968 find_child_pid (DWORD pid)
970 child_process *cp;
972 for (cp = child_procs + (child_proc_count-1); cp >= child_procs; cp--)
973 if ((CHILD_ACTIVE (cp) || cp->procinfo.hProcess != NULL)
974 && pid == cp->pid)
975 return cp;
976 return NULL;
979 void
980 release_listen_threads (void)
982 int i;
984 for (i = child_proc_count - 1; i >= 0; i--)
986 if (CHILD_ACTIVE (&child_procs[i])
987 && (fd_info[child_procs[i].fd].flags & FILE_LISTEN))
988 child_procs[i].status = STATUS_READ_ERROR;
992 /* Thread proc for child process and socket reader threads. Each thread
993 is normally blocked until woken by select() to check for input by
994 reading one char. When the read completes, char_avail is signaled
995 to wake up the select emulator and the thread blocks itself again. */
996 static DWORD WINAPI
997 reader_thread (void *arg)
999 child_process *cp;
1001 /* Our identity */
1002 cp = (child_process *)arg;
1004 /* We have to wait for the go-ahead before we can start */
1005 if (cp == NULL
1006 || WaitForSingleObject (cp->char_consumed, INFINITE) != WAIT_OBJECT_0
1007 || cp->fd < 0)
1008 return 1;
1010 for (;;)
1012 int rc;
1014 if (cp->fd >= 0 && fd_info[cp->fd].flags & FILE_LISTEN)
1015 rc = _sys_wait_accept (cp->fd);
1016 else
1017 rc = _sys_read_ahead (cp->fd);
1019 /* Don't bother waiting for the event if we already have been
1020 told to exit by delete_child. */
1021 if (cp->status == STATUS_READ_ERROR || !cp->char_avail)
1022 break;
1024 /* The name char_avail is a misnomer - it really just means the
1025 read-ahead has completed, whether successfully or not. */
1026 if (!SetEvent (cp->char_avail))
1028 DebPrint (("reader_thread.SetEvent(0x%x) failed with %lu for fd %ld (PID %d)\n",
1029 (DWORD_PTR)cp->char_avail, GetLastError (),
1030 cp->fd, cp->pid));
1031 return 1;
1034 if (rc == STATUS_READ_ERROR)
1035 return 1;
1037 /* If the read died, the child has died so let the thread die */
1038 if (rc == STATUS_READ_FAILED)
1039 break;
1041 /* Don't bother waiting for the acknowledge if we already have
1042 been told to exit by delete_child. */
1043 if (cp->status == STATUS_READ_ERROR || !cp->char_consumed)
1044 break;
1046 /* Wait until our input is acknowledged before reading again */
1047 if (WaitForSingleObject (cp->char_consumed, INFINITE) != WAIT_OBJECT_0)
1049 DebPrint (("reader_thread.WaitForSingleObject failed with "
1050 "%lu for fd %ld\n", GetLastError (), cp->fd));
1051 break;
1053 /* delete_child sets status to STATUS_READ_ERROR when it wants
1054 us to exit. */
1055 if (cp->status == STATUS_READ_ERROR)
1056 break;
1058 return 0;
1061 /* To avoid Emacs changing directory, we just record here the
1062 directory the new process should start in. This is set just before
1063 calling sys_spawnve, and is not generally valid at any other time.
1064 Note that this directory's name is UTF-8 encoded. */
1065 static char * process_dir;
1067 static BOOL
1068 create_child (char *exe, char *cmdline, char *env, int is_gui_app,
1069 pid_t * pPid, child_process *cp)
1071 STARTUPINFO start;
1072 SECURITY_ATTRIBUTES sec_attrs;
1073 #if 0
1074 SECURITY_DESCRIPTOR sec_desc;
1075 #endif
1076 DWORD flags;
1077 char dir[ MAX_PATH ];
1078 char *p;
1079 const char *ext;
1081 if (cp == NULL) emacs_abort ();
1083 memset (&start, 0, sizeof (start));
1084 start.cb = sizeof (start);
1086 #ifdef HAVE_NTGUI
1087 if (NILP (Vw32_start_process_show_window) && !is_gui_app)
1088 start.dwFlags = STARTF_USESTDHANDLES | STARTF_USESHOWWINDOW;
1089 else
1090 start.dwFlags = STARTF_USESTDHANDLES;
1091 start.wShowWindow = SW_HIDE;
1093 start.hStdInput = GetStdHandle (STD_INPUT_HANDLE);
1094 start.hStdOutput = GetStdHandle (STD_OUTPUT_HANDLE);
1095 start.hStdError = GetStdHandle (STD_ERROR_HANDLE);
1096 #endif /* HAVE_NTGUI */
1098 #if 0
1099 /* Explicitly specify no security */
1100 if (!InitializeSecurityDescriptor (&sec_desc, SECURITY_DESCRIPTOR_REVISION))
1101 goto EH_Fail;
1102 if (!SetSecurityDescriptorDacl (&sec_desc, TRUE, NULL, FALSE))
1103 goto EH_Fail;
1104 #endif
1105 sec_attrs.nLength = sizeof (sec_attrs);
1106 sec_attrs.lpSecurityDescriptor = NULL /* &sec_desc */;
1107 sec_attrs.bInheritHandle = FALSE;
1109 filename_to_ansi (process_dir, dir);
1110 /* Can't use unixtodos_filename here, since that needs its file name
1111 argument encoded in UTF-8. OTOH, process_dir, which _is_ in
1112 UTF-8, points, to the directory computed by our caller, and we
1113 don't want to modify that, either. */
1114 for (p = dir; *p; p = CharNextA (p))
1115 if (*p == '/')
1116 *p = '\\';
1118 /* CreateProcess handles batch files as exe specially. This special
1119 handling fails when both the batch file and arguments are quoted.
1120 We pass NULL as exe to avoid the special handling. */
1121 if (exe && cmdline[0] == '"' &&
1122 (ext = strrchr (exe, '.')) &&
1123 (xstrcasecmp (ext, ".bat") == 0
1124 || xstrcasecmp (ext, ".cmd") == 0))
1125 exe = NULL;
1127 flags = (!NILP (Vw32_start_process_share_console)
1128 ? CREATE_NEW_PROCESS_GROUP
1129 : CREATE_NEW_CONSOLE);
1130 if (NILP (Vw32_start_process_inherit_error_mode))
1131 flags |= CREATE_DEFAULT_ERROR_MODE;
1132 if (!CreateProcessA (exe, cmdline, &sec_attrs, NULL, TRUE,
1133 flags, env, dir, &start, &cp->procinfo))
1134 goto EH_Fail;
1136 cp->pid = (int) cp->procinfo.dwProcessId;
1138 /* Hack for Windows 95, which assigns large (ie negative) pids */
1139 if (cp->pid < 0)
1140 cp->pid = -cp->pid;
1142 *pPid = cp->pid;
1144 return TRUE;
1146 EH_Fail:
1147 DebPrint (("create_child.CreateProcess failed: %ld\n", GetLastError ()););
1148 return FALSE;
1151 /* create_child doesn't know what emacs's file handle will be for waiting
1152 on output from the child, so we need to make this additional call
1153 to register the handle with the process
1154 This way the select emulator knows how to match file handles with
1155 entries in child_procs. */
1156 void
1157 register_child (pid_t pid, int fd)
1159 child_process *cp;
1161 cp = find_child_pid ((DWORD)pid);
1162 if (cp == NULL)
1164 DebPrint (("register_child unable to find pid %lu\n", pid));
1165 return;
1168 #ifdef FULL_DEBUG
1169 DebPrint (("register_child registered fd %d with pid %lu\n", fd, pid));
1170 #endif
1172 cp->fd = fd;
1174 /* thread is initially blocked until select is called; set status so
1175 that select will release thread */
1176 cp->status = STATUS_READ_ACKNOWLEDGED;
1178 /* attach child_process to fd_info */
1179 if (fd_info[fd].cp != NULL)
1181 DebPrint (("register_child: fd_info[%d] apparently in use!\n", fd));
1182 emacs_abort ();
1185 fd_info[fd].cp = cp;
1188 /* Called from waitpid when a process exits. */
1189 static void
1190 reap_subprocess (child_process *cp)
1192 if (cp->procinfo.hProcess)
1194 /* Reap the process */
1195 #ifdef FULL_DEBUG
1196 /* Process should have already died before we are called. */
1197 if (WaitForSingleObject (cp->procinfo.hProcess, 0) != WAIT_OBJECT_0)
1198 DebPrint (("reap_subprocess: child for fd %d has not died yet!", cp->fd));
1199 #endif
1200 CloseHandle (cp->procinfo.hProcess);
1201 cp->procinfo.hProcess = NULL;
1202 CloseHandle (cp->procinfo.hThread);
1203 cp->procinfo.hThread = NULL;
1206 /* If cp->fd was not closed yet, we might be still reading the
1207 process output, so don't free its resources just yet. The call
1208 to delete_child on behalf of this subprocess will be made by
1209 sys_read when the subprocess output is fully read. */
1210 if (cp->fd < 0)
1211 delete_child (cp);
1214 /* Wait for a child process specified by PID, or for any of our
1215 existing child processes (if PID is nonpositive) to die. When it
1216 does, close its handle. Return the pid of the process that died
1217 and fill in STATUS if non-NULL. */
1219 pid_t
1220 waitpid (pid_t pid, int *status, int options)
1222 DWORD active, retval;
1223 int nh;
1224 child_process *cp, *cps[MAX_CHILDREN];
1225 HANDLE wait_hnd[MAX_CHILDREN];
1226 DWORD timeout_ms;
1227 int dont_wait = (options & WNOHANG) != 0;
1229 nh = 0;
1230 /* According to Posix:
1232 PID = -1 means status is requested for any child process.
1234 PID > 0 means status is requested for a single child process
1235 whose pid is PID.
1237 PID = 0 means status is requested for any child process whose
1238 process group ID is equal to that of the calling process. But
1239 since Windows has only a limited support for process groups (only
1240 for console processes and only for the purposes of passing
1241 Ctrl-BREAK signal to them), and since we have no documented way
1242 of determining whether a given process belongs to our group, we
1243 treat 0 as -1.
1245 PID < -1 means status is requested for any child process whose
1246 process group ID is equal to the absolute value of PID. Again,
1247 since we don't support process groups, we treat that as -1. */
1248 if (pid > 0)
1250 int our_child = 0;
1252 /* We are requested to wait for a specific child. */
1253 for (cp = child_procs + (child_proc_count-1); cp >= child_procs; cp--)
1255 /* Some child_procs might be sockets; ignore them. Also
1256 ignore subprocesses whose output is not yet completely
1257 read. */
1258 if (CHILD_ACTIVE (cp)
1259 && cp->procinfo.hProcess
1260 && cp->pid == pid)
1262 our_child = 1;
1263 break;
1266 if (our_child)
1268 if (cp->fd < 0 || (fd_info[cp->fd].flags & FILE_AT_EOF) != 0)
1270 wait_hnd[nh] = cp->procinfo.hProcess;
1271 cps[nh] = cp;
1272 nh++;
1274 else if (dont_wait)
1276 /* PID specifies our subprocess, but its status is not
1277 yet available. */
1278 return 0;
1281 if (nh == 0)
1283 /* No such child process, or nothing to wait for, so fail. */
1284 errno = ECHILD;
1285 return -1;
1288 else
1290 for (cp = child_procs + (child_proc_count-1); cp >= child_procs; cp--)
1292 if (CHILD_ACTIVE (cp)
1293 && cp->procinfo.hProcess
1294 && (cp->fd < 0 || (fd_info[cp->fd].flags & FILE_AT_EOF) != 0))
1296 wait_hnd[nh] = cp->procinfo.hProcess;
1297 cps[nh] = cp;
1298 nh++;
1301 if (nh == 0)
1303 /* Nothing to wait on, so fail. */
1304 errno = ECHILD;
1305 return -1;
1309 if (dont_wait)
1310 timeout_ms = 0;
1311 else
1312 timeout_ms = 1000; /* check for quit about once a second. */
1316 QUIT;
1317 active = WaitForMultipleObjects (nh, wait_hnd, FALSE, timeout_ms);
1318 } while (active == WAIT_TIMEOUT && !dont_wait);
1320 if (active == WAIT_FAILED)
1322 errno = EBADF;
1323 return -1;
1325 else if (active == WAIT_TIMEOUT && dont_wait)
1327 /* PID specifies our subprocess, but it didn't exit yet, so its
1328 status is not yet available. */
1329 #ifdef FULL_DEBUG
1330 DebPrint (("Wait: PID %d not reap yet\n", cp->pid));
1331 #endif
1332 return 0;
1334 else if (active >= WAIT_OBJECT_0
1335 && active < WAIT_OBJECT_0+MAXIMUM_WAIT_OBJECTS)
1337 active -= WAIT_OBJECT_0;
1339 else if (active >= WAIT_ABANDONED_0
1340 && active < WAIT_ABANDONED_0+MAXIMUM_WAIT_OBJECTS)
1342 active -= WAIT_ABANDONED_0;
1344 else
1345 emacs_abort ();
1347 if (!GetExitCodeProcess (wait_hnd[active], &retval))
1349 DebPrint (("Wait.GetExitCodeProcess failed with %lu\n",
1350 GetLastError ()));
1351 retval = 1;
1353 if (retval == STILL_ACTIVE)
1355 /* Should never happen. */
1356 DebPrint (("Wait.WaitForMultipleObjects returned an active process\n"));
1357 if (pid > 0 && dont_wait)
1358 return 0;
1359 errno = EINVAL;
1360 return -1;
1363 /* Massage the exit code from the process to match the format expected
1364 by the WIFSTOPPED et al macros in syswait.h. Only WIFSIGNALED and
1365 WIFEXITED are supported; WIFSTOPPED doesn't make sense under NT. */
1367 if (retval == STATUS_CONTROL_C_EXIT)
1368 retval = SIGINT;
1369 else
1370 retval <<= 8;
1372 if (pid > 0 && active != 0)
1373 emacs_abort ();
1374 cp = cps[active];
1375 pid = cp->pid;
1376 #ifdef FULL_DEBUG
1377 DebPrint (("Wait signaled with process pid %d\n", cp->pid));
1378 #endif
1380 if (status)
1381 *status = retval;
1382 reap_subprocess (cp);
1384 return pid;
1387 /* Old versions of w32api headers don't have separate 32-bit and
1388 64-bit defines, but the one they have matches the 32-bit variety. */
1389 #ifndef IMAGE_NT_OPTIONAL_HDR32_MAGIC
1390 # define IMAGE_NT_OPTIONAL_HDR32_MAGIC IMAGE_NT_OPTIONAL_HDR_MAGIC
1391 # define IMAGE_OPTIONAL_HEADER32 IMAGE_OPTIONAL_HEADER
1392 #endif
1394 /* Implementation note: This function works with file names encoded in
1395 the current ANSI codepage. */
1396 static void
1397 w32_executable_type (char * filename,
1398 int * is_dos_app,
1399 int * is_cygnus_app,
1400 int * is_gui_app)
1402 file_data executable;
1403 char * p;
1405 /* Default values in case we can't tell for sure. */
1406 *is_dos_app = FALSE;
1407 *is_cygnus_app = FALSE;
1408 *is_gui_app = FALSE;
1410 if (!open_input_file (&executable, filename))
1411 return;
1413 p = strrchr (filename, '.');
1415 /* We can only identify DOS .com programs from the extension. */
1416 if (p && xstrcasecmp (p, ".com") == 0)
1417 *is_dos_app = TRUE;
1418 else if (p && (xstrcasecmp (p, ".bat") == 0
1419 || xstrcasecmp (p, ".cmd") == 0))
1421 /* A DOS shell script - it appears that CreateProcess is happy to
1422 accept this (somewhat surprisingly); presumably it looks at
1423 COMSPEC to determine what executable to actually invoke.
1424 Therefore, we have to do the same here as well. */
1425 /* Actually, I think it uses the program association for that
1426 extension, which is defined in the registry. */
1427 p = egetenv ("COMSPEC");
1428 if (p)
1429 w32_executable_type (p, is_dos_app, is_cygnus_app, is_gui_app);
1431 else
1433 /* Look for DOS .exe signature - if found, we must also check that
1434 it isn't really a 16- or 32-bit Windows exe, since both formats
1435 start with a DOS program stub. Note that 16-bit Windows
1436 executables use the OS/2 1.x format. */
1438 IMAGE_DOS_HEADER * dos_header;
1439 IMAGE_NT_HEADERS * nt_header;
1441 dos_header = (PIMAGE_DOS_HEADER) executable.file_base;
1442 if (dos_header->e_magic != IMAGE_DOS_SIGNATURE)
1443 goto unwind;
1445 nt_header = (PIMAGE_NT_HEADERS) ((unsigned char *) dos_header + dos_header->e_lfanew);
1447 if ((char *) nt_header > (char *) dos_header + executable.size)
1449 /* Some dos headers (pkunzip) have bogus e_lfanew fields. */
1450 *is_dos_app = TRUE;
1452 else if (nt_header->Signature != IMAGE_NT_SIGNATURE
1453 && LOWORD (nt_header->Signature) != IMAGE_OS2_SIGNATURE)
1455 *is_dos_app = TRUE;
1457 else if (nt_header->Signature == IMAGE_NT_SIGNATURE)
1459 IMAGE_DATA_DIRECTORY *data_dir = NULL;
1460 if (nt_header->OptionalHeader.Magic == IMAGE_NT_OPTIONAL_HDR32_MAGIC)
1462 /* Ensure we are using the 32 bit structure. */
1463 IMAGE_OPTIONAL_HEADER32 *opt
1464 = (IMAGE_OPTIONAL_HEADER32*) &(nt_header->OptionalHeader);
1465 data_dir = opt->DataDirectory;
1466 *is_gui_app = (opt->Subsystem == IMAGE_SUBSYSTEM_WINDOWS_GUI);
1468 /* MingW 3.12 has the required 64 bit structs, but in case older
1469 versions don't, only check 64 bit exes if we know how. */
1470 #ifdef IMAGE_NT_OPTIONAL_HDR64_MAGIC
1471 else if (nt_header->OptionalHeader.Magic
1472 == IMAGE_NT_OPTIONAL_HDR64_MAGIC)
1474 IMAGE_OPTIONAL_HEADER64 *opt
1475 = (IMAGE_OPTIONAL_HEADER64*) &(nt_header->OptionalHeader);
1476 data_dir = opt->DataDirectory;
1477 *is_gui_app = (opt->Subsystem == IMAGE_SUBSYSTEM_WINDOWS_GUI);
1479 #endif
1480 if (data_dir)
1482 /* Look for cygwin.dll in DLL import list. */
1483 IMAGE_DATA_DIRECTORY import_dir =
1484 data_dir[IMAGE_DIRECTORY_ENTRY_IMPORT];
1485 IMAGE_IMPORT_DESCRIPTOR * imports;
1486 IMAGE_SECTION_HEADER * section;
1488 section = rva_to_section (import_dir.VirtualAddress, nt_header);
1489 imports = RVA_TO_PTR (import_dir.VirtualAddress, section,
1490 executable);
1492 for ( ; imports->Name; imports++)
1494 char * dllname = RVA_TO_PTR (imports->Name, section,
1495 executable);
1497 /* The exact name of the cygwin dll has changed with
1498 various releases, but hopefully this will be reasonably
1499 future proof. */
1500 if (strncmp (dllname, "cygwin", 6) == 0)
1502 *is_cygnus_app = TRUE;
1503 break;
1510 unwind:
1511 close_file_data (&executable);
1514 static int
1515 compare_env (const void *strp1, const void *strp2)
1517 const char *str1 = *(const char **)strp1, *str2 = *(const char **)strp2;
1519 while (*str1 && *str2 && *str1 != '=' && *str2 != '=')
1521 /* Sort order in command.com/cmd.exe is based on uppercasing
1522 names, so do the same here. */
1523 if (toupper (*str1) > toupper (*str2))
1524 return 1;
1525 else if (toupper (*str1) < toupper (*str2))
1526 return -1;
1527 str1++, str2++;
1530 if (*str1 == '=' && *str2 == '=')
1531 return 0;
1532 else if (*str1 == '=')
1533 return -1;
1534 else
1535 return 1;
1538 static void
1539 merge_and_sort_env (char **envp1, char **envp2, char **new_envp)
1541 char **optr, **nptr;
1542 int num;
1544 nptr = new_envp;
1545 optr = envp1;
1546 while (*optr)
1547 *nptr++ = *optr++;
1548 num = optr - envp1;
1550 optr = envp2;
1551 while (*optr)
1552 *nptr++ = *optr++;
1553 num += optr - envp2;
1555 qsort (new_envp, num, sizeof (char *), compare_env);
1557 *nptr = NULL;
1560 /* When a new child process is created we need to register it in our list,
1561 so intercept spawn requests. */
1563 sys_spawnve (int mode, char *cmdname, char **argv, char **envp)
1565 Lisp_Object program, full;
1566 char *cmdline, *env, *parg, **targ;
1567 int arglen, numenv;
1568 pid_t pid;
1569 child_process *cp;
1570 int is_dos_app, is_cygnus_app, is_gui_app;
1571 int do_quoting = 0;
1572 /* We pass our process ID to our children by setting up an environment
1573 variable in their environment. */
1574 char ppid_env_var_buffer[64];
1575 char *extra_env[] = {ppid_env_var_buffer, NULL};
1576 /* These are the characters that cause an argument to need quoting.
1577 Arguments with whitespace characters need quoting to prevent the
1578 argument being split into two or more. Arguments with wildcards
1579 are also quoted, for consistency with posix platforms, where wildcards
1580 are not expanded if we run the program directly without a shell.
1581 Some extra whitespace characters need quoting in Cygwin programs,
1582 so this list is conditionally modified below. */
1583 char *sepchars = " \t*?";
1584 /* This is for native w32 apps; modified below for Cygwin apps. */
1585 char escape_char = '\\';
1586 char cmdname_a[MAX_PATH];
1588 /* We don't care about the other modes */
1589 if (mode != _P_NOWAIT)
1591 errno = EINVAL;
1592 return -1;
1595 /* Handle executable names without an executable suffix. The caller
1596 already searched exec-path and verified the file is executable,
1597 but start-process doesn't do that for file names that are already
1598 absolute. So we double-check this here, just in case. */
1599 if (faccessat (AT_FDCWD, cmdname, X_OK, AT_EACCESS) != 0)
1601 struct gcpro gcpro1;
1603 program = build_string (cmdname);
1604 full = Qnil;
1605 GCPRO1 (program);
1606 openp (Vexec_path, program, Vexec_suffixes, &full, make_number (X_OK), 0);
1607 UNGCPRO;
1608 if (NILP (full))
1610 errno = EINVAL;
1611 return -1;
1613 program = ENCODE_FILE (full);
1614 cmdname = SDATA (program);
1616 else
1618 char *p = alloca (strlen (cmdname) + 1);
1620 /* Don't change the command name we were passed by our caller
1621 (unixtodos_filename below will destructively mirror forward
1622 slashes). */
1623 cmdname = strcpy (p, cmdname);
1626 /* make sure argv[0] and cmdname are both in DOS format */
1627 unixtodos_filename (cmdname);
1628 /* argv[0] was encoded by caller using ENCODE_FILE, so it is in
1629 UTF-8. All the other arguments are encoded by ENCODE_SYSTEM or
1630 some such, and are in some ANSI codepage. We need to have
1631 argv[0] encoded in ANSI codepage. */
1632 filename_to_ansi (cmdname, cmdname_a);
1633 /* We explicitly require that the command's file name be encodable
1634 in the current ANSI codepage, because we will be invoking it via
1635 the ANSI APIs. */
1636 if (_mbspbrk (cmdname_a, "?"))
1638 errno = ENOENT;
1639 return -1;
1641 /* From here on, CMDNAME is an ANSI-encoded string. */
1642 cmdname = cmdname_a;
1643 argv[0] = cmdname;
1645 /* Determine whether program is a 16-bit DOS executable, or a 32-bit Windows
1646 executable that is implicitly linked to the Cygnus dll (implying it
1647 was compiled with the Cygnus GNU toolchain and hence relies on
1648 cygwin.dll to parse the command line - we use this to decide how to
1649 escape quote chars in command line args that must be quoted).
1651 Also determine whether it is a GUI app, so that we don't hide its
1652 initial window unless specifically requested. */
1653 w32_executable_type (cmdname, &is_dos_app, &is_cygnus_app, &is_gui_app);
1655 /* On Windows 95, if cmdname is a DOS app, we invoke a helper
1656 application to start it by specifying the helper app as cmdname,
1657 while leaving the real app name as argv[0]. */
1658 if (is_dos_app)
1660 char *p;
1662 cmdname = alloca (MAX_PATH);
1663 if (egetenv ("CMDPROXY"))
1664 strcpy (cmdname, egetenv ("CMDPROXY"));
1665 else
1666 strcpy (lispstpcpy (cmdname, Vinvocation_directory), "cmdproxy.exe");
1668 /* Can't use unixtodos_filename here, since that needs its file
1669 name argument encoded in UTF-8. */
1670 for (p = cmdname; *p; p = CharNextA (p))
1671 if (*p == '/')
1672 *p = '\\';
1675 /* we have to do some conjuring here to put argv and envp into the
1676 form CreateProcess wants... argv needs to be a space separated/null
1677 terminated list of parameters, and envp is a null
1678 separated/double-null terminated list of parameters.
1680 Additionally, zero-length args and args containing whitespace or
1681 quote chars need to be wrapped in double quotes - for this to work,
1682 embedded quotes need to be escaped as well. The aim is to ensure
1683 the child process reconstructs the argv array we start with
1684 exactly, so we treat quotes at the beginning and end of arguments
1685 as embedded quotes.
1687 The w32 GNU-based library from Cygnus doubles quotes to escape
1688 them, while MSVC uses backslash for escaping. (Actually the MSVC
1689 startup code does attempt to recognize doubled quotes and accept
1690 them, but gets it wrong and ends up requiring three quotes to get a
1691 single embedded quote!) So by default we decide whether to use
1692 quote or backslash as the escape character based on whether the
1693 binary is apparently a Cygnus compiled app.
1695 Note that using backslash to escape embedded quotes requires
1696 additional special handling if an embedded quote is already
1697 preceded by backslash, or if an arg requiring quoting ends with
1698 backslash. In such cases, the run of escape characters needs to be
1699 doubled. For consistency, we apply this special handling as long
1700 as the escape character is not quote.
1702 Since we have no idea how large argv and envp are likely to be we
1703 figure out list lengths on the fly and allocate them. */
1705 if (!NILP (Vw32_quote_process_args))
1707 do_quoting = 1;
1708 /* Override escape char by binding w32-quote-process-args to
1709 desired character, or use t for auto-selection. */
1710 if (INTEGERP (Vw32_quote_process_args))
1711 escape_char = XINT (Vw32_quote_process_args);
1712 else
1713 escape_char = is_cygnus_app ? '"' : '\\';
1716 /* Cygwin apps needs quoting a bit more often. */
1717 if (escape_char == '"')
1718 sepchars = "\r\n\t\f '";
1720 /* do argv... */
1721 arglen = 0;
1722 targ = argv;
1723 while (*targ)
1725 char * p = *targ;
1726 int need_quotes = 0;
1727 int escape_char_run = 0;
1729 if (*p == 0)
1730 need_quotes = 1;
1731 for ( ; *p; p++)
1733 if (escape_char == '"' && *p == '\\')
1734 /* If it's a Cygwin app, \ needs to be escaped. */
1735 arglen++;
1736 else if (*p == '"')
1738 /* allow for embedded quotes to be escaped */
1739 arglen++;
1740 need_quotes = 1;
1741 /* handle the case where the embedded quote is already escaped */
1742 if (escape_char_run > 0)
1744 /* To preserve the arg exactly, we need to double the
1745 preceding escape characters (plus adding one to
1746 escape the quote character itself). */
1747 arglen += escape_char_run;
1750 else if (strchr (sepchars, *p) != NULL)
1752 need_quotes = 1;
1755 if (*p == escape_char && escape_char != '"')
1756 escape_char_run++;
1757 else
1758 escape_char_run = 0;
1760 if (need_quotes)
1762 arglen += 2;
1763 /* handle the case where the arg ends with an escape char - we
1764 must not let the enclosing quote be escaped. */
1765 if (escape_char_run > 0)
1766 arglen += escape_char_run;
1768 arglen += strlen (*targ++) + 1;
1770 cmdline = alloca (arglen);
1771 targ = argv;
1772 parg = cmdline;
1773 while (*targ)
1775 char * p = *targ;
1776 int need_quotes = 0;
1778 if (*p == 0)
1779 need_quotes = 1;
1781 if (do_quoting)
1783 for ( ; *p; p++)
1784 if ((strchr (sepchars, *p) != NULL) || *p == '"')
1785 need_quotes = 1;
1787 if (need_quotes)
1789 int escape_char_run = 0;
1790 /* char * first; */
1791 /* char * last; */
1793 p = *targ;
1794 /* first = p; */
1795 /* last = p + strlen (p) - 1; */
1796 *parg++ = '"';
1797 #if 0
1798 /* This version does not escape quotes if they occur at the
1799 beginning or end of the arg - this could lead to incorrect
1800 behavior when the arg itself represents a command line
1801 containing quoted args. I believe this was originally done
1802 as a hack to make some things work, before
1803 `w32-quote-process-args' was added. */
1804 while (*p)
1806 if (*p == '"' && p > first && p < last)
1807 *parg++ = escape_char; /* escape embedded quotes */
1808 *parg++ = *p++;
1810 #else
1811 for ( ; *p; p++)
1813 if (*p == '"')
1815 /* double preceding escape chars if any */
1816 while (escape_char_run > 0)
1818 *parg++ = escape_char;
1819 escape_char_run--;
1821 /* escape all quote chars, even at beginning or end */
1822 *parg++ = escape_char;
1824 else if (escape_char == '"' && *p == '\\')
1825 *parg++ = '\\';
1826 *parg++ = *p;
1828 if (*p == escape_char && escape_char != '"')
1829 escape_char_run++;
1830 else
1831 escape_char_run = 0;
1833 /* double escape chars before enclosing quote */
1834 while (escape_char_run > 0)
1836 *parg++ = escape_char;
1837 escape_char_run--;
1839 #endif
1840 *parg++ = '"';
1842 else
1844 strcpy (parg, *targ);
1845 parg += strlen (*targ);
1847 *parg++ = ' ';
1848 targ++;
1850 *--parg = '\0';
1852 /* and envp... */
1853 arglen = 1;
1854 targ = envp;
1855 numenv = 1; /* for end null */
1856 while (*targ)
1858 arglen += strlen (*targ++) + 1;
1859 numenv++;
1861 /* extra env vars... */
1862 sprintf (ppid_env_var_buffer, "EM_PARENT_PROCESS_ID=%lu",
1863 GetCurrentProcessId ());
1864 arglen += strlen (ppid_env_var_buffer) + 1;
1865 numenv++;
1867 /* merge env passed in and extra env into one, and sort it. */
1868 targ = (char **) alloca (numenv * sizeof (char *));
1869 merge_and_sort_env (envp, extra_env, targ);
1871 /* concatenate env entries. */
1872 env = alloca (arglen);
1873 parg = env;
1874 while (*targ)
1876 strcpy (parg, *targ);
1877 parg += strlen (*targ++);
1878 *parg++ = '\0';
1880 *parg++ = '\0';
1881 *parg = '\0';
1883 cp = new_child ();
1884 if (cp == NULL)
1886 errno = EAGAIN;
1887 return -1;
1890 /* Now create the process. */
1891 if (!create_child (cmdname, cmdline, env, is_gui_app, &pid, cp))
1893 delete_child (cp);
1894 errno = ENOEXEC;
1895 return -1;
1898 return pid;
1901 /* Emulate the select call
1902 Wait for available input on any of the given rfds, or timeout if
1903 a timeout is given and no input is detected
1904 wfds and efds are not supported and must be NULL.
1906 For simplicity, we detect the death of child processes here and
1907 synchronously call the SIGCHLD handler. Since it is possible for
1908 children to be created without a corresponding pipe handle from which
1909 to read output, we wait separately on the process handles as well as
1910 the char_avail events for each process pipe. We only call
1911 wait/reap_process when the process actually terminates.
1913 To reduce the number of places in which Emacs can be hung such that
1914 C-g is not able to interrupt it, we always wait on interrupt_handle
1915 (which is signaled by the input thread when C-g is detected). If we
1916 detect that we were woken up by C-g, we return -1 with errno set to
1917 EINTR as on Unix. */
1919 /* From w32console.c */
1920 extern HANDLE keyboard_handle;
1922 /* From w32xfns.c */
1923 extern HANDLE interrupt_handle;
1925 /* From process.c */
1926 extern int proc_buffered_char[];
1929 sys_select (int nfds, SELECT_TYPE *rfds, SELECT_TYPE *wfds, SELECT_TYPE *efds,
1930 struct timespec *timeout, void *ignored)
1932 SELECT_TYPE orfds;
1933 DWORD timeout_ms, start_time;
1934 int i, nh, nc, nr;
1935 DWORD active;
1936 child_process *cp, *cps[MAX_CHILDREN];
1937 HANDLE wait_hnd[MAXDESC + MAX_CHILDREN];
1938 int fdindex[MAXDESC]; /* mapping from wait handles back to descriptors */
1940 timeout_ms =
1941 timeout ? (timeout->tv_sec * 1000 + timeout->tv_nsec / 1000000) : INFINITE;
1943 /* If the descriptor sets are NULL but timeout isn't, then just Sleep. */
1944 if (rfds == NULL && wfds == NULL && efds == NULL && timeout != NULL)
1946 Sleep (timeout_ms);
1947 return 0;
1950 /* Otherwise, we only handle rfds, so fail otherwise. */
1951 if (rfds == NULL || wfds != NULL || efds != NULL)
1953 errno = EINVAL;
1954 return -1;
1957 orfds = *rfds;
1958 FD_ZERO (rfds);
1959 nr = 0;
1961 /* If interrupt_handle is available and valid, always wait on it, to
1962 detect C-g (quit). */
1963 nh = 0;
1964 if (interrupt_handle && interrupt_handle != INVALID_HANDLE_VALUE)
1966 wait_hnd[0] = interrupt_handle;
1967 fdindex[0] = -1;
1968 nh++;
1971 /* Build a list of pipe handles to wait on. */
1972 for (i = 0; i < nfds; i++)
1973 if (FD_ISSET (i, &orfds))
1975 if (i == 0)
1977 if (keyboard_handle)
1979 /* Handle stdin specially */
1980 wait_hnd[nh] = keyboard_handle;
1981 fdindex[nh] = i;
1982 nh++;
1985 /* Check for any emacs-generated input in the queue since
1986 it won't be detected in the wait */
1987 if (detect_input_pending ())
1989 FD_SET (i, rfds);
1990 return 1;
1992 else if (noninteractive)
1994 if (handle_file_notifications (NULL))
1995 return 1;
1998 else
2000 /* Child process and socket/comm port input. */
2001 cp = fd_info[i].cp;
2002 if (cp)
2004 int current_status = cp->status;
2006 if (current_status == STATUS_READ_ACKNOWLEDGED)
2008 /* Tell reader thread which file handle to use. */
2009 cp->fd = i;
2010 /* Wake up the reader thread for this process */
2011 cp->status = STATUS_READ_READY;
2012 if (!SetEvent (cp->char_consumed))
2013 DebPrint (("sys_select.SetEvent failed with "
2014 "%lu for fd %ld\n", GetLastError (), i));
2017 #ifdef CHECK_INTERLOCK
2018 /* slightly crude cross-checking of interlock between threads */
2020 current_status = cp->status;
2021 if (WaitForSingleObject (cp->char_avail, 0) == WAIT_OBJECT_0)
2023 /* char_avail has been signaled, so status (which may
2024 have changed) should indicate read has completed
2025 but has not been acknowledged. */
2026 current_status = cp->status;
2027 if (current_status != STATUS_READ_SUCCEEDED
2028 && current_status != STATUS_READ_FAILED)
2029 DebPrint (("char_avail set, but read not completed: status %d\n",
2030 current_status));
2032 else
2034 /* char_avail has not been signaled, so status should
2035 indicate that read is in progress; small possibility
2036 that read has completed but event wasn't yet signaled
2037 when we tested it (because a context switch occurred
2038 or if running on separate CPUs). */
2039 if (current_status != STATUS_READ_READY
2040 && current_status != STATUS_READ_IN_PROGRESS
2041 && current_status != STATUS_READ_SUCCEEDED
2042 && current_status != STATUS_READ_FAILED)
2043 DebPrint (("char_avail reset, but read status is bad: %d\n",
2044 current_status));
2046 #endif
2047 wait_hnd[nh] = cp->char_avail;
2048 fdindex[nh] = i;
2049 if (!wait_hnd[nh]) emacs_abort ();
2050 nh++;
2051 #ifdef FULL_DEBUG
2052 DebPrint (("select waiting on child %d fd %d\n",
2053 cp-child_procs, i));
2054 #endif
2056 else
2058 /* Unable to find something to wait on for this fd, skip */
2060 /* Note that this is not a fatal error, and can in fact
2061 happen in unusual circumstances. Specifically, if
2062 sys_spawnve fails, eg. because the program doesn't
2063 exist, and debug-on-error is t so Fsignal invokes a
2064 nested input loop, then the process output pipe is
2065 still included in input_wait_mask with no child_proc
2066 associated with it. (It is removed when the debugger
2067 exits the nested input loop and the error is thrown.) */
2069 DebPrint (("sys_select: fd %ld is invalid! ignoring\n", i));
2074 count_children:
2075 /* Add handles of child processes. */
2076 nc = 0;
2077 for (cp = child_procs + (child_proc_count-1); cp >= child_procs; cp--)
2078 /* Some child_procs might be sockets; ignore them. Also some
2079 children may have died already, but we haven't finished reading
2080 the process output; ignore them too. */
2081 if ((CHILD_ACTIVE (cp) && cp->procinfo.hProcess)
2082 && (cp->fd < 0
2083 || (fd_info[cp->fd].flags & FILE_SEND_SIGCHLD) == 0
2084 || (fd_info[cp->fd].flags & FILE_AT_EOF) != 0)
2087 wait_hnd[nh + nc] = cp->procinfo.hProcess;
2088 cps[nc] = cp;
2089 nc++;
2092 /* Nothing to look for, so we didn't find anything */
2093 if (nh + nc == 0)
2095 if (timeout)
2096 Sleep (timeout_ms);
2097 if (noninteractive)
2099 if (handle_file_notifications (NULL))
2100 return 1;
2102 return 0;
2105 start_time = GetTickCount ();
2107 /* Wait for input or child death to be signaled. If user input is
2108 allowed, then also accept window messages. */
2109 if (FD_ISSET (0, &orfds))
2110 active = MsgWaitForMultipleObjects (nh + nc, wait_hnd, FALSE, timeout_ms,
2111 QS_ALLINPUT);
2112 else
2113 active = WaitForMultipleObjects (nh + nc, wait_hnd, FALSE, timeout_ms);
2115 if (active == WAIT_FAILED)
2117 DebPrint (("select.WaitForMultipleObjects (%d, %lu) failed with %lu\n",
2118 nh + nc, timeout_ms, GetLastError ()));
2119 /* don't return EBADF - this causes wait_reading_process_output to
2120 abort; WAIT_FAILED is returned when single-stepping under
2121 Windows 95 after switching thread focus in debugger, and
2122 possibly at other times. */
2123 errno = EINTR;
2124 return -1;
2126 else if (active == WAIT_TIMEOUT)
2128 if (noninteractive)
2130 if (handle_file_notifications (NULL))
2131 return 1;
2133 return 0;
2135 else if (active >= WAIT_OBJECT_0
2136 && active < WAIT_OBJECT_0+MAXIMUM_WAIT_OBJECTS)
2138 active -= WAIT_OBJECT_0;
2140 else if (active >= WAIT_ABANDONED_0
2141 && active < WAIT_ABANDONED_0+MAXIMUM_WAIT_OBJECTS)
2143 active -= WAIT_ABANDONED_0;
2145 else
2146 emacs_abort ();
2148 /* Loop over all handles after active (now officially documented as
2149 being the first signaled handle in the array). We do this to
2150 ensure fairness, so that all channels with data available will be
2151 processed - otherwise higher numbered channels could be starved. */
2154 if (active == nh + nc)
2156 /* There are messages in the lisp thread's queue; we must
2157 drain the queue now to ensure they are processed promptly,
2158 because if we don't do so, we will not be woken again until
2159 further messages arrive.
2161 NB. If ever we allow window message procedures to callback
2162 into lisp, we will need to ensure messages are dispatched
2163 at a safe time for lisp code to be run (*), and we may also
2164 want to provide some hooks in the dispatch loop to cater
2165 for modeless dialogs created by lisp (ie. to register
2166 window handles to pass to IsDialogMessage).
2168 (*) Note that MsgWaitForMultipleObjects above is an
2169 internal dispatch point for messages that are sent to
2170 windows created by this thread. */
2171 if (drain_message_queue ()
2172 /* If drain_message_queue returns non-zero, that means
2173 we received a WM_EMACS_FILENOTIFY message. If this
2174 is a TTY frame, we must signal the caller that keyboard
2175 input is available, so that w32_console_read_socket
2176 will be called to pick up the notifications. If we
2177 don't do that, file notifications will only work when
2178 the Emacs TTY frame has focus. */
2179 && FRAME_TERMCAP_P (SELECTED_FRAME ())
2180 /* they asked for stdin reads */
2181 && FD_ISSET (0, &orfds)
2182 /* the stdin handle is valid */
2183 && keyboard_handle)
2185 FD_SET (0, rfds);
2186 if (nr == 0)
2187 nr = 1;
2190 else if (active >= nh)
2192 cp = cps[active - nh];
2194 /* We cannot always signal SIGCHLD immediately; if we have not
2195 finished reading the process output, we must delay sending
2196 SIGCHLD until we do. */
2198 if (cp->fd >= 0 && (fd_info[cp->fd].flags & FILE_AT_EOF) == 0)
2199 fd_info[cp->fd].flags |= FILE_SEND_SIGCHLD;
2200 /* SIG_DFL for SIGCHLD is ignore */
2201 else if (sig_handlers[SIGCHLD] != SIG_DFL &&
2202 sig_handlers[SIGCHLD] != SIG_IGN)
2204 #ifdef FULL_DEBUG
2205 DebPrint (("select calling SIGCHLD handler for pid %d\n",
2206 cp->pid));
2207 #endif
2208 sig_handlers[SIGCHLD] (SIGCHLD);
2211 else if (fdindex[active] == -1)
2213 /* Quit (C-g) was detected. */
2214 errno = EINTR;
2215 return -1;
2217 else if (fdindex[active] == 0)
2219 /* Keyboard input available */
2220 FD_SET (0, rfds);
2221 nr++;
2223 else
2225 /* must be a socket or pipe - read ahead should have
2226 completed, either succeeding or failing. */
2227 FD_SET (fdindex[active], rfds);
2228 nr++;
2231 /* Even though wait_reading_process_output only reads from at most
2232 one channel, we must process all channels here so that we reap
2233 all children that have died. */
2234 while (++active < nh + nc)
2235 if (WaitForSingleObject (wait_hnd[active], 0) == WAIT_OBJECT_0)
2236 break;
2237 } while (active < nh + nc);
2239 if (noninteractive)
2241 if (handle_file_notifications (NULL))
2242 nr++;
2245 /* If no input has arrived and timeout hasn't expired, wait again. */
2246 if (nr == 0)
2248 DWORD elapsed = GetTickCount () - start_time;
2250 if (timeout_ms > elapsed) /* INFINITE is MAX_UINT */
2252 if (timeout_ms != INFINITE)
2253 timeout_ms -= elapsed;
2254 goto count_children;
2258 return nr;
2261 /* Substitute for certain kill () operations */
2263 static BOOL CALLBACK
2264 find_child_console (HWND hwnd, LPARAM arg)
2266 child_process * cp = (child_process *) arg;
2267 DWORD process_id;
2269 GetWindowThreadProcessId (hwnd, &process_id);
2270 if (process_id == cp->procinfo.dwProcessId)
2272 char window_class[32];
2274 GetClassName (hwnd, window_class, sizeof (window_class));
2275 if (strcmp (window_class,
2276 (os_subtype == OS_9X)
2277 ? "tty"
2278 : "ConsoleWindowClass") == 0)
2280 cp->hwnd = hwnd;
2281 return FALSE;
2284 /* keep looking */
2285 return TRUE;
2288 /* Emulate 'kill', but only for other processes. */
2290 sys_kill (pid_t pid, int sig)
2292 child_process *cp;
2293 HANDLE proc_hand;
2294 int need_to_free = 0;
2295 int rc = 0;
2297 /* Each process is in its own process group. */
2298 if (pid < 0)
2299 pid = -pid;
2301 /* Only handle signals that will result in the process dying */
2302 if (sig != 0
2303 && sig != SIGINT && sig != SIGKILL && sig != SIGQUIT && sig != SIGHUP)
2305 errno = EINVAL;
2306 return -1;
2309 if (sig == 0)
2311 /* It will take _some_ time before PID 4 or less on Windows will
2312 be Emacs... */
2313 if (pid <= 4)
2315 errno = EPERM;
2316 return -1;
2318 proc_hand = OpenProcess (PROCESS_QUERY_INFORMATION, 0, pid);
2319 if (proc_hand == NULL)
2321 DWORD err = GetLastError ();
2323 switch (err)
2325 case ERROR_ACCESS_DENIED: /* existing process, but access denied */
2326 errno = EPERM;
2327 return -1;
2328 case ERROR_INVALID_PARAMETER: /* process PID does not exist */
2329 errno = ESRCH;
2330 return -1;
2333 else
2334 CloseHandle (proc_hand);
2335 return 0;
2338 cp = find_child_pid (pid);
2339 if (cp == NULL)
2341 /* We were passed a PID of something other than our subprocess.
2342 If that is our own PID, we will send to ourself a message to
2343 close the selected frame, which does not necessarily
2344 terminates Emacs. But then we are not supposed to call
2345 sys_kill with our own PID. */
2346 proc_hand = OpenProcess (PROCESS_TERMINATE, 0, pid);
2347 if (proc_hand == NULL)
2349 errno = EPERM;
2350 return -1;
2352 need_to_free = 1;
2354 else
2356 proc_hand = cp->procinfo.hProcess;
2357 pid = cp->procinfo.dwProcessId;
2359 /* Try to locate console window for process. */
2360 EnumWindows (find_child_console, (LPARAM) cp);
2363 if (sig == SIGINT || sig == SIGQUIT)
2365 if (NILP (Vw32_start_process_share_console) && cp && cp->hwnd)
2367 BYTE control_scan_code = (BYTE) MapVirtualKey (VK_CONTROL, 0);
2368 /* Fake Ctrl-C for SIGINT, and Ctrl-Break for SIGQUIT. */
2369 BYTE vk_break_code = (sig == SIGINT) ? 'C' : VK_CANCEL;
2370 BYTE break_scan_code = (BYTE) MapVirtualKey (vk_break_code, 0);
2371 HWND foreground_window;
2373 if (break_scan_code == 0)
2375 /* Fake Ctrl-C for SIGQUIT if we can't manage Ctrl-Break. */
2376 vk_break_code = 'C';
2377 break_scan_code = (BYTE) MapVirtualKey (vk_break_code, 0);
2380 foreground_window = GetForegroundWindow ();
2381 if (foreground_window)
2383 /* NT 5.0, and apparently also Windows 98, will not allow
2384 a Window to be set to foreground directly without the
2385 user's involvement. The workaround is to attach
2386 ourselves to the thread that owns the foreground
2387 window, since that is the only thread that can set the
2388 foreground window. */
2389 DWORD foreground_thread, child_thread;
2390 foreground_thread =
2391 GetWindowThreadProcessId (foreground_window, NULL);
2392 if (foreground_thread == GetCurrentThreadId ()
2393 || !AttachThreadInput (GetCurrentThreadId (),
2394 foreground_thread, TRUE))
2395 foreground_thread = 0;
2397 child_thread = GetWindowThreadProcessId (cp->hwnd, NULL);
2398 if (child_thread == GetCurrentThreadId ()
2399 || !AttachThreadInput (GetCurrentThreadId (),
2400 child_thread, TRUE))
2401 child_thread = 0;
2403 /* Set the foreground window to the child. */
2404 if (SetForegroundWindow (cp->hwnd))
2406 /* Generate keystrokes as if user had typed Ctrl-Break or
2407 Ctrl-C. */
2408 keybd_event (VK_CONTROL, control_scan_code, 0, 0);
2409 keybd_event (vk_break_code, break_scan_code,
2410 (vk_break_code == 'C' ? 0 : KEYEVENTF_EXTENDEDKEY), 0);
2411 keybd_event (vk_break_code, break_scan_code,
2412 (vk_break_code == 'C' ? 0 : KEYEVENTF_EXTENDEDKEY)
2413 | KEYEVENTF_KEYUP, 0);
2414 keybd_event (VK_CONTROL, control_scan_code,
2415 KEYEVENTF_KEYUP, 0);
2417 /* Sleep for a bit to give time for Emacs frame to respond
2418 to focus change events (if Emacs was active app). */
2419 Sleep (100);
2421 SetForegroundWindow (foreground_window);
2423 /* Detach from the foreground and child threads now that
2424 the foreground switching is over. */
2425 if (foreground_thread)
2426 AttachThreadInput (GetCurrentThreadId (),
2427 foreground_thread, FALSE);
2428 if (child_thread)
2429 AttachThreadInput (GetCurrentThreadId (),
2430 child_thread, FALSE);
2433 /* Ctrl-Break is NT equivalent of SIGINT. */
2434 else if (!GenerateConsoleCtrlEvent (CTRL_BREAK_EVENT, pid))
2436 DebPrint (("sys_kill.GenerateConsoleCtrlEvent return %d "
2437 "for pid %lu\n", GetLastError (), pid));
2438 errno = EINVAL;
2439 rc = -1;
2442 else
2444 if (NILP (Vw32_start_process_share_console) && cp && cp->hwnd)
2446 #if 1
2447 if (os_subtype == OS_9X)
2450 Another possibility is to try terminating the VDM out-right by
2451 calling the Shell VxD (id 0x17) V86 interface, function #4
2452 "SHELL_Destroy_VM", ie.
2454 mov edx,4
2455 mov ebx,vm_handle
2456 call shellapi
2458 First need to determine the current VM handle, and then arrange for
2459 the shellapi call to be made from the system vm (by using
2460 Switch_VM_and_callback).
2462 Could try to invoke DestroyVM through CallVxD.
2465 #if 0
2466 /* On Windows 95, posting WM_QUIT causes the 16-bit subsystem
2467 to hang when cmdproxy is used in conjunction with
2468 command.com for an interactive shell. Posting
2469 WM_CLOSE pops up a dialog that, when Yes is selected,
2470 does the same thing. TerminateProcess is also less
2471 than ideal in that subprocesses tend to stick around
2472 until the machine is shutdown, but at least it
2473 doesn't freeze the 16-bit subsystem. */
2474 PostMessage (cp->hwnd, WM_QUIT, 0xff, 0);
2475 #endif
2476 if (!TerminateProcess (proc_hand, 0xff))
2478 DebPrint (("sys_kill.TerminateProcess returned %d "
2479 "for pid %lu\n", GetLastError (), pid));
2480 errno = EINVAL;
2481 rc = -1;
2484 else
2485 #endif
2486 PostMessage (cp->hwnd, WM_CLOSE, 0, 0);
2488 /* Kill the process. On W32 this doesn't kill child processes
2489 so it doesn't work very well for shells which is why it's not
2490 used in every case. */
2491 else if (!TerminateProcess (proc_hand, 0xff))
2493 DebPrint (("sys_kill.TerminateProcess returned %d "
2494 "for pid %lu\n", GetLastError (), pid));
2495 errno = EINVAL;
2496 rc = -1;
2500 if (need_to_free)
2501 CloseHandle (proc_hand);
2503 return rc;
2506 /* The following two routines are used to manipulate stdin, stdout, and
2507 stderr of our child processes.
2509 Assuming that in, out, and err are *not* inheritable, we make them
2510 stdin, stdout, and stderr of the child as follows:
2512 - Save the parent's current standard handles.
2513 - Set the std handles to inheritable duplicates of the ones being passed in.
2514 (Note that _get_osfhandle() is an io.h procedure that retrieves the
2515 NT file handle for a crt file descriptor.)
2516 - Spawn the child, which inherits in, out, and err as stdin,
2517 stdout, and stderr. (see Spawnve)
2518 - Close the std handles passed to the child.
2519 - Reset the parent's standard handles to the saved handles.
2520 (see reset_standard_handles)
2521 We assume that the caller closes in, out, and err after calling us. */
2523 void
2524 prepare_standard_handles (int in, int out, int err, HANDLE handles[3])
2526 HANDLE parent;
2527 HANDLE newstdin, newstdout, newstderr;
2529 parent = GetCurrentProcess ();
2531 handles[0] = GetStdHandle (STD_INPUT_HANDLE);
2532 handles[1] = GetStdHandle (STD_OUTPUT_HANDLE);
2533 handles[2] = GetStdHandle (STD_ERROR_HANDLE);
2535 /* make inheritable copies of the new handles */
2536 if (!DuplicateHandle (parent,
2537 (HANDLE) _get_osfhandle (in),
2538 parent,
2539 &newstdin,
2541 TRUE,
2542 DUPLICATE_SAME_ACCESS))
2543 report_file_error ("Duplicating input handle for child", Qnil);
2545 if (!DuplicateHandle (parent,
2546 (HANDLE) _get_osfhandle (out),
2547 parent,
2548 &newstdout,
2550 TRUE,
2551 DUPLICATE_SAME_ACCESS))
2552 report_file_error ("Duplicating output handle for child", Qnil);
2554 if (!DuplicateHandle (parent,
2555 (HANDLE) _get_osfhandle (err),
2556 parent,
2557 &newstderr,
2559 TRUE,
2560 DUPLICATE_SAME_ACCESS))
2561 report_file_error ("Duplicating error handle for child", Qnil);
2563 /* and store them as our std handles */
2564 if (!SetStdHandle (STD_INPUT_HANDLE, newstdin))
2565 report_file_error ("Changing stdin handle", Qnil);
2567 if (!SetStdHandle (STD_OUTPUT_HANDLE, newstdout))
2568 report_file_error ("Changing stdout handle", Qnil);
2570 if (!SetStdHandle (STD_ERROR_HANDLE, newstderr))
2571 report_file_error ("Changing stderr handle", Qnil);
2574 void
2575 reset_standard_handles (int in, int out, int err, HANDLE handles[3])
2577 /* close the duplicated handles passed to the child */
2578 CloseHandle (GetStdHandle (STD_INPUT_HANDLE));
2579 CloseHandle (GetStdHandle (STD_OUTPUT_HANDLE));
2580 CloseHandle (GetStdHandle (STD_ERROR_HANDLE));
2582 /* now restore parent's saved std handles */
2583 SetStdHandle (STD_INPUT_HANDLE, handles[0]);
2584 SetStdHandle (STD_OUTPUT_HANDLE, handles[1]);
2585 SetStdHandle (STD_ERROR_HANDLE, handles[2]);
2588 void
2589 set_process_dir (char * dir)
2591 process_dir = dir;
2594 /* To avoid problems with winsock implementations that work over dial-up
2595 connections causing or requiring a connection to exist while Emacs is
2596 running, Emacs no longer automatically loads winsock on startup if it
2597 is present. Instead, it will be loaded when open-network-stream is
2598 first called.
2600 To allow full control over when winsock is loaded, we provide these
2601 two functions to dynamically load and unload winsock. This allows
2602 dial-up users to only be connected when they actually need to use
2603 socket services. */
2605 /* From w32.c */
2606 extern HANDLE winsock_lib;
2607 extern BOOL term_winsock (void);
2608 extern BOOL init_winsock (int load_now);
2610 DEFUN ("w32-has-winsock", Fw32_has_winsock, Sw32_has_winsock, 0, 1, 0,
2611 doc: /* Test for presence of the Windows socket library `winsock'.
2612 Returns non-nil if winsock support is present, nil otherwise.
2614 If the optional argument LOAD-NOW is non-nil, the winsock library is
2615 also loaded immediately if not already loaded. If winsock is loaded,
2616 the winsock local hostname is returned (since this may be different from
2617 the value of `system-name' and should supplant it), otherwise t is
2618 returned to indicate winsock support is present. */)
2619 (Lisp_Object load_now)
2621 int have_winsock;
2623 have_winsock = init_winsock (!NILP (load_now));
2624 if (have_winsock)
2626 if (winsock_lib != NULL)
2628 /* Return new value for system-name. The best way to do this
2629 is to call init_system_name, saving and restoring the
2630 original value to avoid side-effects. */
2631 Lisp_Object orig_hostname = Vsystem_name;
2632 Lisp_Object hostname;
2634 init_system_name ();
2635 hostname = Vsystem_name;
2636 Vsystem_name = orig_hostname;
2637 return hostname;
2639 return Qt;
2641 return Qnil;
2644 DEFUN ("w32-unload-winsock", Fw32_unload_winsock, Sw32_unload_winsock,
2645 0, 0, 0,
2646 doc: /* Unload the Windows socket library `winsock' if loaded.
2647 This is provided to allow dial-up socket connections to be disconnected
2648 when no longer needed. Returns nil without unloading winsock if any
2649 socket connections still exist. */)
2650 (void)
2652 return term_winsock () ? Qt : Qnil;
2656 /* Some miscellaneous functions that are Windows specific, but not GUI
2657 specific (ie. are applicable in terminal or batch mode as well). */
2659 DEFUN ("w32-short-file-name", Fw32_short_file_name, Sw32_short_file_name, 1, 1, 0,
2660 doc: /* Return the short file name version (8.3) of the full path of FILENAME.
2661 If FILENAME does not exist, return nil.
2662 All path elements in FILENAME are converted to their short names. */)
2663 (Lisp_Object filename)
2665 char shortname[MAX_PATH];
2667 CHECK_STRING (filename);
2669 /* first expand it. */
2670 filename = Fexpand_file_name (filename, Qnil);
2672 /* luckily, this returns the short version of each element in the path. */
2673 if (w32_get_short_filename (SDATA (ENCODE_FILE (filename)),
2674 shortname, MAX_PATH) == 0)
2675 return Qnil;
2677 dostounix_filename (shortname);
2679 /* No need to DECODE_FILE, because 8.3 names are pure ASCII. */
2680 return build_string (shortname);
2684 DEFUN ("w32-long-file-name", Fw32_long_file_name, Sw32_long_file_name,
2685 1, 1, 0,
2686 doc: /* Return the long file name version of the full path of FILENAME.
2687 If FILENAME does not exist, return nil.
2688 All path elements in FILENAME are converted to their long names. */)
2689 (Lisp_Object filename)
2691 char longname[ MAX_UTF8_PATH ];
2692 int drive_only = 0;
2694 CHECK_STRING (filename);
2696 if (SBYTES (filename) == 2
2697 && *(SDATA (filename) + 1) == ':')
2698 drive_only = 1;
2700 /* first expand it. */
2701 filename = Fexpand_file_name (filename, Qnil);
2703 if (!w32_get_long_filename (SDATA (ENCODE_FILE (filename)), longname,
2704 MAX_UTF8_PATH))
2705 return Qnil;
2707 dostounix_filename (longname);
2709 /* If we were passed only a drive, make sure that a slash is not appended
2710 for consistency with directories. Allow for drive mapping via SUBST
2711 in case expand-file-name is ever changed to expand those. */
2712 if (drive_only && longname[1] == ':' && longname[2] == '/' && !longname[3])
2713 longname[2] = '\0';
2715 return DECODE_FILE (build_unibyte_string (longname));
2718 DEFUN ("w32-set-process-priority", Fw32_set_process_priority,
2719 Sw32_set_process_priority, 2, 2, 0,
2720 doc: /* Set the priority of PROCESS to PRIORITY.
2721 If PROCESS is nil, the priority of Emacs is changed, otherwise the
2722 priority of the process whose pid is PROCESS is changed.
2723 PRIORITY should be one of the symbols high, normal, or low;
2724 any other symbol will be interpreted as normal.
2726 If successful, the return value is t, otherwise nil. */)
2727 (Lisp_Object process, Lisp_Object priority)
2729 HANDLE proc_handle = GetCurrentProcess ();
2730 DWORD priority_class = NORMAL_PRIORITY_CLASS;
2731 Lisp_Object result = Qnil;
2733 CHECK_SYMBOL (priority);
2735 if (!NILP (process))
2737 DWORD pid;
2738 child_process *cp;
2740 CHECK_NUMBER (process);
2742 /* Allow pid to be an internally generated one, or one obtained
2743 externally. This is necessary because real pids on Windows 95 are
2744 negative. */
2746 pid = XINT (process);
2747 cp = find_child_pid (pid);
2748 if (cp != NULL)
2749 pid = cp->procinfo.dwProcessId;
2751 proc_handle = OpenProcess (PROCESS_SET_INFORMATION, FALSE, pid);
2754 if (EQ (priority, Qhigh))
2755 priority_class = HIGH_PRIORITY_CLASS;
2756 else if (EQ (priority, Qlow))
2757 priority_class = IDLE_PRIORITY_CLASS;
2759 if (proc_handle != NULL)
2761 if (SetPriorityClass (proc_handle, priority_class))
2762 result = Qt;
2763 if (!NILP (process))
2764 CloseHandle (proc_handle);
2767 return result;
2770 #ifdef HAVE_LANGINFO_CODESET
2771 /* Emulation of nl_langinfo. Used in fns.c:Flocale_info. */
2772 char *
2773 nl_langinfo (nl_item item)
2775 /* Conversion of Posix item numbers to their Windows equivalents. */
2776 static const LCTYPE w32item[] = {
2777 LOCALE_IDEFAULTANSICODEPAGE,
2778 LOCALE_SDAYNAME1, LOCALE_SDAYNAME2, LOCALE_SDAYNAME3,
2779 LOCALE_SDAYNAME4, LOCALE_SDAYNAME5, LOCALE_SDAYNAME6, LOCALE_SDAYNAME7,
2780 LOCALE_SMONTHNAME1, LOCALE_SMONTHNAME2, LOCALE_SMONTHNAME3,
2781 LOCALE_SMONTHNAME4, LOCALE_SMONTHNAME5, LOCALE_SMONTHNAME6,
2782 LOCALE_SMONTHNAME7, LOCALE_SMONTHNAME8, LOCALE_SMONTHNAME9,
2783 LOCALE_SMONTHNAME10, LOCALE_SMONTHNAME11, LOCALE_SMONTHNAME12
2786 static char *nl_langinfo_buf = NULL;
2787 static int nl_langinfo_len = 0;
2789 if (nl_langinfo_len <= 0)
2790 nl_langinfo_buf = xmalloc (nl_langinfo_len = 1);
2792 if (item < 0 || item >= _NL_NUM)
2793 nl_langinfo_buf[0] = 0;
2794 else
2796 LCID cloc = GetThreadLocale ();
2797 int need_len = GetLocaleInfo (cloc, w32item[item] | LOCALE_USE_CP_ACP,
2798 NULL, 0);
2800 if (need_len <= 0)
2801 nl_langinfo_buf[0] = 0;
2802 else
2804 if (item == CODESET)
2806 need_len += 2; /* for the "cp" prefix */
2807 if (need_len < 8) /* for the case we call GetACP */
2808 need_len = 8;
2810 if (nl_langinfo_len <= need_len)
2811 nl_langinfo_buf = xrealloc (nl_langinfo_buf,
2812 nl_langinfo_len = need_len);
2813 if (!GetLocaleInfo (cloc, w32item[item] | LOCALE_USE_CP_ACP,
2814 nl_langinfo_buf, nl_langinfo_len))
2815 nl_langinfo_buf[0] = 0;
2816 else if (item == CODESET)
2818 if (strcmp (nl_langinfo_buf, "0") == 0 /* CP_ACP */
2819 || strcmp (nl_langinfo_buf, "1") == 0) /* CP_OEMCP */
2820 sprintf (nl_langinfo_buf, "cp%u", GetACP ());
2821 else
2823 memmove (nl_langinfo_buf + 2, nl_langinfo_buf,
2824 strlen (nl_langinfo_buf) + 1);
2825 nl_langinfo_buf[0] = 'c';
2826 nl_langinfo_buf[1] = 'p';
2831 return nl_langinfo_buf;
2833 #endif /* HAVE_LANGINFO_CODESET */
2835 DEFUN ("w32-get-locale-info", Fw32_get_locale_info,
2836 Sw32_get_locale_info, 1, 2, 0,
2837 doc: /* Return information about the Windows locale LCID.
2838 By default, return a three letter locale code which encodes the default
2839 language as the first two characters, and the country or regional variant
2840 as the third letter. For example, ENU refers to `English (United States)',
2841 while ENC means `English (Canadian)'.
2843 If the optional argument LONGFORM is t, the long form of the locale
2844 name is returned, e.g. `English (United States)' instead; if LONGFORM
2845 is a number, it is interpreted as an LCTYPE constant and the corresponding
2846 locale information is returned.
2848 If LCID (a 16-bit number) is not a valid locale, the result is nil. */)
2849 (Lisp_Object lcid, Lisp_Object longform)
2851 int got_abbrev;
2852 int got_full;
2853 char abbrev_name[32] = { 0 };
2854 char full_name[256] = { 0 };
2856 CHECK_NUMBER (lcid);
2858 if (!IsValidLocale (XINT (lcid), LCID_SUPPORTED))
2859 return Qnil;
2861 if (NILP (longform))
2863 got_abbrev = GetLocaleInfo (XINT (lcid),
2864 LOCALE_SABBREVLANGNAME | LOCALE_USE_CP_ACP,
2865 abbrev_name, sizeof (abbrev_name));
2866 if (got_abbrev)
2867 return build_string (abbrev_name);
2869 else if (EQ (longform, Qt))
2871 got_full = GetLocaleInfo (XINT (lcid),
2872 LOCALE_SLANGUAGE | LOCALE_USE_CP_ACP,
2873 full_name, sizeof (full_name));
2874 if (got_full)
2875 return DECODE_SYSTEM (build_string (full_name));
2877 else if (NUMBERP (longform))
2879 got_full = GetLocaleInfo (XINT (lcid),
2880 XINT (longform),
2881 full_name, sizeof (full_name));
2882 /* GetLocaleInfo's return value includes the terminating null
2883 character, when the returned information is a string, whereas
2884 make_unibyte_string needs the string length without the
2885 terminating null. */
2886 if (got_full)
2887 return make_unibyte_string (full_name, got_full - 1);
2890 return Qnil;
2894 DEFUN ("w32-get-current-locale-id", Fw32_get_current_locale_id,
2895 Sw32_get_current_locale_id, 0, 0, 0,
2896 doc: /* Return Windows locale id for current locale setting.
2897 This is a numerical value; use `w32-get-locale-info' to convert to a
2898 human-readable form. */)
2899 (void)
2901 return make_number (GetThreadLocale ());
2904 static DWORD
2905 int_from_hex (char * s)
2907 DWORD val = 0;
2908 static char hex[] = "0123456789abcdefABCDEF";
2909 char * p;
2911 while (*s && (p = strchr (hex, *s)) != NULL)
2913 unsigned digit = p - hex;
2914 if (digit > 15)
2915 digit -= 6;
2916 val = val * 16 + digit;
2917 s++;
2919 return val;
2922 /* We need to build a global list, since the EnumSystemLocale callback
2923 function isn't given a context pointer. */
2924 Lisp_Object Vw32_valid_locale_ids;
2926 static BOOL CALLBACK ALIGN_STACK
2927 enum_locale_fn (LPTSTR localeNum)
2929 DWORD id = int_from_hex (localeNum);
2930 Vw32_valid_locale_ids = Fcons (make_number (id), Vw32_valid_locale_ids);
2931 return TRUE;
2934 DEFUN ("w32-get-valid-locale-ids", Fw32_get_valid_locale_ids,
2935 Sw32_get_valid_locale_ids, 0, 0, 0,
2936 doc: /* Return list of all valid Windows locale ids.
2937 Each id is a numerical value; use `w32-get-locale-info' to convert to a
2938 human-readable form. */)
2939 (void)
2941 Vw32_valid_locale_ids = Qnil;
2943 EnumSystemLocales (enum_locale_fn, LCID_SUPPORTED);
2945 Vw32_valid_locale_ids = Fnreverse (Vw32_valid_locale_ids);
2946 return Vw32_valid_locale_ids;
2950 DEFUN ("w32-get-default-locale-id", Fw32_get_default_locale_id, Sw32_get_default_locale_id, 0, 1, 0,
2951 doc: /* Return Windows locale id for default locale setting.
2952 By default, the system default locale setting is returned; if the optional
2953 parameter USERP is non-nil, the user default locale setting is returned.
2954 This is a numerical value; use `w32-get-locale-info' to convert to a
2955 human-readable form. */)
2956 (Lisp_Object userp)
2958 if (NILP (userp))
2959 return make_number (GetSystemDefaultLCID ());
2960 return make_number (GetUserDefaultLCID ());
2964 DEFUN ("w32-set-current-locale", Fw32_set_current_locale, Sw32_set_current_locale, 1, 1, 0,
2965 doc: /* Make Windows locale LCID be the current locale setting for Emacs.
2966 If successful, the new locale id is returned, otherwise nil. */)
2967 (Lisp_Object lcid)
2969 CHECK_NUMBER (lcid);
2971 if (!IsValidLocale (XINT (lcid), LCID_SUPPORTED))
2972 return Qnil;
2974 if (!SetThreadLocale (XINT (lcid)))
2975 return Qnil;
2977 /* Need to set input thread locale if present. */
2978 if (dwWindowsThreadId)
2979 /* Reply is not needed. */
2980 PostThreadMessage (dwWindowsThreadId, WM_EMACS_SETLOCALE, XINT (lcid), 0);
2982 return make_number (GetThreadLocale ());
2986 /* We need to build a global list, since the EnumCodePages callback
2987 function isn't given a context pointer. */
2988 Lisp_Object Vw32_valid_codepages;
2990 static BOOL CALLBACK ALIGN_STACK
2991 enum_codepage_fn (LPTSTR codepageNum)
2993 DWORD id = atoi (codepageNum);
2994 Vw32_valid_codepages = Fcons (make_number (id), Vw32_valid_codepages);
2995 return TRUE;
2998 DEFUN ("w32-get-valid-codepages", Fw32_get_valid_codepages,
2999 Sw32_get_valid_codepages, 0, 0, 0,
3000 doc: /* Return list of all valid Windows codepages. */)
3001 (void)
3003 Vw32_valid_codepages = Qnil;
3005 EnumSystemCodePages (enum_codepage_fn, CP_SUPPORTED);
3007 Vw32_valid_codepages = Fnreverse (Vw32_valid_codepages);
3008 return Vw32_valid_codepages;
3012 DEFUN ("w32-get-console-codepage", Fw32_get_console_codepage,
3013 Sw32_get_console_codepage, 0, 0, 0,
3014 doc: /* Return current Windows codepage for console input. */)
3015 (void)
3017 return make_number (GetConsoleCP ());
3021 DEFUN ("w32-set-console-codepage", Fw32_set_console_codepage,
3022 Sw32_set_console_codepage, 1, 1, 0,
3023 doc: /* Make Windows codepage CP be the codepage for Emacs tty keyboard input.
3024 This codepage setting affects keyboard input in tty mode.
3025 If successful, the new CP is returned, otherwise nil. */)
3026 (Lisp_Object cp)
3028 CHECK_NUMBER (cp);
3030 if (!IsValidCodePage (XINT (cp)))
3031 return Qnil;
3033 if (!SetConsoleCP (XINT (cp)))
3034 return Qnil;
3036 return make_number (GetConsoleCP ());
3040 DEFUN ("w32-get-console-output-codepage", Fw32_get_console_output_codepage,
3041 Sw32_get_console_output_codepage, 0, 0, 0,
3042 doc: /* Return current Windows codepage for console output. */)
3043 (void)
3045 return make_number (GetConsoleOutputCP ());
3049 DEFUN ("w32-set-console-output-codepage", Fw32_set_console_output_codepage,
3050 Sw32_set_console_output_codepage, 1, 1, 0,
3051 doc: /* Make Windows codepage CP be the codepage for Emacs console output.
3052 This codepage setting affects display in tty mode.
3053 If successful, the new CP is returned, otherwise nil. */)
3054 (Lisp_Object cp)
3056 CHECK_NUMBER (cp);
3058 if (!IsValidCodePage (XINT (cp)))
3059 return Qnil;
3061 if (!SetConsoleOutputCP (XINT (cp)))
3062 return Qnil;
3064 return make_number (GetConsoleOutputCP ());
3068 DEFUN ("w32-get-codepage-charset", Fw32_get_codepage_charset,
3069 Sw32_get_codepage_charset, 1, 1, 0,
3070 doc: /* Return charset ID corresponding to codepage CP.
3071 Returns nil if the codepage is not valid or its charset ID could
3072 not be determined.
3074 Note that this function is only guaranteed to work with ANSI
3075 codepages; most console codepages are not supported and will
3076 yield nil. */)
3077 (Lisp_Object cp)
3079 CHARSETINFO info;
3080 DWORD dwcp;
3082 CHECK_NUMBER (cp);
3084 if (!IsValidCodePage (XINT (cp)))
3085 return Qnil;
3087 /* Going through a temporary DWORD variable avoids compiler warning
3088 about cast to pointer from integer of different size, when
3089 building --with-wide-int. */
3090 dwcp = XINT (cp);
3091 if (TranslateCharsetInfo ((DWORD *) dwcp, &info, TCI_SRCCODEPAGE))
3092 return make_number (info.ciCharset);
3094 return Qnil;
3098 DEFUN ("w32-get-valid-keyboard-layouts", Fw32_get_valid_keyboard_layouts,
3099 Sw32_get_valid_keyboard_layouts, 0, 0, 0,
3100 doc: /* Return list of Windows keyboard languages and layouts.
3101 The return value is a list of pairs of language id and layout id. */)
3102 (void)
3104 int num_layouts = GetKeyboardLayoutList (0, NULL);
3105 HKL * layouts = (HKL *) alloca (num_layouts * sizeof (HKL));
3106 Lisp_Object obj = Qnil;
3108 if (GetKeyboardLayoutList (num_layouts, layouts) == num_layouts)
3110 while (--num_layouts >= 0)
3112 HKL kl = layouts[num_layouts];
3114 obj = Fcons (Fcons (make_number (LOWORD (kl)),
3115 make_number (HIWORD (kl))),
3116 obj);
3120 return obj;
3124 DEFUN ("w32-get-keyboard-layout", Fw32_get_keyboard_layout,
3125 Sw32_get_keyboard_layout, 0, 0, 0,
3126 doc: /* Return current Windows keyboard language and layout.
3127 The return value is the cons of the language id and the layout id. */)
3128 (void)
3130 HKL kl = GetKeyboardLayout (dwWindowsThreadId);
3132 return Fcons (make_number (LOWORD (kl)),
3133 make_number (HIWORD (kl)));
3137 DEFUN ("w32-set-keyboard-layout", Fw32_set_keyboard_layout,
3138 Sw32_set_keyboard_layout, 1, 1, 0,
3139 doc: /* Make LAYOUT be the current keyboard layout for Emacs.
3140 The keyboard layout setting affects interpretation of keyboard input.
3141 If successful, the new layout id is returned, otherwise nil. */)
3142 (Lisp_Object layout)
3144 HKL kl;
3146 CHECK_CONS (layout);
3147 CHECK_NUMBER_CAR (layout);
3148 CHECK_NUMBER_CDR (layout);
3150 kl = (HKL) (UINT_PTR) ((XINT (XCAR (layout)) & 0xffff)
3151 | (XINT (XCDR (layout)) << 16));
3153 /* Synchronize layout with input thread. */
3154 if (dwWindowsThreadId)
3156 if (PostThreadMessage (dwWindowsThreadId, WM_EMACS_SETKEYBOARDLAYOUT,
3157 (WPARAM) kl, 0))
3159 MSG msg;
3160 GetMessage (&msg, NULL, WM_EMACS_DONE, WM_EMACS_DONE);
3162 if (msg.wParam == 0)
3163 return Qnil;
3166 else if (!ActivateKeyboardLayout (kl, 0))
3167 return Qnil;
3169 return Fw32_get_keyboard_layout ();
3172 /* Two variables to interface between get_lcid and the EnumLocales
3173 callback function below. */
3174 #ifndef LOCALE_NAME_MAX_LENGTH
3175 # define LOCALE_NAME_MAX_LENGTH 85
3176 #endif
3177 static LCID found_lcid;
3178 static char lname[3 * LOCALE_NAME_MAX_LENGTH + 1 + 1];
3180 /* Callback function for EnumLocales. */
3181 static BOOL CALLBACK
3182 get_lcid_callback (LPTSTR locale_num_str)
3184 char *endp;
3185 char locval[2 * LOCALE_NAME_MAX_LENGTH + 1 + 1];
3186 LCID try_lcid = strtoul (locale_num_str, &endp, 16);
3188 if (GetLocaleInfo (try_lcid, LOCALE_SABBREVLANGNAME,
3189 locval, LOCALE_NAME_MAX_LENGTH))
3191 size_t locval_len;
3193 /* This is for when they only specify the language, as in "ENU". */
3194 if (stricmp (locval, lname) == 0)
3196 found_lcid = try_lcid;
3197 return FALSE;
3199 locval_len = strlen (locval);
3200 strcpy (locval + locval_len, "_");
3201 if (GetLocaleInfo (try_lcid, LOCALE_SABBREVCTRYNAME,
3202 locval + locval_len + 1, LOCALE_NAME_MAX_LENGTH))
3204 locval_len = strlen (locval);
3205 if (strnicmp (locval, lname, locval_len) == 0
3206 && (lname[locval_len] == '.'
3207 || lname[locval_len] == '\0'))
3209 found_lcid = try_lcid;
3210 return FALSE;
3214 return TRUE;
3217 /* Return the Locale ID (LCID) number given the locale's name, a
3218 string, in LOCALE_NAME. This works by enumerating all the locales
3219 supported by the system, until we find one whose name matches
3220 LOCALE_NAME. */
3221 static LCID
3222 get_lcid (const char *locale_name)
3224 /* A simple cache. */
3225 static LCID last_lcid;
3226 static char last_locale[1000];
3228 /* The code below is not thread-safe, as it uses static variables.
3229 But this function is called only from the Lisp thread. */
3230 if (last_lcid > 0 && strcmp (locale_name, last_locale) == 0)
3231 return last_lcid;
3233 strncpy (lname, locale_name, sizeof (lname) - 1);
3234 lname[sizeof (lname) - 1] = '\0';
3235 found_lcid = 0;
3236 EnumSystemLocales (get_lcid_callback, LCID_SUPPORTED);
3237 if (found_lcid > 0)
3239 last_lcid = found_lcid;
3240 strcpy (last_locale, locale_name);
3242 return found_lcid;
3245 #ifndef _NSLCMPERROR
3246 # define _NSLCMPERROR INT_MAX
3247 #endif
3248 #ifndef LINGUISTIC_IGNORECASE
3249 # define LINGUISTIC_IGNORECASE 0x00000010
3250 #endif
3253 w32_compare_strings (const char *s1, const char *s2, char *locname,
3254 int ignore_case)
3256 LCID lcid = GetThreadLocale ();
3257 wchar_t *string1_w, *string2_w;
3258 int val, needed;
3259 extern BOOL g_b_init_compare_string_w;
3260 static int (WINAPI *pCompareStringW)(LCID, DWORD, LPCWSTR, int, LPCWSTR, int);
3261 DWORD flags = 0;
3263 USE_SAFE_ALLOCA;
3265 /* The LCID machinery doesn't seem to support the "C" locale, so we
3266 need to do that by hand. */
3267 if (locname
3268 && ((locname[0] == 'C' && (locname[1] == '\0' || locname[1] == '.'))
3269 || strcmp (locname, "POSIX") == 0))
3270 return (ignore_case ? stricmp (s1, s2) : strcmp (s1, s2));
3272 if (!g_b_init_compare_string_w)
3274 if (os_subtype == OS_9X)
3276 pCompareStringW = GetProcAddress (LoadLibrary ("Unicows.dll"),
3277 "CompareStringW");
3278 if (!pCompareStringW)
3280 errno = EINVAL;
3281 /* This return value is compatible with wcscoll and
3282 other MS CRT functions. */
3283 return _NSLCMPERROR;
3286 else
3287 pCompareStringW = CompareStringW;
3289 g_b_init_compare_string_w = 1;
3292 needed = pMultiByteToWideChar (CP_UTF8, MB_ERR_INVALID_CHARS, s1, -1, NULL, 0);
3293 if (needed > 0)
3295 SAFE_NALLOCA (string1_w, 1, needed + 1);
3296 pMultiByteToWideChar (CP_UTF8, MB_ERR_INVALID_CHARS, s1, -1,
3297 string1_w, needed);
3299 else
3301 errno = EINVAL;
3302 return _NSLCMPERROR;
3305 needed = pMultiByteToWideChar (CP_UTF8, MB_ERR_INVALID_CHARS, s2, -1, NULL, 0);
3306 if (needed > 0)
3308 SAFE_NALLOCA (string2_w, 1, needed + 1);
3309 pMultiByteToWideChar (CP_UTF8, MB_ERR_INVALID_CHARS, s2, -1,
3310 string2_w, needed);
3312 else
3314 SAFE_FREE ();
3315 errno = EINVAL;
3316 return _NSLCMPERROR;
3319 if (locname)
3321 /* Convert locale name string to LCID. We don't want to use
3322 LocaleNameToLCID because (a) it is only available since
3323 Vista, and (b) it doesn't accept locale names returned by
3324 'setlocale' and 'GetLocaleInfo'. */
3325 LCID new_lcid = get_lcid (locname);
3327 if (new_lcid > 0)
3328 lcid = new_lcid;
3329 else
3330 error ("Invalid locale %s: Invalid argument", locname);
3333 if (ignore_case)
3335 /* NORM_IGNORECASE ignores any tertiary distinction, not just
3336 case variants. LINGUISTIC_IGNORECASE is more selective, and
3337 is sensitive to the locale's language, but it is not
3338 available before Vista. */
3339 if (w32_major_version >= 6)
3340 flags |= LINGUISTIC_IGNORECASE;
3341 else
3342 flags |= NORM_IGNORECASE;
3344 /* This approximates what glibc collation functions do when the
3345 locale's codeset is UTF-8. */
3346 if (!NILP (Vw32_collate_ignore_punctuation))
3347 flags |= NORM_IGNORESYMBOLS;
3348 val = pCompareStringW (lcid, flags, string1_w, -1, string2_w, -1);
3349 SAFE_FREE ();
3350 if (!val)
3352 errno = EINVAL;
3353 return _NSLCMPERROR;
3355 return val - 2;
3359 void
3360 syms_of_ntproc (void)
3362 DEFSYM (Qhigh, "high");
3363 DEFSYM (Qlow, "low");
3365 defsubr (&Sw32_has_winsock);
3366 defsubr (&Sw32_unload_winsock);
3368 defsubr (&Sw32_short_file_name);
3369 defsubr (&Sw32_long_file_name);
3370 defsubr (&Sw32_set_process_priority);
3371 defsubr (&Sw32_get_locale_info);
3372 defsubr (&Sw32_get_current_locale_id);
3373 defsubr (&Sw32_get_default_locale_id);
3374 defsubr (&Sw32_get_valid_locale_ids);
3375 defsubr (&Sw32_set_current_locale);
3377 defsubr (&Sw32_get_console_codepage);
3378 defsubr (&Sw32_set_console_codepage);
3379 defsubr (&Sw32_get_console_output_codepage);
3380 defsubr (&Sw32_set_console_output_codepage);
3381 defsubr (&Sw32_get_valid_codepages);
3382 defsubr (&Sw32_get_codepage_charset);
3384 defsubr (&Sw32_get_valid_keyboard_layouts);
3385 defsubr (&Sw32_get_keyboard_layout);
3386 defsubr (&Sw32_set_keyboard_layout);
3388 DEFVAR_LISP ("w32-quote-process-args", Vw32_quote_process_args,
3389 doc: /* Non-nil enables quoting of process arguments to ensure correct parsing.
3390 Because Windows does not directly pass argv arrays to child processes,
3391 programs have to reconstruct the argv array by parsing the command
3392 line string. For an argument to contain a space, it must be enclosed
3393 in double quotes or it will be parsed as multiple arguments.
3395 If the value is a character, that character will be used to escape any
3396 quote characters that appear, otherwise a suitable escape character
3397 will be chosen based on the type of the program. */);
3398 Vw32_quote_process_args = Qt;
3400 DEFVAR_LISP ("w32-start-process-show-window",
3401 Vw32_start_process_show_window,
3402 doc: /* When nil, new child processes hide their windows.
3403 When non-nil, they show their window in the method of their choice.
3404 This variable doesn't affect GUI applications, which will never be hidden. */);
3405 Vw32_start_process_show_window = Qnil;
3407 DEFVAR_LISP ("w32-start-process-share-console",
3408 Vw32_start_process_share_console,
3409 doc: /* When nil, new child processes are given a new console.
3410 When non-nil, they share the Emacs console; this has the limitation of
3411 allowing only one DOS subprocess to run at a time (whether started directly
3412 or indirectly by Emacs), and preventing Emacs from cleanly terminating the
3413 subprocess group, but may allow Emacs to interrupt a subprocess that doesn't
3414 otherwise respond to interrupts from Emacs. */);
3415 Vw32_start_process_share_console = Qnil;
3417 DEFVAR_LISP ("w32-start-process-inherit-error-mode",
3418 Vw32_start_process_inherit_error_mode,
3419 doc: /* When nil, new child processes revert to the default error mode.
3420 When non-nil, they inherit their error mode setting from Emacs, which stops
3421 them blocking when trying to access unmounted drives etc. */);
3422 Vw32_start_process_inherit_error_mode = Qt;
3424 DEFVAR_INT ("w32-pipe-read-delay", w32_pipe_read_delay,
3425 doc: /* Forced delay before reading subprocess output.
3426 This is done to improve the buffering of subprocess output, by
3427 avoiding the inefficiency of frequently reading small amounts of data.
3429 If positive, the value is the number of milliseconds to sleep before
3430 reading the subprocess output. If negative, the magnitude is the number
3431 of time slices to wait (effectively boosting the priority of the child
3432 process temporarily). A value of zero disables waiting entirely. */);
3433 w32_pipe_read_delay = 50;
3435 DEFVAR_LISP ("w32-downcase-file-names", Vw32_downcase_file_names,
3436 doc: /* Non-nil means convert all-upper case file names to lower case.
3437 This applies when performing completions and file name expansion.
3438 Note that the value of this setting also affects remote file names,
3439 so you probably don't want to set to non-nil if you use case-sensitive
3440 filesystems via ange-ftp. */);
3441 Vw32_downcase_file_names = Qnil;
3443 #if 0
3444 DEFVAR_LISP ("w32-generate-fake-inodes", Vw32_generate_fake_inodes,
3445 doc: /* Non-nil means attempt to fake realistic inode values.
3446 This works by hashing the truename of files, and should detect
3447 aliasing between long and short (8.3 DOS) names, but can have
3448 false positives because of hash collisions. Note that determining
3449 the truename of a file can be slow. */);
3450 Vw32_generate_fake_inodes = Qnil;
3451 #endif
3453 DEFVAR_LISP ("w32-get-true-file-attributes", Vw32_get_true_file_attributes,
3454 doc: /* Non-nil means determine accurate file attributes in `file-attributes'.
3455 This option controls whether to issue additional system calls to determine
3456 accurate link counts, file type, and ownership information. It is more
3457 useful for files on NTFS volumes, where hard links and file security are
3458 supported, than on volumes of the FAT family.
3460 Without these system calls, link count will always be reported as 1 and file
3461 ownership will be attributed to the current user.
3462 The default value `local' means only issue these system calls for files
3463 on local fixed drives. A value of nil means never issue them.
3464 Any other non-nil value means do this even on remote and removable drives
3465 where the performance impact may be noticeable even on modern hardware. */);
3466 Vw32_get_true_file_attributes = Qlocal;
3468 DEFVAR_LISP ("w32-collate-ignore-punctuation",
3469 Vw32_collate_ignore_punctuation,
3470 doc: /* Non-nil causes string collation functions ignore punctuation on MS-Windows.
3471 On Posix platforms, `string-collate-lessp' and `string-collate-equalp'
3472 ignore punctuation characters when they compare strings, if the
3473 locale's codeset is UTF-8, as in \"en_US.UTF-8\". Binding this option
3474 to a non-nil value will achieve a similar effect on MS-Windows, where
3475 locales with UTF-8 codeset are not supported.
3477 Note that setting this to non-nil will also ignore blanks and symbols
3478 in the strings. So do NOT use this option when comparing file names
3479 for equality, only when you need to sort them. */);
3480 Vw32_collate_ignore_punctuation = Qnil;
3482 staticpro (&Vw32_valid_locale_ids);
3483 staticpro (&Vw32_valid_codepages);
3485 /* end of w32proc.c */