Port to OpenIndiana
[emacs.git] / src / w32proc.c
blob0046c9e85dc963632f252e912fed363d14c8f725
1 /* Process support for GNU Emacs on the Microsoft Windows API.
3 Copyright (C) 1992, 1995, 1999-2017 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 (at
10 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 <https://www.gnu.org/licenses/>. */
21 Drew Bliss Oct 14, 1993
22 Adapted from alarm.c by Tim Fleehart
25 #define DEFER_MS_W32_H
26 #include <config.h>
28 #include <mingw_time.h>
29 #include <stdio.h>
30 #include <stdlib.h>
31 #include <errno.h>
32 #include <ctype.h>
33 #include <io.h>
34 #include <fcntl.h>
35 #include <unistd.h>
36 #include <signal.h>
37 #include <sys/file.h>
38 #include <mbstring.h>
39 #include <locale.h>
41 /* Include CRT headers *before* ms-w32.h. */
42 #include <ms-w32.h>
44 #undef signal
45 #undef wait
46 #undef spawnve
47 #undef select
48 #undef kill
50 #include <windows.h>
52 #ifdef HAVE_LANGINFO_CODESET
53 #include <nl_types.h>
54 #include <langinfo.h>
55 #endif
57 #include "lisp.h"
58 #include "w32.h"
59 #include "w32common.h"
60 #include "w32heap.h"
61 #include "syswait.h" /* for WNOHANG */
62 #include "syssignal.h"
63 #include "w32term.h"
64 #include "coding.h"
66 #define RVA_TO_PTR(var,section,filedata) \
67 ((void *)((section)->PointerToRawData \
68 + ((DWORD_PTR)(var) - (section)->VirtualAddress) \
69 + (filedata).file_base))
71 extern BOOL g_b_init_compare_string_w;
72 extern BOOL g_b_init_debug_break_process;
74 int sys_select (int, SELECT_TYPE *, SELECT_TYPE *, SELECT_TYPE *,
75 const struct timespec *, const sigset_t *);
77 /* Signal handlers...SIG_DFL == 0 so this is initialized correctly. */
78 static signal_handler sig_handlers[NSIG];
80 static sigset_t sig_mask;
82 static CRITICAL_SECTION crit_sig;
84 /* Improve on the CRT 'signal' implementation so that we could record
85 the SIGCHLD handler and fake interval timers. */
86 signal_handler
87 sys_signal (int sig, signal_handler handler)
89 signal_handler old;
91 /* SIGCHLD is needed for supporting subprocesses, see sys_kill
92 below. SIGALRM and SIGPROF are used by setitimer. All the
93 others are the only ones supported by the MS runtime. */
94 if (!(sig == SIGINT || sig == SIGSEGV || sig == SIGILL
95 || sig == SIGFPE || sig == SIGABRT || sig == SIGTERM
96 || sig == SIGCHLD || sig == SIGALRM || sig == SIGPROF))
98 errno = EINVAL;
99 return SIG_ERR;
101 old = sig_handlers[sig];
102 /* SIGABRT is treated specially because w32.c installs term_ntproc
103 as its handler, so we don't want to override that afterwards.
104 Aborting Emacs works specially anyway: either by calling
105 emacs_abort directly or through terminate_due_to_signal, which
106 calls emacs_abort through emacs_raise. */
107 if (!(sig == SIGABRT && old == term_ntproc))
109 sig_handlers[sig] = handler;
110 if (!(sig == SIGCHLD || sig == SIGALRM || sig == SIGPROF))
111 signal (sig, handler);
113 return old;
116 /* Emulate sigaction. */
118 sigaction (int sig, const struct sigaction *act, struct sigaction *oact)
120 signal_handler old = SIG_DFL;
121 int retval = 0;
123 if (act)
124 old = sys_signal (sig, act->sa_handler);
125 else if (oact)
126 old = sig_handlers[sig];
128 if (old == SIG_ERR)
130 errno = EINVAL;
131 retval = -1;
133 if (oact)
135 oact->sa_handler = old;
136 oact->sa_flags = 0;
137 oact->sa_mask = empty_mask;
139 return retval;
142 /* Emulate signal sets and blocking of signals used by timers. */
145 sigemptyset (sigset_t *set)
147 *set = 0;
148 return 0;
152 sigaddset (sigset_t *set, int signo)
154 if (!set)
156 errno = EINVAL;
157 return -1;
159 if (signo < 0 || signo >= NSIG)
161 errno = EINVAL;
162 return -1;
165 *set |= (1U << signo);
167 return 0;
171 sigfillset (sigset_t *set)
173 if (!set)
175 errno = EINVAL;
176 return -1;
179 *set = 0xFFFFFFFF;
180 return 0;
184 sigprocmask (int how, const sigset_t *set, sigset_t *oset)
186 if (!(how == SIG_BLOCK || how == SIG_UNBLOCK || how == SIG_SETMASK))
188 errno = EINVAL;
189 return -1;
192 if (oset)
193 *oset = sig_mask;
195 if (!set)
196 return 0;
198 switch (how)
200 case SIG_BLOCK:
201 sig_mask |= *set;
202 break;
203 case SIG_SETMASK:
204 sig_mask = *set;
205 break;
206 case SIG_UNBLOCK:
207 /* FIXME: Catch signals that are blocked and reissue them when
208 they are unblocked. Important for SIGALRM and SIGPROF only. */
209 sig_mask &= ~(*set);
210 break;
213 return 0;
217 pthread_sigmask (int how, const sigset_t *set, sigset_t *oset)
219 if (sigprocmask (how, set, oset) == -1)
220 return EINVAL;
221 return 0;
225 sigismember (const sigset_t *set, int signo)
227 if (signo < 0 || signo >= NSIG)
229 errno = EINVAL;
230 return -1;
232 if (signo > sizeof (*set) * CHAR_BIT)
233 emacs_abort ();
235 return (*set & (1U << signo)) != 0;
238 pid_t
239 getpgrp (void)
241 return getpid ();
244 pid_t
245 tcgetpgrp (int fd)
247 return getpid ();
251 setpgid (pid_t pid, pid_t pgid)
253 return 0;
256 pid_t
257 setsid (void)
259 return getpid ();
262 /* Emulations of interval timers.
264 Limitations: only ITIMER_REAL and ITIMER_PROF are supported.
266 Implementation: a separate thread is started for each timer type,
267 the thread calls the appropriate signal handler when the timer
268 expires, after stopping the thread which installed the timer. */
270 struct itimer_data {
271 volatile ULONGLONG expire;
272 volatile ULONGLONG reload;
273 volatile int terminate;
274 int type;
275 HANDLE caller_thread;
276 HANDLE timer_thread;
279 static ULONGLONG ticks_now;
280 static struct itimer_data real_itimer, prof_itimer;
281 static ULONGLONG clocks_min;
282 /* If non-zero, itimers are disabled. Used during shutdown, when we
283 delete the critical sections used by the timer threads. */
284 static int disable_itimers;
286 static CRITICAL_SECTION crit_real, crit_prof;
288 /* GetThreadTimes is not available on Windows 9X and possibly also on 2K. */
289 typedef BOOL (WINAPI *GetThreadTimes_Proc) (
290 HANDLE hThread,
291 LPFILETIME lpCreationTime,
292 LPFILETIME lpExitTime,
293 LPFILETIME lpKernelTime,
294 LPFILETIME lpUserTime);
296 static GetThreadTimes_Proc s_pfn_Get_Thread_Times;
298 #define MAX_SINGLE_SLEEP 30
299 #define TIMER_TICKS_PER_SEC 1000
301 /* Return a suitable time value, in 1-ms units, for THREAD, a handle
302 to a thread. If THREAD is NULL or an invalid handle, return the
303 current wall-clock time since January 1, 1601 (UTC). Otherwise,
304 return the sum of kernel and user times used by THREAD since it was
305 created, plus its creation time. */
306 static ULONGLONG
307 w32_get_timer_time (HANDLE thread)
309 ULONGLONG retval;
310 int use_system_time = 1;
311 /* The functions below return times in 100-ns units. */
312 const int tscale = 10 * TIMER_TICKS_PER_SEC;
314 if (thread && thread != INVALID_HANDLE_VALUE
315 && s_pfn_Get_Thread_Times != NULL)
317 FILETIME creation_ftime, exit_ftime, kernel_ftime, user_ftime;
318 ULARGE_INTEGER temp_creation, temp_kernel, temp_user;
320 if (s_pfn_Get_Thread_Times (thread, &creation_ftime, &exit_ftime,
321 &kernel_ftime, &user_ftime))
323 use_system_time = 0;
324 temp_creation.LowPart = creation_ftime.dwLowDateTime;
325 temp_creation.HighPart = creation_ftime.dwHighDateTime;
326 temp_kernel.LowPart = kernel_ftime.dwLowDateTime;
327 temp_kernel.HighPart = kernel_ftime.dwHighDateTime;
328 temp_user.LowPart = user_ftime.dwLowDateTime;
329 temp_user.HighPart = user_ftime.dwHighDateTime;
330 retval =
331 temp_creation.QuadPart / tscale + temp_kernel.QuadPart / tscale
332 + temp_user.QuadPart / tscale;
334 else
335 DebPrint (("GetThreadTimes failed with error code %lu\n",
336 GetLastError ()));
339 if (use_system_time)
341 FILETIME current_ftime;
342 ULARGE_INTEGER temp;
344 GetSystemTimeAsFileTime (&current_ftime);
346 temp.LowPart = current_ftime.dwLowDateTime;
347 temp.HighPart = current_ftime.dwHighDateTime;
349 retval = temp.QuadPart / tscale;
352 return retval;
355 /* Thread function for a timer thread. */
356 static DWORD WINAPI
357 timer_loop (LPVOID arg)
359 struct itimer_data *itimer = (struct itimer_data *)arg;
360 int which = itimer->type;
361 int sig = (which == ITIMER_REAL) ? SIGALRM : SIGPROF;
362 CRITICAL_SECTION *crit = (which == ITIMER_REAL) ? &crit_real : &crit_prof;
363 const DWORD max_sleep = MAX_SINGLE_SLEEP * 1000 / TIMER_TICKS_PER_SEC;
364 HANDLE hth = (which == ITIMER_REAL) ? NULL : itimer->caller_thread;
366 while (1)
368 DWORD sleep_time;
369 signal_handler handler;
370 ULONGLONG now, expire, reload;
372 /* Load new values if requested by setitimer. */
373 EnterCriticalSection (crit);
374 expire = itimer->expire;
375 reload = itimer->reload;
376 LeaveCriticalSection (crit);
377 if (itimer->terminate)
378 return 0;
380 if (expire == 0)
382 /* We are idle. */
383 Sleep (max_sleep);
384 continue;
387 if (expire > (now = w32_get_timer_time (hth)))
388 sleep_time = expire - now;
389 else
390 sleep_time = 0;
391 /* Don't sleep too long at a time, to be able to see the
392 termination flag without too long a delay. */
393 while (sleep_time > max_sleep)
395 if (itimer->terminate)
396 return 0;
397 Sleep (max_sleep);
398 EnterCriticalSection (crit);
399 expire = itimer->expire;
400 LeaveCriticalSection (crit);
401 sleep_time =
402 (expire > (now = w32_get_timer_time (hth))) ? expire - now : 0;
404 if (itimer->terminate)
405 return 0;
406 if (sleep_time > 0)
408 Sleep (sleep_time * 1000 / TIMER_TICKS_PER_SEC);
409 /* Always sleep past the expiration time, to make sure we
410 never call the handler _before_ the expiration time,
411 always slightly after it. Sleep(5) makes sure we don't
412 hog the CPU by calling 'w32_get_timer_time' with high
413 frequency, and also let other threads work. */
414 while (w32_get_timer_time (hth) < expire)
415 Sleep (5);
418 EnterCriticalSection (crit);
419 expire = itimer->expire;
420 LeaveCriticalSection (crit);
421 if (expire == 0)
422 continue;
424 /* Time's up. */
425 handler = sig_handlers[sig];
426 if (!(handler == SIG_DFL || handler == SIG_IGN || handler == SIG_ERR)
427 /* FIXME: Don't ignore masked signals. Instead, record that
428 they happened and reissue them when the signal is
429 unblocked. */
430 && !sigismember (&sig_mask, sig)
431 /* Simulate masking of SIGALRM and SIGPROF when processing
432 fatal signals. */
433 && !fatal_error_in_progress
434 && itimer->caller_thread)
436 /* Simulate a signal delivered to the thread which installed
437 the timer, by suspending that thread while the handler
438 runs. */
439 HANDLE th = itimer->caller_thread;
440 DWORD result = SuspendThread (th);
442 if (result == (DWORD)-1)
443 return 2;
445 handler (sig);
446 ResumeThread (th);
449 /* Update expiration time and loop. */
450 EnterCriticalSection (crit);
451 expire = itimer->expire;
452 if (expire == 0)
454 LeaveCriticalSection (crit);
455 continue;
457 reload = itimer->reload;
458 if (reload > 0)
460 now = w32_get_timer_time (hth);
461 if (expire <= now)
463 ULONGLONG lag = now - expire;
465 /* If we missed some opportunities (presumably while
466 sleeping or while the signal handler ran), skip
467 them. */
468 if (lag > reload)
469 expire = now - (lag % reload);
471 expire += reload;
474 else
475 expire = 0; /* become idle */
476 itimer->expire = expire;
477 LeaveCriticalSection (crit);
479 return 0;
482 static void
483 stop_timer_thread (int which)
485 struct itimer_data *itimer =
486 (which == ITIMER_REAL) ? &real_itimer : &prof_itimer;
487 int i;
488 DWORD err = 0, exit_code = 255;
489 BOOL status;
491 /* Signal the thread that it should terminate. */
492 itimer->terminate = 1;
494 if (itimer->timer_thread == NULL)
495 return;
497 /* Wait for the timer thread to terminate voluntarily, then kill it
498 if it doesn't. This loop waits twice more than the maximum
499 amount of time a timer thread sleeps, see above. */
500 for (i = 0; i < MAX_SINGLE_SLEEP / 5; i++)
502 if (!((status = GetExitCodeThread (itimer->timer_thread, &exit_code))
503 && exit_code == STILL_ACTIVE))
504 break;
505 Sleep (10);
507 if ((status == FALSE && (err = GetLastError ()) == ERROR_INVALID_HANDLE)
508 || exit_code == STILL_ACTIVE)
510 if (!(status == FALSE && err == ERROR_INVALID_HANDLE))
511 TerminateThread (itimer->timer_thread, 0);
514 /* Clean up. */
515 CloseHandle (itimer->timer_thread);
516 itimer->timer_thread = NULL;
517 if (itimer->caller_thread)
519 CloseHandle (itimer->caller_thread);
520 itimer->caller_thread = NULL;
524 /* This is called at shutdown time from term_ntproc. */
525 void
526 term_timers (void)
528 if (real_itimer.timer_thread)
529 stop_timer_thread (ITIMER_REAL);
530 if (prof_itimer.timer_thread)
531 stop_timer_thread (ITIMER_PROF);
533 /* We are going to delete the critical sections, so timers cannot
534 work after this. */
535 disable_itimers = 1;
537 DeleteCriticalSection (&crit_real);
538 DeleteCriticalSection (&crit_prof);
539 DeleteCriticalSection (&crit_sig);
542 /* This is called at initialization time from init_ntproc. */
543 void
544 init_timers (void)
546 /* GetThreadTimes is not available on all versions of Windows, so
547 need to probe for its availability dynamically, and call it
548 through a pointer. */
549 s_pfn_Get_Thread_Times = NULL; /* in case dumped Emacs comes with a value */
550 if (os_subtype != OS_9X)
551 s_pfn_Get_Thread_Times =
552 (GetThreadTimes_Proc)GetProcAddress (GetModuleHandle ("kernel32.dll"),
553 "GetThreadTimes");
555 /* Make sure we start with zeroed out itimer structures, since
556 dumping may have left there traces of threads long dead. */
557 memset (&real_itimer, 0, sizeof real_itimer);
558 memset (&prof_itimer, 0, sizeof prof_itimer);
560 InitializeCriticalSection (&crit_real);
561 InitializeCriticalSection (&crit_prof);
562 InitializeCriticalSection (&crit_sig);
564 disable_itimers = 0;
567 static int
568 start_timer_thread (int which)
570 DWORD exit_code, tid;
571 HANDLE th;
572 struct itimer_data *itimer =
573 (which == ITIMER_REAL) ? &real_itimer : &prof_itimer;
575 if (itimer->timer_thread
576 && GetExitCodeThread (itimer->timer_thread, &exit_code)
577 && exit_code == STILL_ACTIVE)
578 return 0;
580 /* Clean up after possibly exited thread. */
581 if (itimer->timer_thread)
583 CloseHandle (itimer->timer_thread);
584 itimer->timer_thread = NULL;
586 if (itimer->caller_thread)
588 CloseHandle (itimer->caller_thread);
589 itimer->caller_thread = NULL;
592 /* Start a new thread. */
593 if (!DuplicateHandle (GetCurrentProcess (), GetCurrentThread (),
594 GetCurrentProcess (), &th, 0, FALSE,
595 DUPLICATE_SAME_ACCESS))
597 errno = ESRCH;
598 return -1;
600 itimer->terminate = 0;
601 itimer->type = which;
602 itimer->caller_thread = th;
603 /* Request that no more than 64KB of stack be reserved for this
604 thread, to avoid reserving too much memory, which would get in
605 the way of threads we start to wait for subprocesses. See also
606 new_child below. */
607 itimer->timer_thread = CreateThread (NULL, 64 * 1024, timer_loop,
608 (void *)itimer, 0x00010000, &tid);
610 if (!itimer->timer_thread)
612 CloseHandle (itimer->caller_thread);
613 itimer->caller_thread = NULL;
614 errno = EAGAIN;
615 return -1;
618 /* This is needed to make sure that the timer thread running for
619 profiling gets CPU as soon as the Sleep call terminates. */
620 if (which == ITIMER_PROF)
621 SetThreadPriority (itimer->timer_thread, THREAD_PRIORITY_TIME_CRITICAL);
623 return 0;
626 /* Most of the code of getitimer and setitimer (but not of their
627 subroutines) was shamelessly stolen from itimer.c in the DJGPP
628 library, see www.delorie.com/djgpp. */
630 getitimer (int which, struct itimerval *value)
632 volatile ULONGLONG *t_expire;
633 volatile ULONGLONG *t_reload;
634 ULONGLONG expire, reload;
635 __int64 usecs;
636 CRITICAL_SECTION *crit;
637 struct itimer_data *itimer;
639 if (disable_itimers)
640 return -1;
642 if (!value)
644 errno = EFAULT;
645 return -1;
648 if (which != ITIMER_REAL && which != ITIMER_PROF)
650 errno = EINVAL;
651 return -1;
654 itimer = (which == ITIMER_REAL) ? &real_itimer : &prof_itimer;
656 ticks_now = w32_get_timer_time ((which == ITIMER_REAL)
657 ? NULL
658 : GetCurrentThread ());
660 t_expire = &itimer->expire;
661 t_reload = &itimer->reload;
662 crit = (which == ITIMER_REAL) ? &crit_real : &crit_prof;
664 EnterCriticalSection (crit);
665 reload = *t_reload;
666 expire = *t_expire;
667 LeaveCriticalSection (crit);
669 if (expire)
670 expire -= ticks_now;
672 value->it_value.tv_sec = expire / TIMER_TICKS_PER_SEC;
673 usecs =
674 (expire % TIMER_TICKS_PER_SEC) * (__int64)1000000 / TIMER_TICKS_PER_SEC;
675 value->it_value.tv_usec = usecs;
676 value->it_interval.tv_sec = reload / TIMER_TICKS_PER_SEC;
677 usecs =
678 (reload % TIMER_TICKS_PER_SEC) * (__int64)1000000 / TIMER_TICKS_PER_SEC;
679 value->it_interval.tv_usec= usecs;
681 return 0;
685 setitimer(int which, struct itimerval *value, struct itimerval *ovalue)
687 volatile ULONGLONG *t_expire, *t_reload;
688 ULONGLONG expire, reload, expire_old, reload_old;
689 __int64 usecs;
690 CRITICAL_SECTION *crit;
691 struct itimerval tem, *ptem;
693 if (disable_itimers)
694 return -1;
696 /* Posix systems expect timer values smaller than the resolution of
697 the system clock be rounded up to the clock resolution. First
698 time we are called, measure the clock tick resolution. */
699 if (!clocks_min)
701 ULONGLONG t1, t2;
703 for (t1 = w32_get_timer_time (NULL);
704 (t2 = w32_get_timer_time (NULL)) == t1; )
706 clocks_min = t2 - t1;
709 if (ovalue)
710 ptem = ovalue;
711 else
712 ptem = &tem;
714 if (getitimer (which, ptem)) /* also sets ticks_now */
715 return -1; /* errno already set */
717 t_expire =
718 (which == ITIMER_REAL) ? &real_itimer.expire : &prof_itimer.expire;
719 t_reload =
720 (which == ITIMER_REAL) ? &real_itimer.reload : &prof_itimer.reload;
722 crit = (which == ITIMER_REAL) ? &crit_real : &crit_prof;
724 if (!value
725 || (value->it_value.tv_sec == 0 && value->it_value.tv_usec == 0))
727 EnterCriticalSection (crit);
728 /* Disable the timer. */
729 *t_expire = 0;
730 *t_reload = 0;
731 LeaveCriticalSection (crit);
732 return 0;
735 reload = value->it_interval.tv_sec * TIMER_TICKS_PER_SEC;
737 usecs = value->it_interval.tv_usec;
738 if (value->it_interval.tv_sec == 0
739 && usecs && usecs * TIMER_TICKS_PER_SEC < clocks_min * 1000000)
740 reload = clocks_min;
741 else
743 usecs *= TIMER_TICKS_PER_SEC;
744 reload += usecs / 1000000;
747 expire = value->it_value.tv_sec * TIMER_TICKS_PER_SEC;
748 usecs = value->it_value.tv_usec;
749 if (value->it_value.tv_sec == 0
750 && usecs * TIMER_TICKS_PER_SEC < clocks_min * 1000000)
751 expire = clocks_min;
752 else
754 usecs *= TIMER_TICKS_PER_SEC;
755 expire += usecs / 1000000;
758 expire += ticks_now;
760 EnterCriticalSection (crit);
761 expire_old = *t_expire;
762 reload_old = *t_reload;
763 if (!(expire == expire_old && reload == reload_old))
765 *t_reload = reload;
766 *t_expire = expire;
768 LeaveCriticalSection (crit);
770 return start_timer_thread (which);
774 alarm (int seconds)
776 #ifdef HAVE_SETITIMER
777 struct itimerval new_values, old_values;
779 new_values.it_value.tv_sec = seconds;
780 new_values.it_value.tv_usec = 0;
781 new_values.it_interval.tv_sec = new_values.it_interval.tv_usec = 0;
783 if (setitimer (ITIMER_REAL, &new_values, &old_values) < 0)
784 return 0;
785 return old_values.it_value.tv_sec;
786 #else
787 return seconds;
788 #endif
793 /* Here's an overview of how support for subprocesses and
794 network/serial streams is implemented on MS-Windows.
796 The management of both subprocesses and network/serial streams
797 circles around the child_procs[] array, which can record up to the
798 grand total of MAX_CHILDREN (= 32) of these. (The reasons for the
799 32 limitation will become clear below.) Each member of
800 child_procs[] is a child_process structure, defined on w32.h.
802 A related data structure is the fd_info[] array, which holds twice
803 as many members, 64, and records the information about file
804 descriptors used for communicating with subprocesses and
805 network/serial devices. Each member of the array is the filedesc
806 structure, which records the Windows handle for communications,
807 such as the read end of the pipe to a subprocess, a socket handle,
808 etc.
810 Both these arrays reference each other: there's a member of
811 child_process structure that records the corresponding file
812 descriptor, and there's a member of filedesc structure that holds a
813 pointer to the corresponding child_process.
815 Whenever Emacs starts a subprocess or opens a network/serial
816 stream, the function new_child is called to prepare a new
817 child_process structure. new_child looks for the first vacant slot
818 in the child_procs[] array, initializes it, and starts a "reader
819 thread" that will watch the output of the subprocess/stream and its
820 status. (If no vacant slot can be found, new_child returns a
821 failure indication to its caller, and the higher-level Emacs
822 primitive that called it will then fail with EMFILE or EAGAIN.)
824 The reader thread started by new_child communicates with the main
825 (a.k.a. "Lisp") thread via two event objects and a status, all of
826 them recorded by the members of the child_process structure in
827 child_procs[]. The event objects serve as semaphores between the
828 reader thread and the 'pselect' emulation in sys_select, as follows:
830 . Initially, the reader thread is waiting for the char_consumed
831 event to become signaled by sys_select, which is an indication
832 for the reader thread to go ahead and try reading more stuff
833 from the subprocess/stream.
835 . The reader thread then attempts to read by calling a
836 blocking-read function. When the read call returns, either
837 successfully or with some failure indication, the reader thread
838 updates the status of the read accordingly, and signals the 2nd
839 event object, char_avail, on whose handle sys_select is
840 waiting. This tells sys_select that the file descriptor
841 allocated for the subprocess or the stream is ready to be
842 read from.
844 When the subprocess exits or the network/serial stream is closed,
845 the reader thread sets the status accordingly and exits. It also
846 exits when the main thread sets the status to STATUS_READ_ERROR
847 and/or the char_avail and char_consumed event handles become NULL;
848 this is how delete_child, called by Emacs when a subprocess or a
849 stream is terminated, terminates the reader thread as part of
850 deleting the child_process object.
852 The sys_select function emulates the Posix 'pselect' functionality;
853 it is needed because the Windows 'select' function supports only
854 network sockets, while Emacs expects 'pselect' to work for any file
855 descriptor, including pipes and serial streams.
857 When sys_select is called, it uses the information in fd_info[]
858 array to convert the file descriptors which it was asked to watch
859 into Windows handles. In general, the handle to watch is the
860 handle of the char_avail event of the child_process structure that
861 corresponds to the file descriptor. In addition, for subprocesses,
862 sys_select watches one more handle: the handle for the subprocess,
863 so that it could emulate the SIGCHLD signal when the subprocess
864 exits.
866 If file descriptor zero (stdin) doesn't have its bit set in the
867 'rfds' argument to sys_select, the function always watches for
868 keyboard interrupts, to be able to interrupt the wait and return
869 when the user presses C-g.
871 Having collected the handles to watch, sys_select calls
872 WaitForMultipleObjects to wait for any one of them to become
873 signaled. Since WaitForMultipleObjects can only watch up to 64
874 handles, Emacs on Windows is limited to maximum 32 child_process
875 objects (since a subprocess consumes 2 handles to be watched, see
876 above).
878 When any of the handles become signaled, sys_select does whatever
879 is appropriate for the corresponding child_process object:
881 . If it's a handle to the char_avail event, sys_select marks the
882 corresponding bit in 'rfds', and Emacs will then read from that
883 file descriptor.
885 . If it's a handle to the process, sys_select calls the SIGCHLD
886 handler, to inform Emacs of the fact that the subprocess
887 exited.
889 The waitpid emulation works very similar to sys_select, except that
890 it only watches handles of subprocesses, and doesn't synchronize
891 with the reader thread.
893 Because socket descriptors on Windows are handles, while Emacs
894 expects them to be file descriptors, all low-level I/O functions,
895 such as 'read' and 'write', and all socket operations, like
896 'connect', 'recvfrom', 'accept', etc., are redirected to the
897 corresponding 'sys_*' functions, which must convert a file
898 descriptor to a handle using the fd_info[] array, and then invoke
899 the corresponding Windows API on the handle. Most of these
900 redirected 'sys_*' functions are implemented on w32.c.
902 When the file descriptor was produced by functions such as 'open',
903 the corresponding handle is obtained by calling _get_osfhandle. To
904 produce a file descriptor for a socket handle, which has no file
905 descriptor as far as Windows is concerned, the function
906 socket_to_fd opens the null device; the resulting file descriptor
907 will never be used directly in any I/O API, but serves as an index
908 into the fd_info[] array, where the socket handle is stored. The
909 SOCK_HANDLE macro retrieves the handle when given the file
910 descriptor.
912 The function sys_kill emulates the Posix 'kill' functionality to
913 terminate other processes. It does that by attaching to the
914 foreground window of the process and sending a Ctrl-C or Ctrl-BREAK
915 signal to the process; if that doesn't work, then it calls
916 TerminateProcess to forcibly terminate the process. Note that this
917 only terminates the immediate process whose PID was passed to
918 sys_kill; it doesn't terminate the child processes of that process.
919 This means, for example, that an Emacs subprocess run through a
920 shell might not be killed, because sys_kill will only terminate the
921 shell. (In practice, however, such problems are very rare.) */
923 /* Defined in <process.h> which conflicts with the local copy */
924 #define _P_NOWAIT 1
926 /* Child process management list. */
927 int child_proc_count = 0;
928 child_process child_procs[ MAX_CHILDREN ];
930 static DWORD WINAPI reader_thread (void *arg);
932 /* Find an unused process slot. */
933 child_process *
934 new_child (void)
936 child_process *cp;
937 DWORD id;
939 for (cp = child_procs + (child_proc_count-1); cp >= child_procs; cp--)
940 if (!CHILD_ACTIVE (cp) && cp->procinfo.hProcess == NULL)
941 goto Initialize;
942 if (child_proc_count == MAX_CHILDREN)
944 int i = 0;
945 child_process *dead_cp = NULL;
947 DebPrint (("new_child: No vacant slots, looking for dead processes\n"));
948 for (cp = child_procs + (child_proc_count-1); cp >= child_procs; cp--)
949 if (!CHILD_ACTIVE (cp) && cp->procinfo.hProcess)
951 DWORD status = 0;
953 if (!GetExitCodeProcess (cp->procinfo.hProcess, &status))
955 DebPrint (("new_child.GetExitCodeProcess: error %lu for PID %lu\n",
956 GetLastError (), cp->procinfo.dwProcessId));
957 status = STILL_ACTIVE;
959 if (status != STILL_ACTIVE
960 || WaitForSingleObject (cp->procinfo.hProcess, 0) == WAIT_OBJECT_0)
962 DebPrint (("new_child: Freeing slot of dead process %d, fd %d\n",
963 cp->procinfo.dwProcessId, cp->fd));
964 CloseHandle (cp->procinfo.hProcess);
965 cp->procinfo.hProcess = NULL;
966 CloseHandle (cp->procinfo.hThread);
967 cp->procinfo.hThread = NULL;
968 /* Free up to 2 dead slots at a time, so that if we
969 have a lot of them, they will eventually all be
970 freed when the tornado ends. */
971 if (i == 0)
972 dead_cp = cp;
973 else
974 break;
975 i++;
978 if (dead_cp)
980 cp = dead_cp;
981 goto Initialize;
984 if (child_proc_count == MAX_CHILDREN)
985 return NULL;
986 cp = &child_procs[child_proc_count++];
988 Initialize:
989 /* Last opportunity to avoid leaking handles before we forget them
990 for good. */
991 if (cp->procinfo.hProcess)
992 CloseHandle (cp->procinfo.hProcess);
993 if (cp->procinfo.hThread)
994 CloseHandle (cp->procinfo.hThread);
995 memset (cp, 0, sizeof (*cp));
996 cp->fd = -1;
997 cp->pid = -1;
998 cp->procinfo.hProcess = NULL;
999 cp->status = STATUS_READ_ERROR;
1001 /* use manual reset event so that select() will function properly */
1002 cp->char_avail = CreateEvent (NULL, TRUE, FALSE, NULL);
1003 if (cp->char_avail)
1005 cp->char_consumed = CreateEvent (NULL, FALSE, FALSE, NULL);
1006 if (cp->char_consumed)
1008 /* The 0x00010000 flag is STACK_SIZE_PARAM_IS_A_RESERVATION.
1009 It means that the 64K stack we are requesting in the 2nd
1010 argument is how much memory should be reserved for the
1011 stack. If we don't use this flag, the memory requested
1012 by the 2nd argument is the amount actually _committed_,
1013 but Windows reserves 8MB of memory for each thread's
1014 stack. (The 8MB figure comes from the -stack
1015 command-line argument we pass to the linker when building
1016 Emacs, but that's because we need a large stack for
1017 Emacs's main thread.) Since we request 2GB of reserved
1018 memory at startup (see w32heap.c), which is close to the
1019 maximum memory available for a 32-bit process on Windows,
1020 the 8MB reservation for each thread causes failures in
1021 starting subprocesses, because we create a thread running
1022 reader_thread for each subprocess. As 8MB of stack is
1023 way too much for reader_thread, forcing Windows to
1024 reserve less wins the day. */
1025 cp->thrd = CreateThread (NULL, 64 * 1024, reader_thread, cp,
1026 0x00010000, &id);
1027 if (cp->thrd)
1028 return cp;
1031 delete_child (cp);
1032 return NULL;
1035 void
1036 delete_child (child_process *cp)
1038 int i;
1040 /* Should not be deleting a child that is still needed. */
1041 for (i = 0; i < MAXDESC; i++)
1042 if (fd_info[i].cp == cp)
1043 emacs_abort ();
1045 if (!CHILD_ACTIVE (cp) && cp->procinfo.hProcess == NULL)
1046 return;
1048 /* reap thread if necessary */
1049 if (cp->thrd)
1051 DWORD rc;
1053 if (GetExitCodeThread (cp->thrd, &rc) && rc == STILL_ACTIVE)
1055 /* let the thread exit cleanly if possible */
1056 cp->status = STATUS_READ_ERROR;
1057 SetEvent (cp->char_consumed);
1058 #if 0
1059 /* We used to forcibly terminate the thread here, but it
1060 is normally unnecessary, and in abnormal cases, the worst that
1061 will happen is we have an extra idle thread hanging around
1062 waiting for the zombie process. */
1063 if (WaitForSingleObject (cp->thrd, 1000) != WAIT_OBJECT_0)
1065 DebPrint (("delete_child.WaitForSingleObject (thread) failed "
1066 "with %lu for fd %ld\n", GetLastError (), cp->fd));
1067 TerminateThread (cp->thrd, 0);
1069 #endif
1071 CloseHandle (cp->thrd);
1072 cp->thrd = NULL;
1074 if (cp->char_avail)
1076 CloseHandle (cp->char_avail);
1077 cp->char_avail = NULL;
1079 if (cp->char_consumed)
1081 CloseHandle (cp->char_consumed);
1082 cp->char_consumed = NULL;
1085 /* update child_proc_count (highest numbered slot in use plus one) */
1086 if (cp == child_procs + child_proc_count - 1)
1088 for (i = child_proc_count-1; i >= 0; i--)
1089 if (CHILD_ACTIVE (&child_procs[i])
1090 || child_procs[i].procinfo.hProcess != NULL)
1092 child_proc_count = i + 1;
1093 break;
1096 if (i < 0)
1097 child_proc_count = 0;
1100 /* Find a child by pid. */
1101 static child_process *
1102 find_child_pid (DWORD pid)
1104 child_process *cp;
1106 for (cp = child_procs + (child_proc_count-1); cp >= child_procs; cp--)
1107 if ((CHILD_ACTIVE (cp) || cp->procinfo.hProcess != NULL)
1108 && pid == cp->pid)
1109 return cp;
1110 return NULL;
1113 void
1114 release_listen_threads (void)
1116 int i;
1118 for (i = child_proc_count - 1; i >= 0; i--)
1120 if (CHILD_ACTIVE (&child_procs[i])
1121 && (fd_info[child_procs[i].fd].flags & FILE_LISTEN))
1122 child_procs[i].status = STATUS_READ_ERROR;
1126 /* Thread proc for child process and socket reader threads. Each thread
1127 is normally blocked until woken by select() to check for input by
1128 reading one char. When the read completes, char_avail is signaled
1129 to wake up the select emulator and the thread blocks itself again. */
1130 static DWORD WINAPI
1131 reader_thread (void *arg)
1133 child_process *cp;
1135 /* Our identity */
1136 cp = (child_process *)arg;
1138 /* We have to wait for the go-ahead before we can start */
1139 if (cp == NULL
1140 || WaitForSingleObject (cp->char_consumed, INFINITE) != WAIT_OBJECT_0
1141 || cp->fd < 0)
1142 return 1;
1144 for (;;)
1146 int rc;
1148 if (cp->fd >= 0 && (fd_info[cp->fd].flags & FILE_CONNECT) != 0)
1149 rc = _sys_wait_connect (cp->fd);
1150 else if (cp->fd >= 0 && (fd_info[cp->fd].flags & FILE_LISTEN) != 0)
1151 rc = _sys_wait_accept (cp->fd);
1152 else
1153 rc = _sys_read_ahead (cp->fd);
1155 /* Don't bother waiting for the event if we already have been
1156 told to exit by delete_child. */
1157 if (cp->status == STATUS_READ_ERROR || !cp->char_avail)
1158 break;
1160 /* The name char_avail is a misnomer - it really just means the
1161 read-ahead has completed, whether successfully or not. */
1162 if (!SetEvent (cp->char_avail))
1164 DebPrint (("reader_thread.SetEvent(0x%x) failed with %lu for fd %ld (PID %d)\n",
1165 (DWORD_PTR)cp->char_avail, GetLastError (),
1166 cp->fd, cp->pid));
1167 return 1;
1170 if (rc == STATUS_READ_ERROR || rc == STATUS_CONNECT_FAILED)
1171 return 2;
1173 /* If the read died, the child has died so let the thread die */
1174 if (rc == STATUS_READ_FAILED)
1175 break;
1177 /* Don't bother waiting for the acknowledge if we already have
1178 been told to exit by delete_child. */
1179 if (cp->status == STATUS_READ_ERROR || !cp->char_consumed)
1180 break;
1182 /* Wait until our input is acknowledged before reading again */
1183 if (WaitForSingleObject (cp->char_consumed, INFINITE) != WAIT_OBJECT_0)
1185 DebPrint (("reader_thread.WaitForSingleObject failed with "
1186 "%lu for fd %ld\n", GetLastError (), cp->fd));
1187 break;
1189 /* delete_child sets status to STATUS_READ_ERROR when it wants
1190 us to exit. */
1191 if (cp->status == STATUS_READ_ERROR)
1192 break;
1194 return 0;
1197 /* To avoid Emacs changing directory, we just record here the
1198 directory the new process should start in. This is set just before
1199 calling sys_spawnve, and is not generally valid at any other time.
1200 Note that this directory's name is UTF-8 encoded. */
1201 static char * process_dir;
1203 static BOOL
1204 create_child (char *exe, char *cmdline, char *env, int is_gui_app,
1205 pid_t * pPid, child_process *cp)
1207 STARTUPINFO start;
1208 SECURITY_ATTRIBUTES sec_attrs;
1209 #if 0
1210 SECURITY_DESCRIPTOR sec_desc;
1211 #endif
1212 DWORD flags;
1213 char dir[ MAX_PATH ];
1214 char *p;
1215 const char *ext;
1217 if (cp == NULL) emacs_abort ();
1219 memset (&start, 0, sizeof (start));
1220 start.cb = sizeof (start);
1222 #ifdef HAVE_NTGUI
1223 if (NILP (Vw32_start_process_show_window) && !is_gui_app)
1224 start.dwFlags = STARTF_USESTDHANDLES | STARTF_USESHOWWINDOW;
1225 else
1226 start.dwFlags = STARTF_USESTDHANDLES;
1227 start.wShowWindow = SW_HIDE;
1229 start.hStdInput = GetStdHandle (STD_INPUT_HANDLE);
1230 start.hStdOutput = GetStdHandle (STD_OUTPUT_HANDLE);
1231 start.hStdError = GetStdHandle (STD_ERROR_HANDLE);
1232 #endif /* HAVE_NTGUI */
1234 #if 0
1235 /* Explicitly specify no security */
1236 if (!InitializeSecurityDescriptor (&sec_desc, SECURITY_DESCRIPTOR_REVISION))
1237 goto EH_Fail;
1238 if (!SetSecurityDescriptorDacl (&sec_desc, TRUE, NULL, FALSE))
1239 goto EH_Fail;
1240 #endif
1241 sec_attrs.nLength = sizeof (sec_attrs);
1242 sec_attrs.lpSecurityDescriptor = NULL /* &sec_desc */;
1243 sec_attrs.bInheritHandle = FALSE;
1245 filename_to_ansi (process_dir, dir);
1246 /* Can't use unixtodos_filename here, since that needs its file name
1247 argument encoded in UTF-8. OTOH, process_dir, which _is_ in
1248 UTF-8, points, to the directory computed by our caller, and we
1249 don't want to modify that, either. */
1250 for (p = dir; *p; p = CharNextA (p))
1251 if (*p == '/')
1252 *p = '\\';
1254 /* CreateProcess handles batch files as exe specially. This special
1255 handling fails when both the batch file and arguments are quoted.
1256 We pass NULL as exe to avoid the special handling. */
1257 if (exe && cmdline[0] == '"' &&
1258 (ext = strrchr (exe, '.')) &&
1259 (xstrcasecmp (ext, ".bat") == 0
1260 || xstrcasecmp (ext, ".cmd") == 0))
1261 exe = NULL;
1263 flags = (!NILP (Vw32_start_process_share_console)
1264 ? CREATE_NEW_PROCESS_GROUP
1265 : CREATE_NEW_CONSOLE);
1266 if (NILP (Vw32_start_process_inherit_error_mode))
1267 flags |= CREATE_DEFAULT_ERROR_MODE;
1268 if (!CreateProcessA (exe, cmdline, &sec_attrs, NULL, TRUE,
1269 flags, env, dir, &start, &cp->procinfo))
1270 goto EH_Fail;
1272 cp->pid = (int) cp->procinfo.dwProcessId;
1274 /* Hack for Windows 95, which assigns large (ie negative) pids */
1275 if (cp->pid < 0)
1276 cp->pid = -cp->pid;
1278 *pPid = cp->pid;
1280 return TRUE;
1282 EH_Fail:
1283 DebPrint (("create_child.CreateProcess failed: %ld\n", GetLastError ()););
1284 return FALSE;
1287 /* create_child doesn't know what emacs's file handle will be for waiting
1288 on output from the child, so we need to make this additional call
1289 to register the handle with the process
1290 This way the select emulator knows how to match file handles with
1291 entries in child_procs. */
1292 void
1293 register_child (pid_t pid, int fd)
1295 child_process *cp;
1297 cp = find_child_pid ((DWORD)pid);
1298 if (cp == NULL)
1300 DebPrint (("register_child unable to find pid %lu\n", pid));
1301 return;
1304 #ifdef FULL_DEBUG
1305 DebPrint (("register_child registered fd %d with pid %lu\n", fd, pid));
1306 #endif
1308 cp->fd = fd;
1310 /* thread is initially blocked until select is called; set status so
1311 that select will release thread */
1312 cp->status = STATUS_READ_ACKNOWLEDGED;
1314 /* attach child_process to fd_info */
1315 if (fd_info[fd].cp != NULL)
1317 DebPrint (("register_child: fd_info[%d] apparently in use!\n", fd));
1318 emacs_abort ();
1321 fd_info[fd].cp = cp;
1324 /* Called from waitpid when a process exits. */
1325 static void
1326 reap_subprocess (child_process *cp)
1328 if (cp->procinfo.hProcess)
1330 /* Reap the process */
1331 #ifdef FULL_DEBUG
1332 /* Process should have already died before we are called. */
1333 if (WaitForSingleObject (cp->procinfo.hProcess, 0) != WAIT_OBJECT_0)
1334 DebPrint (("reap_subprocess: child for fd %d has not died yet!", cp->fd));
1335 #endif
1336 CloseHandle (cp->procinfo.hProcess);
1337 cp->procinfo.hProcess = NULL;
1338 CloseHandle (cp->procinfo.hThread);
1339 cp->procinfo.hThread = NULL;
1342 /* If cp->fd was not closed yet, we might be still reading the
1343 process output, so don't free its resources just yet. The call
1344 to delete_child on behalf of this subprocess will be made by
1345 sys_read when the subprocess output is fully read. */
1346 if (cp->fd < 0)
1347 delete_child (cp);
1350 /* Wait for a child process specified by PID, or for any of our
1351 existing child processes (if PID is nonpositive) to die. When it
1352 does, close its handle. Return the pid of the process that died
1353 and fill in STATUS if non-NULL. */
1355 pid_t
1356 waitpid (pid_t pid, int *status, int options)
1358 DWORD active, retval;
1359 int nh;
1360 child_process *cp, *cps[MAX_CHILDREN];
1361 HANDLE wait_hnd[MAX_CHILDREN];
1362 DWORD timeout_ms;
1363 int dont_wait = (options & WNOHANG) != 0;
1365 nh = 0;
1366 /* According to Posix:
1368 PID = -1 means status is requested for any child process.
1370 PID > 0 means status is requested for a single child process
1371 whose pid is PID.
1373 PID = 0 means status is requested for any child process whose
1374 process group ID is equal to that of the calling process. But
1375 since Windows has only a limited support for process groups (only
1376 for console processes and only for the purposes of passing
1377 Ctrl-BREAK signal to them), and since we have no documented way
1378 of determining whether a given process belongs to our group, we
1379 treat 0 as -1.
1381 PID < -1 means status is requested for any child process whose
1382 process group ID is equal to the absolute value of PID. Again,
1383 since we don't support process groups, we treat that as -1. */
1384 if (pid > 0)
1386 int our_child = 0;
1388 /* We are requested to wait for a specific child. */
1389 for (cp = child_procs + (child_proc_count-1); cp >= child_procs; cp--)
1391 /* Some child_procs might be sockets; ignore them. Also
1392 ignore subprocesses whose output is not yet completely
1393 read. */
1394 if (CHILD_ACTIVE (cp)
1395 && cp->procinfo.hProcess
1396 && cp->pid == pid)
1398 our_child = 1;
1399 break;
1402 if (our_child)
1404 if (cp->fd < 0 || (fd_info[cp->fd].flags & FILE_AT_EOF) != 0)
1406 wait_hnd[nh] = cp->procinfo.hProcess;
1407 cps[nh] = cp;
1408 nh++;
1410 else if (dont_wait)
1412 /* PID specifies our subprocess, but its status is not
1413 yet available. */
1414 return 0;
1417 if (nh == 0)
1419 /* No such child process, or nothing to wait for, so fail. */
1420 errno = ECHILD;
1421 return -1;
1424 else
1426 for (cp = child_procs + (child_proc_count-1); cp >= child_procs; cp--)
1428 if (CHILD_ACTIVE (cp)
1429 && cp->procinfo.hProcess
1430 && (cp->fd < 0 || (fd_info[cp->fd].flags & FILE_AT_EOF) != 0))
1432 wait_hnd[nh] = cp->procinfo.hProcess;
1433 cps[nh] = cp;
1434 nh++;
1437 if (nh == 0)
1439 /* Nothing to wait on, so fail. */
1440 errno = ECHILD;
1441 return -1;
1445 if (dont_wait)
1446 timeout_ms = 0;
1447 else
1448 timeout_ms = 1000; /* check for quit about once a second. */
1452 /* When child_status_changed calls us with WNOHANG in OPTIONS,
1453 we are supposed to be non-interruptible, so don't allow
1454 quitting in that case. */
1455 if (!dont_wait)
1456 maybe_quit ();
1457 active = WaitForMultipleObjects (nh, wait_hnd, FALSE, timeout_ms);
1458 } while (active == WAIT_TIMEOUT && !dont_wait);
1460 if (active == WAIT_FAILED)
1462 errno = EBADF;
1463 return -1;
1465 else if (active == WAIT_TIMEOUT && dont_wait)
1467 /* PID specifies our subprocess, but it didn't exit yet, so its
1468 status is not yet available. */
1469 #ifdef FULL_DEBUG
1470 DebPrint (("Wait: PID %d not reap yet\n", cp->pid));
1471 #endif
1472 return 0;
1474 else if (active >= WAIT_OBJECT_0
1475 && active < WAIT_OBJECT_0+MAXIMUM_WAIT_OBJECTS)
1477 active -= WAIT_OBJECT_0;
1479 else if (active >= WAIT_ABANDONED_0
1480 && active < WAIT_ABANDONED_0+MAXIMUM_WAIT_OBJECTS)
1482 active -= WAIT_ABANDONED_0;
1484 else
1485 emacs_abort ();
1487 if (!GetExitCodeProcess (wait_hnd[active], &retval))
1489 DebPrint (("Wait.GetExitCodeProcess failed with %lu\n",
1490 GetLastError ()));
1491 retval = 1;
1493 if (retval == STILL_ACTIVE)
1495 /* Should never happen. But it does, with invoking git-gui.exe
1496 asynchronously. So we punt, and just report this process as
1497 exited with exit code 259, when we are called with WNOHANG
1498 from child_status_changed, because in that case we already
1499 _know_ the process has died. */
1500 DebPrint (("Wait.WaitForMultipleObjects returned an active process\n"));
1501 if (!(pid > 0 && dont_wait))
1503 errno = EINVAL;
1504 return -1;
1508 /* Massage the exit code from the process to match the format expected
1509 by the WIFSTOPPED et al macros in syswait.h. Only WIFSIGNALED and
1510 WIFEXITED are supported; WIFSTOPPED doesn't make sense under NT. */
1512 if (retval == STATUS_CONTROL_C_EXIT)
1513 retval = SIGINT;
1514 else
1515 retval <<= 8;
1517 if (pid > 0 && active != 0)
1518 emacs_abort ();
1519 cp = cps[active];
1520 pid = cp->pid;
1521 #ifdef FULL_DEBUG
1522 DebPrint (("Wait signaled with process pid %d\n", cp->pid));
1523 #endif
1525 if (status)
1526 *status = retval;
1527 reap_subprocess (cp);
1529 return pid;
1532 /* Old versions of w32api headers don't have separate 32-bit and
1533 64-bit defines, but the one they have matches the 32-bit variety. */
1534 #ifndef IMAGE_NT_OPTIONAL_HDR32_MAGIC
1535 # define IMAGE_NT_OPTIONAL_HDR32_MAGIC IMAGE_NT_OPTIONAL_HDR_MAGIC
1536 # define IMAGE_OPTIONAL_HEADER32 IMAGE_OPTIONAL_HEADER
1537 #endif
1539 /* Implementation note: This function works with file names encoded in
1540 the current ANSI codepage. */
1541 static int
1542 w32_executable_type (char * filename,
1543 int * is_dos_app,
1544 int * is_cygnus_app,
1545 int * is_msys_app,
1546 int * is_gui_app)
1548 file_data executable;
1549 char * p;
1550 int retval = 0;
1552 /* Default values in case we can't tell for sure. */
1553 *is_dos_app = FALSE;
1554 *is_cygnus_app = FALSE;
1555 *is_msys_app = FALSE;
1556 *is_gui_app = FALSE;
1558 if (!open_input_file (&executable, filename))
1559 return -1;
1561 p = strrchr (filename, '.');
1563 /* We can only identify DOS .com programs from the extension. */
1564 if (p && xstrcasecmp (p, ".com") == 0)
1565 *is_dos_app = TRUE;
1566 else if (p && (xstrcasecmp (p, ".bat") == 0
1567 || xstrcasecmp (p, ".cmd") == 0))
1569 /* A DOS shell script - it appears that CreateProcess is happy to
1570 accept this (somewhat surprisingly); presumably it looks at
1571 COMSPEC to determine what executable to actually invoke.
1572 Therefore, we have to do the same here as well. */
1573 /* Actually, I think it uses the program association for that
1574 extension, which is defined in the registry. */
1575 p = egetenv ("COMSPEC");
1576 if (p)
1577 retval = w32_executable_type (p, is_dos_app, is_cygnus_app, is_msys_app,
1578 is_gui_app);
1580 else
1582 /* Look for DOS .exe signature - if found, we must also check that
1583 it isn't really a 16- or 32-bit Windows exe, since both formats
1584 start with a DOS program stub. Note that 16-bit Windows
1585 executables use the OS/2 1.x format. */
1587 IMAGE_DOS_HEADER * dos_header;
1588 IMAGE_NT_HEADERS * nt_header;
1590 dos_header = (PIMAGE_DOS_HEADER) executable.file_base;
1591 if (dos_header->e_magic != IMAGE_DOS_SIGNATURE)
1592 goto unwind;
1594 nt_header = (PIMAGE_NT_HEADERS) ((unsigned char *) dos_header + dos_header->e_lfanew);
1596 if ((char *) nt_header > (char *) dos_header + executable.size)
1598 /* Some dos headers (pkunzip) have bogus e_lfanew fields. */
1599 *is_dos_app = TRUE;
1601 else if (nt_header->Signature != IMAGE_NT_SIGNATURE
1602 && LOWORD (nt_header->Signature) != IMAGE_OS2_SIGNATURE)
1604 *is_dos_app = TRUE;
1606 else if (nt_header->Signature == IMAGE_NT_SIGNATURE)
1608 IMAGE_DATA_DIRECTORY *data_dir = NULL;
1609 if (nt_header->OptionalHeader.Magic == IMAGE_NT_OPTIONAL_HDR32_MAGIC)
1611 /* Ensure we are using the 32 bit structure. */
1612 IMAGE_OPTIONAL_HEADER32 *opt
1613 = (IMAGE_OPTIONAL_HEADER32*) &(nt_header->OptionalHeader);
1614 data_dir = opt->DataDirectory;
1615 *is_gui_app = (opt->Subsystem == IMAGE_SUBSYSTEM_WINDOWS_GUI);
1617 /* MingW 3.12 has the required 64 bit structs, but in case older
1618 versions don't, only check 64 bit exes if we know how. */
1619 #ifdef IMAGE_NT_OPTIONAL_HDR64_MAGIC
1620 else if (nt_header->OptionalHeader.Magic
1621 == IMAGE_NT_OPTIONAL_HDR64_MAGIC)
1623 IMAGE_OPTIONAL_HEADER64 *opt
1624 = (IMAGE_OPTIONAL_HEADER64*) &(nt_header->OptionalHeader);
1625 data_dir = opt->DataDirectory;
1626 *is_gui_app = (opt->Subsystem == IMAGE_SUBSYSTEM_WINDOWS_GUI);
1628 #endif
1629 if (data_dir)
1631 /* Look for Cygwin DLL in the DLL import list. */
1632 IMAGE_DATA_DIRECTORY import_dir =
1633 data_dir[IMAGE_DIRECTORY_ENTRY_IMPORT];
1635 /* Import directory can be missing in .NET DLLs. */
1636 if (import_dir.VirtualAddress != 0)
1638 IMAGE_IMPORT_DESCRIPTOR * imports =
1639 RVA_TO_PTR (import_dir.VirtualAddress,
1640 rva_to_section (import_dir.VirtualAddress,
1641 nt_header),
1642 executable);
1644 for ( ; imports->Name; imports++)
1646 IMAGE_SECTION_HEADER * section =
1647 rva_to_section (imports->Name, nt_header);
1648 char * dllname = RVA_TO_PTR (imports->Name, section,
1649 executable);
1651 /* The exact name of the Cygwin DLL has changed with
1652 various releases, but hopefully this will be
1653 reasonably future-proof. */
1654 if (strncmp (dllname, "cygwin", 6) == 0)
1656 *is_cygnus_app = TRUE;
1657 break;
1659 else if (strncmp (dllname, "msys-", 5) == 0)
1661 /* This catches both MSYS 1.x and MSYS2
1662 executables (the DLL name is msys-1.0.dll and
1663 msys-2.0.dll, respectively). There doesn't
1664 seem to be a reason to distinguish between
1665 the two, for now. */
1666 *is_msys_app = TRUE;
1667 break;
1675 unwind:
1676 close_file_data (&executable);
1677 return retval;
1680 static int
1681 compare_env (const void *strp1, const void *strp2)
1683 const char *str1 = *(const char **)strp1, *str2 = *(const char **)strp2;
1685 while (*str1 && *str2 && *str1 != '=' && *str2 != '=')
1687 /* Sort order in command.com/cmd.exe is based on uppercasing
1688 names, so do the same here. */
1689 if (toupper (*str1) > toupper (*str2))
1690 return 1;
1691 else if (toupper (*str1) < toupper (*str2))
1692 return -1;
1693 str1++, str2++;
1696 if (*str1 == '=' && *str2 == '=')
1697 return 0;
1698 else if (*str1 == '=')
1699 return -1;
1700 else
1701 return 1;
1704 static void
1705 merge_and_sort_env (char **envp1, char **envp2, char **new_envp)
1707 char **optr, **nptr;
1708 int num;
1710 nptr = new_envp;
1711 optr = envp1;
1712 while (*optr)
1713 *nptr++ = *optr++;
1714 num = optr - envp1;
1716 optr = envp2;
1717 while (*optr)
1718 *nptr++ = *optr++;
1719 num += optr - envp2;
1721 qsort (new_envp, num, sizeof (char *), compare_env);
1723 *nptr = NULL;
1726 /* When a new child process is created we need to register it in our list,
1727 so intercept spawn requests. */
1729 sys_spawnve (int mode, char *cmdname, char **argv, char **envp)
1731 Lisp_Object program, full;
1732 char *cmdline, *env, *parg, **targ;
1733 int arglen, numenv;
1734 pid_t pid;
1735 child_process *cp;
1736 int is_dos_app, is_cygnus_app, is_msys_app, is_gui_app;
1737 int do_quoting = 0;
1738 /* We pass our process ID to our children by setting up an environment
1739 variable in their environment. */
1740 char ppid_env_var_buffer[64];
1741 char *extra_env[] = {ppid_env_var_buffer, NULL};
1742 /* These are the characters that cause an argument to need quoting.
1743 Arguments with whitespace characters need quoting to prevent the
1744 argument being split into two or more. Arguments with wildcards
1745 are also quoted, for consistency with posix platforms, where wildcards
1746 are not expanded if we run the program directly without a shell.
1747 Some extra whitespace characters need quoting in Cygwin/MSYS programs,
1748 so this list is conditionally modified below. */
1749 const char *sepchars = " \t*?";
1750 /* This is for native w32 apps; modified below for Cygwin/MSUS apps. */
1751 char escape_char = '\\';
1752 char cmdname_a[MAX_PATH];
1754 /* We don't care about the other modes */
1755 if (mode != _P_NOWAIT)
1757 errno = EINVAL;
1758 return -1;
1761 /* Handle executable names without an executable suffix. The caller
1762 already searched exec-path and verified the file is executable,
1763 but start-process doesn't do that for file names that are already
1764 absolute. So we double-check this here, just in case. */
1765 if (faccessat (AT_FDCWD, cmdname, X_OK, AT_EACCESS) != 0)
1767 program = build_string (cmdname);
1768 full = Qnil;
1769 openp (Vexec_path, program, Vexec_suffixes, &full, make_number (X_OK), 0);
1770 if (NILP (full))
1772 errno = EINVAL;
1773 return -1;
1775 program = ENCODE_FILE (full);
1776 cmdname = SSDATA (program);
1778 else
1780 char *p = alloca (strlen (cmdname) + 1);
1782 /* Don't change the command name we were passed by our caller
1783 (unixtodos_filename below will destructively mirror forward
1784 slashes). */
1785 cmdname = strcpy (p, cmdname);
1788 /* make sure argv[0] and cmdname are both in DOS format */
1789 unixtodos_filename (cmdname);
1790 /* argv[0] was encoded by caller using ENCODE_FILE, so it is in
1791 UTF-8. All the other arguments are encoded by ENCODE_SYSTEM or
1792 some such, and are in some ANSI codepage. We need to have
1793 argv[0] encoded in ANSI codepage. */
1794 filename_to_ansi (cmdname, cmdname_a);
1795 /* We explicitly require that the command's file name be encodable
1796 in the current ANSI codepage, because we will be invoking it via
1797 the ANSI APIs. */
1798 if (_mbspbrk ((unsigned char *)cmdname_a, (const unsigned char *)"?"))
1800 errno = ENOENT;
1801 return -1;
1803 /* From here on, CMDNAME is an ANSI-encoded string. */
1804 cmdname = cmdname_a;
1805 argv[0] = cmdname;
1807 /* Determine whether program is a 16-bit DOS executable, or a 32-bit
1808 Windows executable that is implicitly linked to the Cygnus or
1809 MSYS dll (implying it was compiled with the Cygnus/MSYS GNU
1810 toolchain and hence relies on cygwin.dll or MSYS DLL to parse the
1811 command line - we use this to decide how to escape quote chars in
1812 command line args that must be quoted).
1814 Also determine whether it is a GUI app, so that we don't hide its
1815 initial window unless specifically requested. */
1816 w32_executable_type (cmdname, &is_dos_app, &is_cygnus_app, &is_msys_app,
1817 &is_gui_app);
1819 /* On Windows 95, if cmdname is a DOS app, we invoke a helper
1820 application to start it by specifying the helper app as cmdname,
1821 while leaving the real app name as argv[0]. */
1822 if (is_dos_app)
1824 char *p;
1826 cmdname = alloca (MAX_PATH);
1827 if (egetenv ("CMDPROXY"))
1829 /* Implementation note: since process-environment, where
1830 'egetenv' looks, is encoded in the system codepage, we
1831 don't need to encode the cmdproxy file name if we get it
1832 from the environment. */
1833 strcpy (cmdname, egetenv ("CMDPROXY"));
1835 else
1837 char *q = lispstpcpy (cmdname,
1838 /* exec-directory needs to be encoded. */
1839 ansi_encode_filename (Vexec_directory));
1840 /* If we are run from the source tree, use cmdproxy.exe from
1841 the same source tree. */
1842 for (p = q - 2; p > cmdname; p = CharPrevA (cmdname, p))
1843 if (*p == '/')
1844 break;
1845 if (*p == '/' && xstrcasecmp (p, "/lib-src/") == 0)
1846 q = stpcpy (p, "/nt/");
1847 strcpy (q, "cmdproxy.exe");
1850 /* Can't use unixtodos_filename here, since that needs its file
1851 name argument encoded in UTF-8. */
1852 for (p = cmdname; *p; p = CharNextA (p))
1853 if (*p == '/')
1854 *p = '\\';
1857 /* we have to do some conjuring here to put argv and envp into the
1858 form CreateProcess wants... argv needs to be a space separated/null
1859 terminated list of parameters, and envp is a null
1860 separated/double-null terminated list of parameters.
1862 Additionally, zero-length args and args containing whitespace or
1863 quote chars need to be wrapped in double quotes - for this to work,
1864 embedded quotes need to be escaped as well. The aim is to ensure
1865 the child process reconstructs the argv array we start with
1866 exactly, so we treat quotes at the beginning and end of arguments
1867 as embedded quotes.
1869 The w32 GNU-based library from Cygnus doubles quotes to escape
1870 them, while MSVC uses backslash for escaping. (Actually the MSVC
1871 startup code does attempt to recognize doubled quotes and accept
1872 them, but gets it wrong and ends up requiring three quotes to get a
1873 single embedded quote!) So by default we decide whether to use
1874 quote or backslash as the escape character based on whether the
1875 binary is apparently a Cygnus compiled app.
1877 Note that using backslash to escape embedded quotes requires
1878 additional special handling if an embedded quote is already
1879 preceded by backslash, or if an arg requiring quoting ends with
1880 backslash. In such cases, the run of escape characters needs to be
1881 doubled. For consistency, we apply this special handling as long
1882 as the escape character is not quote.
1884 Since we have no idea how large argv and envp are likely to be we
1885 figure out list lengths on the fly and allocate them. */
1887 if (!NILP (Vw32_quote_process_args))
1889 do_quoting = 1;
1890 /* Override escape char by binding w32-quote-process-args to
1891 desired character, or use t for auto-selection. */
1892 if (INTEGERP (Vw32_quote_process_args))
1893 escape_char = XINT (Vw32_quote_process_args);
1894 else
1895 escape_char = (is_cygnus_app || is_msys_app) ? '"' : '\\';
1898 /* Cygwin/MSYS apps need quoting a bit more often. */
1899 if (escape_char == '"')
1900 sepchars = "\r\n\t\f '";
1902 /* do argv... */
1903 arglen = 0;
1904 targ = argv;
1905 while (*targ)
1907 char * p = *targ;
1908 int need_quotes = 0;
1909 int escape_char_run = 0;
1911 if (*p == 0)
1912 need_quotes = 1;
1913 for ( ; *p; p++)
1915 if (escape_char == '"' && *p == '\\')
1916 /* If it's a Cygwin/MSYS app, \ needs to be escaped. */
1917 arglen++;
1918 else if (*p == '"')
1920 /* allow for embedded quotes to be escaped */
1921 arglen++;
1922 need_quotes = 1;
1923 /* handle the case where the embedded quote is already escaped */
1924 if (escape_char_run > 0)
1926 /* To preserve the arg exactly, we need to double the
1927 preceding escape characters (plus adding one to
1928 escape the quote character itself). */
1929 arglen += escape_char_run;
1932 else if (strchr (sepchars, *p) != NULL)
1934 need_quotes = 1;
1937 if (*p == escape_char && escape_char != '"')
1938 escape_char_run++;
1939 else
1940 escape_char_run = 0;
1942 if (need_quotes)
1944 arglen += 2;
1945 /* handle the case where the arg ends with an escape char - we
1946 must not let the enclosing quote be escaped. */
1947 if (escape_char_run > 0)
1948 arglen += escape_char_run;
1950 arglen += strlen (*targ++) + 1;
1952 cmdline = alloca (arglen);
1953 targ = argv;
1954 parg = cmdline;
1955 while (*targ)
1957 char * p = *targ;
1958 int need_quotes = 0;
1960 if (*p == 0)
1961 need_quotes = 1;
1963 if (do_quoting)
1965 for ( ; *p; p++)
1966 if ((strchr (sepchars, *p) != NULL) || *p == '"')
1967 need_quotes = 1;
1969 if (need_quotes)
1971 int escape_char_run = 0;
1972 /* char * first; */
1973 /* char * last; */
1975 p = *targ;
1976 /* first = p; */
1977 /* last = p + strlen (p) - 1; */
1978 *parg++ = '"';
1979 #if 0
1980 /* This version does not escape quotes if they occur at the
1981 beginning or end of the arg - this could lead to incorrect
1982 behavior when the arg itself represents a command line
1983 containing quoted args. I believe this was originally done
1984 as a hack to make some things work, before
1985 `w32-quote-process-args' was added. */
1986 while (*p)
1988 if (*p == '"' && p > first && p < last)
1989 *parg++ = escape_char; /* escape embedded quotes */
1990 *parg++ = *p++;
1992 #else
1993 for ( ; *p; p++)
1995 if (*p == '"')
1997 /* double preceding escape chars if any */
1998 while (escape_char_run > 0)
2000 *parg++ = escape_char;
2001 escape_char_run--;
2003 /* escape all quote chars, even at beginning or end */
2004 *parg++ = escape_char;
2006 else if (escape_char == '"' && *p == '\\')
2007 *parg++ = '\\';
2008 *parg++ = *p;
2010 if (*p == escape_char && escape_char != '"')
2011 escape_char_run++;
2012 else
2013 escape_char_run = 0;
2015 /* double escape chars before enclosing quote */
2016 while (escape_char_run > 0)
2018 *parg++ = escape_char;
2019 escape_char_run--;
2021 #endif
2022 *parg++ = '"';
2024 else
2026 strcpy (parg, *targ);
2027 parg += strlen (*targ);
2029 *parg++ = ' ';
2030 targ++;
2032 *--parg = '\0';
2034 /* and envp... */
2035 arglen = 1;
2036 targ = envp;
2037 numenv = 1; /* for end null */
2038 while (*targ)
2040 arglen += strlen (*targ++) + 1;
2041 numenv++;
2043 /* extra env vars... */
2044 sprintf (ppid_env_var_buffer, "EM_PARENT_PROCESS_ID=%lu",
2045 GetCurrentProcessId ());
2046 arglen += strlen (ppid_env_var_buffer) + 1;
2047 numenv++;
2049 /* merge env passed in and extra env into one, and sort it. */
2050 targ = (char **) alloca (numenv * sizeof (char *));
2051 merge_and_sort_env (envp, extra_env, targ);
2053 /* concatenate env entries. */
2054 env = alloca (arglen);
2055 parg = env;
2056 while (*targ)
2058 strcpy (parg, *targ);
2059 parg += strlen (*targ++);
2060 *parg++ = '\0';
2062 *parg++ = '\0';
2063 *parg = '\0';
2065 cp = new_child ();
2066 if (cp == NULL)
2068 errno = EAGAIN;
2069 return -1;
2072 /* Now create the process. */
2073 if (!create_child (cmdname, cmdline, env, is_gui_app, &pid, cp))
2075 delete_child (cp);
2076 errno = ENOEXEC;
2077 return -1;
2080 return pid;
2083 /* Emulate the select call.
2084 Wait for available input on any of the given rfds, or timeout if
2085 a timeout is given and no input is detected. wfds are supported
2086 only for asynchronous 'connect' calls. efds are not supported
2087 and must be NULL.
2089 For simplicity, we detect the death of child processes here and
2090 synchronously call the SIGCHLD handler. Since it is possible for
2091 children to be created without a corresponding pipe handle from which
2092 to read output, we wait separately on the process handles as well as
2093 the char_avail events for each process pipe. We only call
2094 wait/reap_process when the process actually terminates.
2096 To reduce the number of places in which Emacs can be hung such that
2097 C-g is not able to interrupt it, we always wait on interrupt_handle
2098 (which is signaled by the input thread when C-g is detected). If we
2099 detect that we were woken up by C-g, we return -1 with errno set to
2100 EINTR as on Unix. */
2102 /* From w32console.c */
2103 extern HANDLE keyboard_handle;
2105 /* From w32xfns.c */
2106 extern HANDLE interrupt_handle;
2108 /* From process.c */
2109 extern int proc_buffered_char[];
2112 sys_select (int nfds, SELECT_TYPE *rfds, SELECT_TYPE *wfds, SELECT_TYPE *efds,
2113 const struct timespec *timeout, const sigset_t *ignored)
2115 SELECT_TYPE orfds, owfds;
2116 DWORD timeout_ms, start_time;
2117 int i, nh, nc, nr;
2118 DWORD active;
2119 child_process *cp, *cps[MAX_CHILDREN];
2120 HANDLE wait_hnd[MAXDESC + MAX_CHILDREN];
2121 int fdindex[MAXDESC]; /* mapping from wait handles back to descriptors */
2123 timeout_ms =
2124 timeout ? (timeout->tv_sec * 1000 + timeout->tv_nsec / 1000000) : INFINITE;
2126 /* If the descriptor sets are NULL but timeout isn't, then just Sleep. */
2127 if (rfds == NULL && wfds == NULL && efds == NULL && timeout != NULL)
2129 Sleep (timeout_ms);
2130 return 0;
2133 /* Otherwise, we only handle rfds and wfds, so fail otherwise. */
2134 if ((rfds == NULL && wfds == NULL) || efds != NULL)
2136 errno = EINVAL;
2137 return -1;
2140 if (rfds)
2142 orfds = *rfds;
2143 FD_ZERO (rfds);
2145 else
2146 FD_ZERO (&orfds);
2147 if (wfds)
2149 owfds = *wfds;
2150 FD_ZERO (wfds);
2152 else
2153 FD_ZERO (&owfds);
2154 nr = 0;
2156 /* If interrupt_handle is available and valid, always wait on it, to
2157 detect C-g (quit). */
2158 nh = 0;
2159 if (interrupt_handle && interrupt_handle != INVALID_HANDLE_VALUE)
2161 wait_hnd[0] = interrupt_handle;
2162 fdindex[0] = -1;
2163 nh++;
2166 /* Build a list of pipe handles to wait on. */
2167 for (i = 0; i < nfds; i++)
2168 if (FD_ISSET (i, &orfds) || FD_ISSET (i, &owfds))
2170 if (i == 0)
2172 if (keyboard_handle)
2174 /* Handle stdin specially */
2175 wait_hnd[nh] = keyboard_handle;
2176 fdindex[nh] = i;
2177 nh++;
2180 /* Check for any emacs-generated input in the queue since
2181 it won't be detected in the wait */
2182 if (rfds && detect_input_pending ())
2184 FD_SET (i, rfds);
2185 return 1;
2187 else if (noninteractive)
2189 if (handle_file_notifications (NULL))
2190 return 1;
2193 else
2195 /* Child process and socket/comm port input. */
2196 cp = fd_info[i].cp;
2197 if (FD_ISSET (i, &owfds)
2198 && cp
2199 && (fd_info[i].flags & FILE_CONNECT) == 0)
2201 DebPrint (("sys_select: fd %d is in wfds, but FILE_CONNECT is reset!\n", i));
2202 cp = NULL;
2204 if (cp)
2206 int current_status = cp->status;
2208 if (current_status == STATUS_READ_ACKNOWLEDGED)
2210 /* Tell reader thread which file handle to use. */
2211 cp->fd = i;
2212 /* Zero out the error code. */
2213 cp->errcode = 0;
2214 /* Wake up the reader thread for this process */
2215 cp->status = STATUS_READ_READY;
2216 if (!SetEvent (cp->char_consumed))
2217 DebPrint (("sys_select.SetEvent failed with "
2218 "%lu for fd %ld\n", GetLastError (), i));
2221 #ifdef CHECK_INTERLOCK
2222 /* slightly crude cross-checking of interlock between threads */
2224 current_status = cp->status;
2225 if (WaitForSingleObject (cp->char_avail, 0) == WAIT_OBJECT_0)
2227 /* char_avail has been signaled, so status (which may
2228 have changed) should indicate read has completed
2229 but has not been acknowledged. */
2230 current_status = cp->status;
2231 if (current_status != STATUS_READ_SUCCEEDED
2232 && current_status != STATUS_READ_FAILED)
2233 DebPrint (("char_avail set, but read not completed: status %d\n",
2234 current_status));
2236 else
2238 /* char_avail has not been signaled, so status should
2239 indicate that read is in progress; small possibility
2240 that read has completed but event wasn't yet signaled
2241 when we tested it (because a context switch occurred
2242 or if running on separate CPUs). */
2243 if (current_status != STATUS_READ_READY
2244 && current_status != STATUS_READ_IN_PROGRESS
2245 && current_status != STATUS_READ_SUCCEEDED
2246 && current_status != STATUS_READ_FAILED)
2247 DebPrint (("char_avail reset, but read status is bad: %d\n",
2248 current_status));
2250 #endif
2251 wait_hnd[nh] = cp->char_avail;
2252 fdindex[nh] = i;
2253 if (!wait_hnd[nh]) emacs_abort ();
2254 nh++;
2255 #ifdef FULL_DEBUG
2256 DebPrint (("select waiting on child %d fd %d\n",
2257 cp-child_procs, i));
2258 #endif
2260 else
2262 /* Unable to find something to wait on for this fd, skip */
2264 /* Note that this is not a fatal error, and can in fact
2265 happen in unusual circumstances. Specifically, if
2266 sys_spawnve fails, eg. because the program doesn't
2267 exist, and debug-on-error is t so Fsignal invokes a
2268 nested input loop, then the process output pipe is
2269 still included in input_wait_mask with no child_proc
2270 associated with it. (It is removed when the debugger
2271 exits the nested input loop and the error is thrown.) */
2273 DebPrint (("sys_select: fd %ld is invalid! ignoring\n", i));
2278 count_children:
2279 /* Add handles of child processes. */
2280 nc = 0;
2281 for (cp = child_procs + (child_proc_count-1); cp >= child_procs; cp--)
2282 /* Some child_procs might be sockets; ignore them. Also some
2283 children may have died already, but we haven't finished reading
2284 the process output; ignore them too. */
2285 if ((CHILD_ACTIVE (cp) && cp->procinfo.hProcess)
2286 && (cp->fd < 0
2287 || (fd_info[cp->fd].flags & FILE_SEND_SIGCHLD) == 0
2288 || (fd_info[cp->fd].flags & FILE_AT_EOF) != 0)
2291 wait_hnd[nh + nc] = cp->procinfo.hProcess;
2292 cps[nc] = cp;
2293 nc++;
2296 /* Nothing to look for, so we didn't find anything */
2297 if (nh + nc == 0)
2299 if (timeout)
2300 Sleep (timeout_ms);
2301 if (noninteractive)
2303 if (handle_file_notifications (NULL))
2304 return 1;
2306 return 0;
2309 start_time = GetTickCount ();
2311 /* Wait for input or child death to be signaled. If user input is
2312 allowed, then also accept window messages. */
2313 if (FD_ISSET (0, &orfds))
2314 active = MsgWaitForMultipleObjects (nh + nc, wait_hnd, FALSE, timeout_ms,
2315 QS_ALLINPUT);
2316 else
2317 active = WaitForMultipleObjects (nh + nc, wait_hnd, FALSE, timeout_ms);
2319 if (active == WAIT_FAILED)
2321 DebPrint (("select.WaitForMultipleObjects (%d, %lu) failed with %lu\n",
2322 nh + nc, timeout_ms, GetLastError ()));
2323 /* don't return EBADF - this causes wait_reading_process_output to
2324 abort; WAIT_FAILED is returned when single-stepping under
2325 Windows 95 after switching thread focus in debugger, and
2326 possibly at other times. */
2327 errno = EINTR;
2328 return -1;
2330 else if (active == WAIT_TIMEOUT)
2332 if (noninteractive)
2334 if (handle_file_notifications (NULL))
2335 return 1;
2337 return 0;
2339 else if (active >= WAIT_OBJECT_0
2340 && active < WAIT_OBJECT_0+MAXIMUM_WAIT_OBJECTS)
2342 active -= WAIT_OBJECT_0;
2344 else if (active >= WAIT_ABANDONED_0
2345 && active < WAIT_ABANDONED_0+MAXIMUM_WAIT_OBJECTS)
2347 active -= WAIT_ABANDONED_0;
2349 else
2350 emacs_abort ();
2352 /* Loop over all handles after active (now officially documented as
2353 being the first signaled handle in the array). We do this to
2354 ensure fairness, so that all channels with data available will be
2355 processed - otherwise higher numbered channels could be starved. */
2358 if (active == nh + nc)
2360 /* There are messages in the lisp thread's queue; we must
2361 drain the queue now to ensure they are processed promptly,
2362 because if we don't do so, we will not be woken again until
2363 further messages arrive.
2365 NB. If ever we allow window message procedures to callback
2366 into lisp, we will need to ensure messages are dispatched
2367 at a safe time for lisp code to be run (*), and we may also
2368 want to provide some hooks in the dispatch loop to cater
2369 for modeless dialogs created by lisp (ie. to register
2370 window handles to pass to IsDialogMessage).
2372 (*) Note that MsgWaitForMultipleObjects above is an
2373 internal dispatch point for messages that are sent to
2374 windows created by this thread. */
2375 if (drain_message_queue ()
2376 /* If drain_message_queue returns non-zero, that means
2377 we received a WM_EMACS_FILENOTIFY message. If this
2378 is a TTY frame, we must signal the caller that keyboard
2379 input is available, so that w32_console_read_socket
2380 will be called to pick up the notifications. If we
2381 don't do that, file notifications will only work when
2382 the Emacs TTY frame has focus. */
2383 && FRAME_TERMCAP_P (SELECTED_FRAME ())
2384 /* they asked for stdin reads */
2385 && FD_ISSET (0, &orfds)
2386 /* the stdin handle is valid */
2387 && keyboard_handle)
2389 FD_SET (0, rfds);
2390 if (nr == 0)
2391 nr = 1;
2394 else if (active >= nh)
2396 cp = cps[active - nh];
2398 /* We cannot always signal SIGCHLD immediately; if we have not
2399 finished reading the process output, we must delay sending
2400 SIGCHLD until we do. */
2402 if (cp->fd >= 0 && (fd_info[cp->fd].flags & FILE_AT_EOF) == 0)
2403 fd_info[cp->fd].flags |= FILE_SEND_SIGCHLD;
2404 /* SIG_DFL for SIGCHLD is ignored */
2405 else if (sig_handlers[SIGCHLD] != SIG_DFL &&
2406 sig_handlers[SIGCHLD] != SIG_IGN)
2408 #ifdef FULL_DEBUG
2409 DebPrint (("select calling SIGCHLD handler for pid %d\n",
2410 cp->pid));
2411 #endif
2412 sig_handlers[SIGCHLD] (SIGCHLD);
2415 else if (fdindex[active] == -1)
2417 /* Quit (C-g) was detected. */
2418 errno = EINTR;
2419 return -1;
2421 else if (rfds && fdindex[active] == 0)
2423 /* Keyboard input available */
2424 FD_SET (0, rfds);
2425 nr++;
2427 else
2429 /* Must be a socket or pipe - read ahead should have
2430 completed, either succeeding or failing. If this handle
2431 was waiting for an async 'connect', reset the connect
2432 flag, so it could read from now on. */
2433 if (wfds && (fd_info[fdindex[active]].flags & FILE_CONNECT) != 0)
2435 cp = fd_info[fdindex[active]].cp;
2436 if (cp)
2438 /* Don't reset the FILE_CONNECT bit and don't
2439 acknowledge the read if the status is
2440 STATUS_CONNECT_FAILED or some other
2441 failure. That's because the thread exits in those
2442 cases, so it doesn't need the ACK, and we want to
2443 keep the FILE_CONNECT bit as evidence that the
2444 connect failed, to be checked in sys_read. */
2445 if (cp->status == STATUS_READ_SUCCEEDED)
2447 fd_info[cp->fd].flags &= ~FILE_CONNECT;
2448 cp->status = STATUS_READ_ACKNOWLEDGED;
2450 ResetEvent (cp->char_avail);
2452 FD_SET (fdindex[active], wfds);
2454 else if (rfds)
2455 FD_SET (fdindex[active], rfds);
2456 nr++;
2459 /* Even though wait_reading_process_output only reads from at most
2460 one channel, we must process all channels here so that we reap
2461 all children that have died. */
2462 while (++active < nh + nc)
2463 if (WaitForSingleObject (wait_hnd[active], 0) == WAIT_OBJECT_0)
2464 break;
2465 } while (active < nh + nc);
2467 if (noninteractive)
2469 if (handle_file_notifications (NULL))
2470 nr++;
2473 /* If no input has arrived and timeout hasn't expired, wait again. */
2474 if (nr == 0)
2476 DWORD elapsed = GetTickCount () - start_time;
2478 if (timeout_ms > elapsed) /* INFINITE is MAX_UINT */
2480 if (timeout_ms != INFINITE)
2481 timeout_ms -= elapsed;
2482 goto count_children;
2486 return nr;
2489 /* Substitute for certain kill () operations */
2491 static BOOL CALLBACK
2492 find_child_console (HWND hwnd, LPARAM arg)
2494 child_process * cp = (child_process *) arg;
2495 DWORD process_id;
2497 GetWindowThreadProcessId (hwnd, &process_id);
2498 if (process_id == cp->procinfo.dwProcessId)
2500 char window_class[32];
2502 GetClassName (hwnd, window_class, sizeof (window_class));
2503 if (strcmp (window_class,
2504 (os_subtype == OS_9X)
2505 ? "tty"
2506 : "ConsoleWindowClass") == 0)
2508 cp->hwnd = hwnd;
2509 return FALSE;
2512 /* keep looking */
2513 return TRUE;
2516 typedef BOOL (WINAPI * DebugBreakProcess_Proc) (
2517 HANDLE hProcess);
2519 /* Emulate 'kill', but only for other processes. */
2521 sys_kill (pid_t pid, int sig)
2523 child_process *cp;
2524 HANDLE proc_hand;
2525 int need_to_free = 0;
2526 int rc = 0;
2528 /* Each process is in its own process group. */
2529 if (pid < 0)
2530 pid = -pid;
2532 /* Only handle signals that can be mapped to a similar behavior on Windows */
2533 if (sig != 0
2534 && sig != SIGINT && sig != SIGKILL && sig != SIGQUIT && sig != SIGHUP && sig != SIGTRAP)
2536 errno = EINVAL;
2537 return -1;
2540 if (sig == 0)
2542 /* It will take _some_ time before PID 4 or less on Windows will
2543 be Emacs... */
2544 if (pid <= 4)
2546 errno = EPERM;
2547 return -1;
2549 proc_hand = OpenProcess (PROCESS_QUERY_INFORMATION, 0, pid);
2550 if (proc_hand == NULL)
2552 DWORD err = GetLastError ();
2554 switch (err)
2556 case ERROR_ACCESS_DENIED: /* existing process, but access denied */
2557 errno = EPERM;
2558 return -1;
2559 case ERROR_INVALID_PARAMETER: /* process PID does not exist */
2560 errno = ESRCH;
2561 return -1;
2564 else
2565 CloseHandle (proc_hand);
2566 return 0;
2569 cp = find_child_pid (pid);
2570 if (cp == NULL)
2572 /* We were passed a PID of something other than our subprocess.
2573 If that is our own PID, we will send to ourself a message to
2574 close the selected frame, which does not necessarily
2575 terminates Emacs. But then we are not supposed to call
2576 sys_kill with our own PID. */
2578 DWORD desiredAccess =
2579 (sig == SIGTRAP) ? PROCESS_ALL_ACCESS : PROCESS_TERMINATE;
2581 proc_hand = OpenProcess (desiredAccess, 0, pid);
2582 if (proc_hand == NULL)
2584 errno = EPERM;
2585 return -1;
2587 need_to_free = 1;
2589 else
2591 proc_hand = cp->procinfo.hProcess;
2592 pid = cp->procinfo.dwProcessId;
2594 /* Try to locate console window for process. */
2595 EnumWindows (find_child_console, (LPARAM) cp);
2598 if (sig == SIGINT || sig == SIGQUIT)
2600 if (NILP (Vw32_start_process_share_console) && cp && cp->hwnd)
2602 BYTE control_scan_code = (BYTE) MapVirtualKey (VK_CONTROL, 0);
2603 /* Fake Ctrl-C for SIGINT, and Ctrl-Break for SIGQUIT. */
2604 BYTE vk_break_code = (sig == SIGINT) ? 'C' : VK_CANCEL;
2605 BYTE break_scan_code = (BYTE) MapVirtualKey (vk_break_code, 0);
2606 HWND foreground_window;
2608 if (break_scan_code == 0)
2610 /* Fake Ctrl-C for SIGQUIT if we can't manage Ctrl-Break. */
2611 vk_break_code = 'C';
2612 break_scan_code = (BYTE) MapVirtualKey (vk_break_code, 0);
2615 foreground_window = GetForegroundWindow ();
2616 if (foreground_window)
2618 /* NT 5.0, and apparently also Windows 98, will not allow
2619 a Window to be set to foreground directly without the
2620 user's involvement. The workaround is to attach
2621 ourselves to the thread that owns the foreground
2622 window, since that is the only thread that can set the
2623 foreground window. */
2624 DWORD foreground_thread, child_thread;
2625 foreground_thread =
2626 GetWindowThreadProcessId (foreground_window, NULL);
2627 if (foreground_thread == GetCurrentThreadId ()
2628 || !AttachThreadInput (GetCurrentThreadId (),
2629 foreground_thread, TRUE))
2630 foreground_thread = 0;
2632 child_thread = GetWindowThreadProcessId (cp->hwnd, NULL);
2633 if (child_thread == GetCurrentThreadId ()
2634 || !AttachThreadInput (GetCurrentThreadId (),
2635 child_thread, TRUE))
2636 child_thread = 0;
2638 /* Set the foreground window to the child. */
2639 if (SetForegroundWindow (cp->hwnd))
2641 /* Record the state of the Ctrl key: the user could
2642 have it depressed while we are simulating Ctrl-C,
2643 in which case we will have to leave the state of
2644 Ctrl depressed when we are done. */
2645 short ctrl_state = GetKeyState (VK_CONTROL) & 0x8000;
2647 /* Generate keystrokes as if user had typed Ctrl-Break or
2648 Ctrl-C. */
2649 keybd_event (VK_CONTROL, control_scan_code, 0, 0);
2650 keybd_event (vk_break_code, break_scan_code,
2651 (vk_break_code == 'C' ? 0 : KEYEVENTF_EXTENDEDKEY), 0);
2652 keybd_event (vk_break_code, break_scan_code,
2653 (vk_break_code == 'C' ? 0 : KEYEVENTF_EXTENDEDKEY)
2654 | KEYEVENTF_KEYUP, 0);
2655 keybd_event (VK_CONTROL, control_scan_code,
2656 KEYEVENTF_KEYUP, 0);
2658 /* Sleep for a bit to give time for Emacs frame to respond
2659 to focus change events (if Emacs was active app). */
2660 Sleep (100);
2662 SetForegroundWindow (foreground_window);
2663 /* If needed, restore the state of Ctrl. */
2664 if (ctrl_state != 0)
2665 keybd_event (VK_CONTROL, control_scan_code, 0, 0);
2667 /* Detach from the foreground and child threads now that
2668 the foreground switching is over. */
2669 if (foreground_thread)
2670 AttachThreadInput (GetCurrentThreadId (),
2671 foreground_thread, FALSE);
2672 if (child_thread)
2673 AttachThreadInput (GetCurrentThreadId (),
2674 child_thread, FALSE);
2677 /* Ctrl-Break is NT equivalent of SIGINT. */
2678 else if (!GenerateConsoleCtrlEvent (CTRL_BREAK_EVENT, pid))
2680 DebPrint (("sys_kill.GenerateConsoleCtrlEvent return %d "
2681 "for pid %lu\n", GetLastError (), pid));
2682 errno = EINVAL;
2683 rc = -1;
2686 else if (sig == SIGTRAP)
2688 static DebugBreakProcess_Proc s_pfn_Debug_Break_Process = NULL;
2690 if (g_b_init_debug_break_process == 0)
2692 g_b_init_debug_break_process = 1;
2693 s_pfn_Debug_Break_Process = (DebugBreakProcess_Proc)
2694 GetProcAddress (GetModuleHandle ("kernel32.dll"),
2695 "DebugBreakProcess");
2698 if (s_pfn_Debug_Break_Process == NULL)
2700 errno = ENOTSUP;
2701 rc = -1;
2703 else if (!s_pfn_Debug_Break_Process (proc_hand))
2705 DWORD err = GetLastError ();
2707 DebPrint (("sys_kill.DebugBreakProcess return %d "
2708 "for pid %lu\n", err, pid));
2710 switch (err)
2712 case ERROR_ACCESS_DENIED:
2713 errno = EPERM;
2714 break;
2715 default:
2716 errno = EINVAL;
2717 break;
2720 rc = -1;
2723 else
2725 if (NILP (Vw32_start_process_share_console) && cp && cp->hwnd)
2727 #if 1
2728 if (os_subtype == OS_9X)
2731 Another possibility is to try terminating the VDM out-right by
2732 calling the Shell VxD (id 0x17) V86 interface, function #4
2733 "SHELL_Destroy_VM", ie.
2735 mov edx,4
2736 mov ebx,vm_handle
2737 call shellapi
2739 First need to determine the current VM handle, and then arrange for
2740 the shellapi call to be made from the system vm (by using
2741 Switch_VM_and_callback).
2743 Could try to invoke DestroyVM through CallVxD.
2746 #if 0
2747 /* On Windows 95, posting WM_QUIT causes the 16-bit subsystem
2748 to hang when cmdproxy is used in conjunction with
2749 command.com for an interactive shell. Posting
2750 WM_CLOSE pops up a dialog that, when Yes is selected,
2751 does the same thing. TerminateProcess is also less
2752 than ideal in that subprocesses tend to stick around
2753 until the machine is shutdown, but at least it
2754 doesn't freeze the 16-bit subsystem. */
2755 PostMessage (cp->hwnd, WM_QUIT, 0xff, 0);
2756 #endif
2757 if (!TerminateProcess (proc_hand, 0xff))
2759 DebPrint (("sys_kill.TerminateProcess returned %d "
2760 "for pid %lu\n", GetLastError (), pid));
2761 errno = EINVAL;
2762 rc = -1;
2765 else
2766 #endif
2767 PostMessage (cp->hwnd, WM_CLOSE, 0, 0);
2769 /* Kill the process. On W32 this doesn't kill child processes
2770 so it doesn't work very well for shells which is why it's not
2771 used in every case. */
2772 else if (!TerminateProcess (proc_hand, 0xff))
2774 DebPrint (("sys_kill.TerminateProcess returned %d "
2775 "for pid %lu\n", GetLastError (), pid));
2776 errno = EINVAL;
2777 rc = -1;
2781 if (need_to_free)
2782 CloseHandle (proc_hand);
2784 return rc;
2787 /* The following two routines are used to manipulate stdin, stdout, and
2788 stderr of our child processes.
2790 Assuming that in, out, and err are *not* inheritable, we make them
2791 stdin, stdout, and stderr of the child as follows:
2793 - Save the parent's current standard handles.
2794 - Set the std handles to inheritable duplicates of the ones being passed in.
2795 (Note that _get_osfhandle() is an io.h procedure that retrieves the
2796 NT file handle for a crt file descriptor.)
2797 - Spawn the child, which inherits in, out, and err as stdin,
2798 stdout, and stderr. (see Spawnve)
2799 - Close the std handles passed to the child.
2800 - Reset the parent's standard handles to the saved handles.
2801 (see reset_standard_handles)
2802 We assume that the caller closes in, out, and err after calling us. */
2804 void
2805 prepare_standard_handles (int in, int out, int err, HANDLE handles[3])
2807 HANDLE parent;
2808 HANDLE newstdin, newstdout, newstderr;
2810 parent = GetCurrentProcess ();
2812 handles[0] = GetStdHandle (STD_INPUT_HANDLE);
2813 handles[1] = GetStdHandle (STD_OUTPUT_HANDLE);
2814 handles[2] = GetStdHandle (STD_ERROR_HANDLE);
2816 /* make inheritable copies of the new handles */
2817 if (!DuplicateHandle (parent,
2818 (HANDLE) _get_osfhandle (in),
2819 parent,
2820 &newstdin,
2822 TRUE,
2823 DUPLICATE_SAME_ACCESS))
2824 report_file_error ("Duplicating input handle for child", Qnil);
2826 if (!DuplicateHandle (parent,
2827 (HANDLE) _get_osfhandle (out),
2828 parent,
2829 &newstdout,
2831 TRUE,
2832 DUPLICATE_SAME_ACCESS))
2833 report_file_error ("Duplicating output handle for child", Qnil);
2835 if (!DuplicateHandle (parent,
2836 (HANDLE) _get_osfhandle (err),
2837 parent,
2838 &newstderr,
2840 TRUE,
2841 DUPLICATE_SAME_ACCESS))
2842 report_file_error ("Duplicating error handle for child", Qnil);
2844 /* and store them as our std handles */
2845 if (!SetStdHandle (STD_INPUT_HANDLE, newstdin))
2846 report_file_error ("Changing stdin handle", Qnil);
2848 if (!SetStdHandle (STD_OUTPUT_HANDLE, newstdout))
2849 report_file_error ("Changing stdout handle", Qnil);
2851 if (!SetStdHandle (STD_ERROR_HANDLE, newstderr))
2852 report_file_error ("Changing stderr handle", Qnil);
2855 void
2856 reset_standard_handles (int in, int out, int err, HANDLE handles[3])
2858 /* close the duplicated handles passed to the child */
2859 CloseHandle (GetStdHandle (STD_INPUT_HANDLE));
2860 CloseHandle (GetStdHandle (STD_OUTPUT_HANDLE));
2861 CloseHandle (GetStdHandle (STD_ERROR_HANDLE));
2863 /* now restore parent's saved std handles */
2864 SetStdHandle (STD_INPUT_HANDLE, handles[0]);
2865 SetStdHandle (STD_OUTPUT_HANDLE, handles[1]);
2866 SetStdHandle (STD_ERROR_HANDLE, handles[2]);
2869 void
2870 set_process_dir (char * dir)
2872 process_dir = dir;
2875 /* To avoid problems with winsock implementations that work over dial-up
2876 connections causing or requiring a connection to exist while Emacs is
2877 running, Emacs no longer automatically loads winsock on startup if it
2878 is present. Instead, it will be loaded when open-network-stream is
2879 first called.
2881 To allow full control over when winsock is loaded, we provide these
2882 two functions to dynamically load and unload winsock. This allows
2883 dial-up users to only be connected when they actually need to use
2884 socket services. */
2886 /* From w32.c */
2887 extern HANDLE winsock_lib;
2888 extern BOOL term_winsock (void);
2890 DEFUN ("w32-has-winsock", Fw32_has_winsock, Sw32_has_winsock, 0, 1, 0,
2891 doc: /* Test for presence of the Windows socket library `winsock'.
2892 Returns non-nil if winsock support is present, nil otherwise.
2894 If the optional argument LOAD-NOW is non-nil, the winsock library is
2895 also loaded immediately if not already loaded. If winsock is loaded,
2896 the winsock local hostname is returned (since this may be different from
2897 the value of `system-name' and should supplant it), otherwise t is
2898 returned to indicate winsock support is present. */)
2899 (Lisp_Object load_now)
2901 int have_winsock;
2903 have_winsock = init_winsock (!NILP (load_now));
2904 if (have_winsock)
2906 if (winsock_lib != NULL)
2908 /* Return new value for system-name. The best way to do this
2909 is to call init_system_name, saving and restoring the
2910 original value to avoid side-effects. */
2911 Lisp_Object orig_hostname = Vsystem_name;
2912 Lisp_Object hostname;
2914 init_system_name ();
2915 hostname = Vsystem_name;
2916 Vsystem_name = orig_hostname;
2917 return hostname;
2919 return Qt;
2921 return Qnil;
2924 DEFUN ("w32-unload-winsock", Fw32_unload_winsock, Sw32_unload_winsock,
2925 0, 0, 0,
2926 doc: /* Unload the Windows socket library `winsock' if loaded.
2927 This is provided to allow dial-up socket connections to be disconnected
2928 when no longer needed. Returns nil without unloading winsock if any
2929 socket connections still exist. */)
2930 (void)
2932 return term_winsock () ? Qt : Qnil;
2936 /* Some miscellaneous functions that are Windows specific, but not GUI
2937 specific (ie. are applicable in terminal or batch mode as well). */
2939 DEFUN ("w32-short-file-name", Fw32_short_file_name, Sw32_short_file_name, 1, 1, 0,
2940 doc: /* Return the short file name version (8.3) of the full path of FILENAME.
2941 If FILENAME does not exist, return nil.
2942 All path elements in FILENAME are converted to their short names. */)
2943 (Lisp_Object filename)
2945 char shortname[MAX_PATH];
2947 CHECK_STRING (filename);
2949 /* first expand it. */
2950 filename = Fexpand_file_name (filename, Qnil);
2952 /* luckily, this returns the short version of each element in the path. */
2953 if (w32_get_short_filename (SSDATA (ENCODE_FILE (filename)),
2954 shortname, MAX_PATH) == 0)
2955 return Qnil;
2957 dostounix_filename (shortname);
2959 /* No need to DECODE_FILE, because 8.3 names are pure ASCII. */
2960 return build_string (shortname);
2964 DEFUN ("w32-long-file-name", Fw32_long_file_name, Sw32_long_file_name,
2965 1, 1, 0,
2966 doc: /* Return the long file name version of the full path of FILENAME.
2967 If FILENAME does not exist, return nil.
2968 All path elements in FILENAME are converted to their long names. */)
2969 (Lisp_Object filename)
2971 char longname[ MAX_UTF8_PATH ];
2972 int drive_only = 0;
2974 CHECK_STRING (filename);
2976 if (SBYTES (filename) == 2
2977 && *(SDATA (filename) + 1) == ':')
2978 drive_only = 1;
2980 /* first expand it. */
2981 filename = Fexpand_file_name (filename, Qnil);
2983 if (!w32_get_long_filename (SSDATA (ENCODE_FILE (filename)), longname,
2984 MAX_UTF8_PATH))
2985 return Qnil;
2987 dostounix_filename (longname);
2989 /* If we were passed only a drive, make sure that a slash is not appended
2990 for consistency with directories. Allow for drive mapping via SUBST
2991 in case expand-file-name is ever changed to expand those. */
2992 if (drive_only && longname[1] == ':' && longname[2] == '/' && !longname[3])
2993 longname[2] = '\0';
2995 return DECODE_FILE (build_unibyte_string (longname));
2998 DEFUN ("w32-set-process-priority", Fw32_set_process_priority,
2999 Sw32_set_process_priority, 2, 2, 0,
3000 doc: /* Set the priority of PROCESS to PRIORITY.
3001 If PROCESS is nil, the priority of Emacs is changed, otherwise the
3002 priority of the process whose pid is PROCESS is changed.
3003 PRIORITY should be one of the symbols high, normal, or low;
3004 any other symbol will be interpreted as normal.
3006 If successful, the return value is t, otherwise nil. */)
3007 (Lisp_Object process, Lisp_Object priority)
3009 HANDLE proc_handle = GetCurrentProcess ();
3010 DWORD priority_class = NORMAL_PRIORITY_CLASS;
3011 Lisp_Object result = Qnil;
3013 CHECK_SYMBOL (priority);
3015 if (!NILP (process))
3017 DWORD pid;
3018 child_process *cp;
3020 CHECK_NUMBER (process);
3022 /* Allow pid to be an internally generated one, or one obtained
3023 externally. This is necessary because real pids on Windows 95 are
3024 negative. */
3026 pid = XINT (process);
3027 cp = find_child_pid (pid);
3028 if (cp != NULL)
3029 pid = cp->procinfo.dwProcessId;
3031 proc_handle = OpenProcess (PROCESS_SET_INFORMATION, FALSE, pid);
3034 if (EQ (priority, Qhigh))
3035 priority_class = HIGH_PRIORITY_CLASS;
3036 else if (EQ (priority, Qlow))
3037 priority_class = IDLE_PRIORITY_CLASS;
3039 if (proc_handle != NULL)
3041 if (SetPriorityClass (proc_handle, priority_class))
3042 result = Qt;
3043 if (!NILP (process))
3044 CloseHandle (proc_handle);
3047 return result;
3050 DEFUN ("w32-application-type", Fw32_application_type,
3051 Sw32_application_type, 1, 1, 0,
3052 doc: /* Return the type of an MS-Windows PROGRAM.
3054 Knowing the type of an executable could be useful for formatting
3055 file names passed to it or for quoting its command-line arguments.
3057 PROGRAM should specify an executable file, including the extension.
3059 The value is one of the following:
3061 `dos' -- a DOS .com program or some other non-PE executable
3062 `cygwin' -- a Cygwin program that depends on Cygwin DLL
3063 `msys' -- an MSYS 1.x or MSYS2 program
3064 `w32-native' -- a native Windows application
3065 `unknown' -- a file that doesn't exist, or cannot be open, or whose
3066 name is not encodable in the current ANSI codepage.
3068 Note that for .bat and .cmd batch files the function returns the type
3069 of their command interpreter, as specified by the \"COMSPEC\"
3070 environment variable.
3072 This function returns `unknown' for programs whose file names
3073 include characters not supported by the current ANSI codepage, as
3074 such programs cannot be invoked by Emacs anyway. */)
3075 (Lisp_Object program)
3077 int is_dos_app, is_cygwin_app, is_msys_app, dummy;
3078 Lisp_Object encoded_progname;
3079 char *progname, progname_a[MAX_PATH];
3081 program = Fexpand_file_name (program, Qnil);
3082 encoded_progname = ENCODE_FILE (program);
3083 progname = SSDATA (encoded_progname);
3084 unixtodos_filename (progname);
3085 filename_to_ansi (progname, progname_a);
3086 /* Reject file names that cannot be encoded in the current ANSI
3087 codepage. */
3088 if (_mbspbrk ((unsigned char *)progname_a, (const unsigned char *)"?"))
3089 return Qunknown;
3091 if (w32_executable_type (progname_a, &is_dos_app, &is_cygwin_app,
3092 &is_msys_app, &dummy) != 0)
3093 return Qunknown;
3094 if (is_dos_app)
3095 return Qdos;
3096 if (is_cygwin_app)
3097 return Qcygwin;
3098 if (is_msys_app)
3099 return Qmsys;
3100 return Qw32_native;
3103 #ifdef HAVE_LANGINFO_CODESET
3104 /* Emulation of nl_langinfo. Used in fns.c:Flocale_info. */
3105 char *
3106 nl_langinfo (nl_item item)
3108 /* Conversion of Posix item numbers to their Windows equivalents. */
3109 static const LCTYPE w32item[] = {
3110 LOCALE_IDEFAULTANSICODEPAGE,
3111 LOCALE_SDAYNAME1, LOCALE_SDAYNAME2, LOCALE_SDAYNAME3,
3112 LOCALE_SDAYNAME4, LOCALE_SDAYNAME5, LOCALE_SDAYNAME6, LOCALE_SDAYNAME7,
3113 LOCALE_SMONTHNAME1, LOCALE_SMONTHNAME2, LOCALE_SMONTHNAME3,
3114 LOCALE_SMONTHNAME4, LOCALE_SMONTHNAME5, LOCALE_SMONTHNAME6,
3115 LOCALE_SMONTHNAME7, LOCALE_SMONTHNAME8, LOCALE_SMONTHNAME9,
3116 LOCALE_SMONTHNAME10, LOCALE_SMONTHNAME11, LOCALE_SMONTHNAME12
3119 static char *nl_langinfo_buf = NULL;
3120 static int nl_langinfo_len = 0;
3122 if (nl_langinfo_len <= 0)
3123 nl_langinfo_buf = xmalloc (nl_langinfo_len = 1);
3125 if (item < 0 || item >= _NL_NUM)
3126 nl_langinfo_buf[0] = 0;
3127 else
3129 LCID cloc = GetThreadLocale ();
3130 int need_len = GetLocaleInfo (cloc, w32item[item] | LOCALE_USE_CP_ACP,
3131 NULL, 0);
3133 if (need_len <= 0)
3134 nl_langinfo_buf[0] = 0;
3135 else
3137 if (item == CODESET)
3139 need_len += 2; /* for the "cp" prefix */
3140 if (need_len < 8) /* for the case we call GetACP */
3141 need_len = 8;
3143 if (nl_langinfo_len <= need_len)
3144 nl_langinfo_buf = xrealloc (nl_langinfo_buf,
3145 nl_langinfo_len = need_len);
3146 if (!GetLocaleInfo (cloc, w32item[item] | LOCALE_USE_CP_ACP,
3147 nl_langinfo_buf, nl_langinfo_len))
3148 nl_langinfo_buf[0] = 0;
3149 else if (item == CODESET)
3151 if (strcmp (nl_langinfo_buf, "0") == 0 /* CP_ACP */
3152 || strcmp (nl_langinfo_buf, "1") == 0) /* CP_OEMCP */
3153 sprintf (nl_langinfo_buf, "cp%u", GetACP ());
3154 else
3156 memmove (nl_langinfo_buf + 2, nl_langinfo_buf,
3157 strlen (nl_langinfo_buf) + 1);
3158 nl_langinfo_buf[0] = 'c';
3159 nl_langinfo_buf[1] = 'p';
3164 return nl_langinfo_buf;
3166 #endif /* HAVE_LANGINFO_CODESET */
3168 DEFUN ("w32-get-locale-info", Fw32_get_locale_info,
3169 Sw32_get_locale_info, 1, 2, 0,
3170 doc: /* Return information about the Windows locale LCID.
3171 By default, return a three letter locale code which encodes the default
3172 language as the first two characters, and the country or regional variant
3173 as the third letter. For example, ENU refers to `English (United States)',
3174 while ENC means `English (Canadian)'.
3176 If the optional argument LONGFORM is t, the long form of the locale
3177 name is returned, e.g. `English (United States)' instead; if LONGFORM
3178 is a number, it is interpreted as an LCTYPE constant and the corresponding
3179 locale information is returned.
3181 If LCID (a 16-bit number) is not a valid locale, the result is nil. */)
3182 (Lisp_Object lcid, Lisp_Object longform)
3184 int got_abbrev;
3185 int got_full;
3186 char abbrev_name[32] = { 0 };
3187 char full_name[256] = { 0 };
3189 CHECK_NUMBER (lcid);
3191 if (!IsValidLocale (XINT (lcid), LCID_SUPPORTED))
3192 return Qnil;
3194 if (NILP (longform))
3196 got_abbrev = GetLocaleInfo (XINT (lcid),
3197 LOCALE_SABBREVLANGNAME | LOCALE_USE_CP_ACP,
3198 abbrev_name, sizeof (abbrev_name));
3199 if (got_abbrev)
3200 return build_string (abbrev_name);
3202 else if (EQ (longform, Qt))
3204 got_full = GetLocaleInfo (XINT (lcid),
3205 LOCALE_SLANGUAGE | LOCALE_USE_CP_ACP,
3206 full_name, sizeof (full_name));
3207 if (got_full)
3208 return DECODE_SYSTEM (build_string (full_name));
3210 else if (NUMBERP (longform))
3212 got_full = GetLocaleInfo (XINT (lcid),
3213 XINT (longform),
3214 full_name, sizeof (full_name));
3215 /* GetLocaleInfo's return value includes the terminating null
3216 character, when the returned information is a string, whereas
3217 make_unibyte_string needs the string length without the
3218 terminating null. */
3219 if (got_full)
3220 return make_unibyte_string (full_name, got_full - 1);
3223 return Qnil;
3227 DEFUN ("w32-get-current-locale-id", Fw32_get_current_locale_id,
3228 Sw32_get_current_locale_id, 0, 0, 0,
3229 doc: /* Return Windows locale id for current locale setting.
3230 This is a numerical value; use `w32-get-locale-info' to convert to a
3231 human-readable form. */)
3232 (void)
3234 return make_number (GetThreadLocale ());
3237 static DWORD
3238 int_from_hex (char * s)
3240 DWORD val = 0;
3241 static char hex[] = "0123456789abcdefABCDEF";
3242 char * p;
3244 while (*s && (p = strchr (hex, *s)) != NULL)
3246 unsigned digit = p - hex;
3247 if (digit > 15)
3248 digit -= 6;
3249 val = val * 16 + digit;
3250 s++;
3252 return val;
3255 /* We need to build a global list, since the EnumSystemLocale callback
3256 function isn't given a context pointer. */
3257 Lisp_Object Vw32_valid_locale_ids;
3259 static BOOL CALLBACK ALIGN_STACK
3260 enum_locale_fn (LPTSTR localeNum)
3262 DWORD id = int_from_hex (localeNum);
3263 Vw32_valid_locale_ids = Fcons (make_number (id), Vw32_valid_locale_ids);
3264 return TRUE;
3267 DEFUN ("w32-get-valid-locale-ids", Fw32_get_valid_locale_ids,
3268 Sw32_get_valid_locale_ids, 0, 0, 0,
3269 doc: /* Return list of all valid Windows locale ids.
3270 Each id is a numerical value; use `w32-get-locale-info' to convert to a
3271 human-readable form. */)
3272 (void)
3274 Vw32_valid_locale_ids = Qnil;
3276 EnumSystemLocales (enum_locale_fn, LCID_SUPPORTED);
3278 Vw32_valid_locale_ids = Fnreverse (Vw32_valid_locale_ids);
3279 return Vw32_valid_locale_ids;
3283 DEFUN ("w32-get-default-locale-id", Fw32_get_default_locale_id, Sw32_get_default_locale_id, 0, 1, 0,
3284 doc: /* Return Windows locale id for default locale setting.
3285 By default, the system default locale setting is returned; if the optional
3286 parameter USERP is non-nil, the user default locale setting is returned.
3287 This is a numerical value; use `w32-get-locale-info' to convert to a
3288 human-readable form. */)
3289 (Lisp_Object userp)
3291 if (NILP (userp))
3292 return make_number (GetSystemDefaultLCID ());
3293 return make_number (GetUserDefaultLCID ());
3297 DEFUN ("w32-set-current-locale", Fw32_set_current_locale, Sw32_set_current_locale, 1, 1, 0,
3298 doc: /* Make Windows locale LCID be the current locale setting for Emacs.
3299 If successful, the new locale id is returned, otherwise nil. */)
3300 (Lisp_Object lcid)
3302 CHECK_NUMBER (lcid);
3304 if (!IsValidLocale (XINT (lcid), LCID_SUPPORTED))
3305 return Qnil;
3307 if (!SetThreadLocale (XINT (lcid)))
3308 return Qnil;
3310 /* Need to set input thread locale if present. */
3311 if (dwWindowsThreadId)
3312 /* Reply is not needed. */
3313 PostThreadMessage (dwWindowsThreadId, WM_EMACS_SETLOCALE, XINT (lcid), 0);
3315 return make_number (GetThreadLocale ());
3319 /* We need to build a global list, since the EnumCodePages callback
3320 function isn't given a context pointer. */
3321 Lisp_Object Vw32_valid_codepages;
3323 static BOOL CALLBACK ALIGN_STACK
3324 enum_codepage_fn (LPTSTR codepageNum)
3326 DWORD id = atoi (codepageNum);
3327 Vw32_valid_codepages = Fcons (make_number (id), Vw32_valid_codepages);
3328 return TRUE;
3331 DEFUN ("w32-get-valid-codepages", Fw32_get_valid_codepages,
3332 Sw32_get_valid_codepages, 0, 0, 0,
3333 doc: /* Return list of all valid Windows codepages. */)
3334 (void)
3336 Vw32_valid_codepages = Qnil;
3338 EnumSystemCodePages (enum_codepage_fn, CP_SUPPORTED);
3340 Vw32_valid_codepages = Fnreverse (Vw32_valid_codepages);
3341 return Vw32_valid_codepages;
3345 DEFUN ("w32-get-console-codepage", Fw32_get_console_codepage,
3346 Sw32_get_console_codepage, 0, 0, 0,
3347 doc: /* Return current Windows codepage for console input. */)
3348 (void)
3350 return make_number (GetConsoleCP ());
3354 DEFUN ("w32-set-console-codepage", Fw32_set_console_codepage,
3355 Sw32_set_console_codepage, 1, 1, 0,
3356 doc: /* Make Windows codepage CP be the codepage for Emacs tty keyboard input.
3357 This codepage setting affects keyboard input in tty mode.
3358 If successful, the new CP is returned, otherwise nil. */)
3359 (Lisp_Object cp)
3361 CHECK_NUMBER (cp);
3363 if (!IsValidCodePage (XINT (cp)))
3364 return Qnil;
3366 if (!SetConsoleCP (XINT (cp)))
3367 return Qnil;
3369 return make_number (GetConsoleCP ());
3373 DEFUN ("w32-get-console-output-codepage", Fw32_get_console_output_codepage,
3374 Sw32_get_console_output_codepage, 0, 0, 0,
3375 doc: /* Return current Windows codepage for console output. */)
3376 (void)
3378 return make_number (GetConsoleOutputCP ());
3382 DEFUN ("w32-set-console-output-codepage", Fw32_set_console_output_codepage,
3383 Sw32_set_console_output_codepage, 1, 1, 0,
3384 doc: /* Make Windows codepage CP be the codepage for Emacs console output.
3385 This codepage setting affects display in tty mode.
3386 If successful, the new CP is returned, otherwise nil. */)
3387 (Lisp_Object cp)
3389 CHECK_NUMBER (cp);
3391 if (!IsValidCodePage (XINT (cp)))
3392 return Qnil;
3394 if (!SetConsoleOutputCP (XINT (cp)))
3395 return Qnil;
3397 return make_number (GetConsoleOutputCP ());
3401 DEFUN ("w32-get-codepage-charset", Fw32_get_codepage_charset,
3402 Sw32_get_codepage_charset, 1, 1, 0,
3403 doc: /* Return charset ID corresponding to codepage CP.
3404 Returns nil if the codepage is not valid or its charset ID could
3405 not be determined.
3407 Note that this function is only guaranteed to work with ANSI
3408 codepages; most console codepages are not supported and will
3409 yield nil. */)
3410 (Lisp_Object cp)
3412 CHARSETINFO info;
3413 DWORD_PTR dwcp;
3415 CHECK_NUMBER (cp);
3417 if (!IsValidCodePage (XINT (cp)))
3418 return Qnil;
3420 /* Going through a temporary DWORD_PTR variable avoids compiler warning
3421 about cast to pointer from integer of different size, when
3422 building --with-wide-int or building for 64bit. */
3423 dwcp = XINT (cp);
3424 if (TranslateCharsetInfo ((DWORD *) dwcp, &info, TCI_SRCCODEPAGE))
3425 return make_number (info.ciCharset);
3427 return Qnil;
3431 DEFUN ("w32-get-valid-keyboard-layouts", Fw32_get_valid_keyboard_layouts,
3432 Sw32_get_valid_keyboard_layouts, 0, 0, 0,
3433 doc: /* Return list of Windows keyboard languages and layouts.
3434 The return value is a list of pairs of language id and layout id. */)
3435 (void)
3437 int num_layouts = GetKeyboardLayoutList (0, NULL);
3438 HKL * layouts = (HKL *) alloca (num_layouts * sizeof (HKL));
3439 Lisp_Object obj = Qnil;
3441 if (GetKeyboardLayoutList (num_layouts, layouts) == num_layouts)
3443 while (--num_layouts >= 0)
3445 HKL kl = layouts[num_layouts];
3447 obj = Fcons (Fcons (make_number (LOWORD (kl)),
3448 make_number (HIWORD (kl))),
3449 obj);
3453 return obj;
3457 DEFUN ("w32-get-keyboard-layout", Fw32_get_keyboard_layout,
3458 Sw32_get_keyboard_layout, 0, 0, 0,
3459 doc: /* Return current Windows keyboard language and layout.
3460 The return value is the cons of the language id and the layout id. */)
3461 (void)
3463 HKL kl = GetKeyboardLayout (dwWindowsThreadId);
3465 return Fcons (make_number (LOWORD (kl)),
3466 make_number (HIWORD (kl)));
3470 DEFUN ("w32-set-keyboard-layout", Fw32_set_keyboard_layout,
3471 Sw32_set_keyboard_layout, 1, 1, 0,
3472 doc: /* Make LAYOUT be the current keyboard layout for Emacs.
3473 The keyboard layout setting affects interpretation of keyboard input.
3474 If successful, the new layout id is returned, otherwise nil. */)
3475 (Lisp_Object layout)
3477 HKL kl;
3479 CHECK_CONS (layout);
3480 CHECK_NUMBER_CAR (layout);
3481 CHECK_NUMBER_CDR (layout);
3483 kl = (HKL) (UINT_PTR) ((XINT (XCAR (layout)) & 0xffff)
3484 | (XINT (XCDR (layout)) << 16));
3486 /* Synchronize layout with input thread. */
3487 if (dwWindowsThreadId)
3489 if (PostThreadMessage (dwWindowsThreadId, WM_EMACS_SETKEYBOARDLAYOUT,
3490 (WPARAM) kl, 0))
3492 MSG msg;
3493 GetMessage (&msg, NULL, WM_EMACS_DONE, WM_EMACS_DONE);
3495 if (msg.wParam == 0)
3496 return Qnil;
3499 else if (!ActivateKeyboardLayout (kl, 0))
3500 return Qnil;
3502 return Fw32_get_keyboard_layout ();
3505 /* Two variables to interface between get_lcid and the EnumLocales
3506 callback function below. */
3507 #ifndef LOCALE_NAME_MAX_LENGTH
3508 # define LOCALE_NAME_MAX_LENGTH 85
3509 #endif
3510 static LCID found_lcid;
3511 static char lname[3 * LOCALE_NAME_MAX_LENGTH + 1 + 1];
3513 /* Callback function for EnumLocales. */
3514 static BOOL CALLBACK
3515 get_lcid_callback (LPTSTR locale_num_str)
3517 char *endp;
3518 char locval[2 * LOCALE_NAME_MAX_LENGTH + 1 + 1];
3519 LCID try_lcid = strtoul (locale_num_str, &endp, 16);
3521 if (GetLocaleInfo (try_lcid, LOCALE_SABBREVLANGNAME,
3522 locval, LOCALE_NAME_MAX_LENGTH))
3524 size_t locval_len;
3526 /* This is for when they only specify the language, as in "ENU". */
3527 if (stricmp (locval, lname) == 0)
3529 found_lcid = try_lcid;
3530 return FALSE;
3532 locval_len = strlen (locval);
3533 strcpy (locval + locval_len, "_");
3534 if (GetLocaleInfo (try_lcid, LOCALE_SABBREVCTRYNAME,
3535 locval + locval_len + 1, LOCALE_NAME_MAX_LENGTH))
3537 locval_len = strlen (locval);
3538 if (strnicmp (locval, lname, locval_len) == 0
3539 && (lname[locval_len] == '.'
3540 || lname[locval_len] == '\0'))
3542 found_lcid = try_lcid;
3543 return FALSE;
3547 return TRUE;
3550 /* Return the Locale ID (LCID) number given the locale's name, a
3551 string, in LOCALE_NAME. This works by enumerating all the locales
3552 supported by the system, until we find one whose name matches
3553 LOCALE_NAME. */
3554 static LCID
3555 get_lcid (const char *locale_name)
3557 /* A simple cache. */
3558 static LCID last_lcid;
3559 static char last_locale[1000];
3561 /* The code below is not thread-safe, as it uses static variables.
3562 But this function is called only from the Lisp thread. */
3563 if (last_lcid > 0 && strcmp (locale_name, last_locale) == 0)
3564 return last_lcid;
3566 strncpy (lname, locale_name, sizeof (lname) - 1);
3567 lname[sizeof (lname) - 1] = '\0';
3568 found_lcid = 0;
3569 EnumSystemLocales (get_lcid_callback, LCID_SUPPORTED);
3570 if (found_lcid > 0)
3572 last_lcid = found_lcid;
3573 strcpy (last_locale, locale_name);
3575 return found_lcid;
3578 #ifndef _NLSCMPERROR
3579 # define _NLSCMPERROR INT_MAX
3580 #endif
3581 #ifndef LINGUISTIC_IGNORECASE
3582 # define LINGUISTIC_IGNORECASE 0x00000010
3583 #endif
3585 typedef int (WINAPI *CompareStringW_Proc)
3586 (LCID, DWORD, LPCWSTR, int, LPCWSTR, int);
3589 w32_compare_strings (const char *s1, const char *s2, char *locname,
3590 int ignore_case)
3592 LCID lcid = GetThreadLocale ();
3593 wchar_t *string1_w, *string2_w;
3594 int val, needed;
3595 static CompareStringW_Proc pCompareStringW;
3596 DWORD flags = 0;
3598 USE_SAFE_ALLOCA;
3600 /* The LCID machinery doesn't seem to support the "C" locale, so we
3601 need to do that by hand. */
3602 if (locname
3603 && ((locname[0] == 'C' && (locname[1] == '\0' || locname[1] == '.'))
3604 || strcmp (locname, "POSIX") == 0))
3605 return (ignore_case ? stricmp (s1, s2) : strcmp (s1, s2));
3607 if (!g_b_init_compare_string_w)
3609 if (os_subtype == OS_9X)
3611 pCompareStringW =
3612 (CompareStringW_Proc) GetProcAddress (LoadLibrary ("Unicows.dll"),
3613 "CompareStringW");
3614 if (!pCompareStringW)
3616 errno = EINVAL;
3617 /* This return value is compatible with wcscoll and
3618 other MS CRT functions. */
3619 return _NLSCMPERROR;
3622 else
3623 pCompareStringW = CompareStringW;
3625 g_b_init_compare_string_w = 1;
3628 needed = pMultiByteToWideChar (CP_UTF8, MB_ERR_INVALID_CHARS, s1, -1, NULL, 0);
3629 if (needed > 0)
3631 SAFE_NALLOCA (string1_w, 1, needed + 1);
3632 pMultiByteToWideChar (CP_UTF8, MB_ERR_INVALID_CHARS, s1, -1,
3633 string1_w, needed);
3635 else
3637 errno = EINVAL;
3638 return _NLSCMPERROR;
3641 needed = pMultiByteToWideChar (CP_UTF8, MB_ERR_INVALID_CHARS, s2, -1, NULL, 0);
3642 if (needed > 0)
3644 SAFE_NALLOCA (string2_w, 1, needed + 1);
3645 pMultiByteToWideChar (CP_UTF8, MB_ERR_INVALID_CHARS, s2, -1,
3646 string2_w, needed);
3648 else
3650 SAFE_FREE ();
3651 errno = EINVAL;
3652 return _NLSCMPERROR;
3655 if (locname)
3657 /* Convert locale name string to LCID. We don't want to use
3658 LocaleNameToLCID because (a) it is only available since
3659 Vista, and (b) it doesn't accept locale names returned by
3660 'setlocale' and 'GetLocaleInfo'. */
3661 LCID new_lcid = get_lcid (locname);
3663 if (new_lcid > 0)
3664 lcid = new_lcid;
3665 else
3666 error ("Invalid locale %s: Invalid argument", locname);
3669 if (ignore_case)
3671 /* NORM_IGNORECASE ignores any tertiary distinction, not just
3672 case variants. LINGUISTIC_IGNORECASE is more selective, and
3673 is sensitive to the locale's language, but it is not
3674 available before Vista. */
3675 if (w32_major_version >= 6)
3676 flags |= LINGUISTIC_IGNORECASE;
3677 else
3678 flags |= NORM_IGNORECASE;
3680 /* This approximates what glibc collation functions do when the
3681 locale's codeset is UTF-8. */
3682 if (!NILP (Vw32_collate_ignore_punctuation))
3683 flags |= NORM_IGNORESYMBOLS;
3684 val = pCompareStringW (lcid, flags, string1_w, -1, string2_w, -1);
3685 SAFE_FREE ();
3686 if (!val)
3688 errno = EINVAL;
3689 return _NLSCMPERROR;
3691 return val - 2;
3695 void
3696 syms_of_ntproc (void)
3698 DEFSYM (Qhigh, "high");
3699 DEFSYM (Qlow, "low");
3700 DEFSYM (Qcygwin, "cygwin");
3701 DEFSYM (Qmsys, "msys");
3702 DEFSYM (Qw32_native, "w32-native");
3704 defsubr (&Sw32_has_winsock);
3705 defsubr (&Sw32_unload_winsock);
3707 defsubr (&Sw32_short_file_name);
3708 defsubr (&Sw32_long_file_name);
3709 defsubr (&Sw32_set_process_priority);
3710 defsubr (&Sw32_application_type);
3711 defsubr (&Sw32_get_locale_info);
3712 defsubr (&Sw32_get_current_locale_id);
3713 defsubr (&Sw32_get_default_locale_id);
3714 defsubr (&Sw32_get_valid_locale_ids);
3715 defsubr (&Sw32_set_current_locale);
3717 defsubr (&Sw32_get_console_codepage);
3718 defsubr (&Sw32_set_console_codepage);
3719 defsubr (&Sw32_get_console_output_codepage);
3720 defsubr (&Sw32_set_console_output_codepage);
3721 defsubr (&Sw32_get_valid_codepages);
3722 defsubr (&Sw32_get_codepage_charset);
3724 defsubr (&Sw32_get_valid_keyboard_layouts);
3725 defsubr (&Sw32_get_keyboard_layout);
3726 defsubr (&Sw32_set_keyboard_layout);
3728 DEFVAR_LISP ("w32-quote-process-args", Vw32_quote_process_args,
3729 doc: /* Non-nil enables quoting of process arguments to ensure correct parsing.
3730 Because Windows does not directly pass argv arrays to child processes,
3731 programs have to reconstruct the argv array by parsing the command
3732 line string. For an argument to contain a space, it must be enclosed
3733 in double quotes or it will be parsed as multiple arguments.
3735 If the value is a character, that character will be used to escape any
3736 quote characters that appear, otherwise a suitable escape character
3737 will be chosen based on the type of the program. */);
3738 Vw32_quote_process_args = Qt;
3740 DEFVAR_LISP ("w32-start-process-show-window",
3741 Vw32_start_process_show_window,
3742 doc: /* When nil, new child processes hide their windows.
3743 When non-nil, they show their window in the method of their choice.
3744 This variable doesn't affect GUI applications, which will never be hidden. */);
3745 Vw32_start_process_show_window = Qnil;
3747 DEFVAR_LISP ("w32-start-process-share-console",
3748 Vw32_start_process_share_console,
3749 doc: /* When nil, new child processes are given a new console.
3750 When non-nil, they share the Emacs console; this has the limitation of
3751 allowing only one DOS subprocess to run at a time (whether started directly
3752 or indirectly by Emacs), and preventing Emacs from cleanly terminating the
3753 subprocess group, but may allow Emacs to interrupt a subprocess that doesn't
3754 otherwise respond to interrupts from Emacs. */);
3755 Vw32_start_process_share_console = Qnil;
3757 DEFVAR_LISP ("w32-start-process-inherit-error-mode",
3758 Vw32_start_process_inherit_error_mode,
3759 doc: /* When nil, new child processes revert to the default error mode.
3760 When non-nil, they inherit their error mode setting from Emacs, which stops
3761 them blocking when trying to access unmounted drives etc. */);
3762 Vw32_start_process_inherit_error_mode = Qt;
3764 DEFVAR_INT ("w32-pipe-read-delay", w32_pipe_read_delay,
3765 doc: /* Forced delay before reading subprocess output.
3766 This is done to improve the buffering of subprocess output, by
3767 avoiding the inefficiency of frequently reading small amounts of data.
3769 If positive, the value is the number of milliseconds to sleep before
3770 reading the subprocess output. If negative, the magnitude is the number
3771 of time slices to wait (effectively boosting the priority of the child
3772 process temporarily). A value of zero disables waiting entirely. */);
3773 w32_pipe_read_delay = 50;
3775 DEFVAR_INT ("w32-pipe-buffer-size", w32_pipe_buffer_size,
3776 doc: /* Size of buffer for pipes created to communicate with subprocesses.
3777 The size is in bytes, and must be non-negative. The default is zero,
3778 which lets the OS use its default size, usually 4KB (4096 bytes).
3779 Any negative value means to use the default value of zero. */);
3780 w32_pipe_buffer_size = 0;
3782 DEFVAR_LISP ("w32-downcase-file-names", Vw32_downcase_file_names,
3783 doc: /* Non-nil means convert all-upper case file names to lower case.
3784 This applies when performing completions and file name expansion.
3785 Note that the value of this setting also affects remote file names,
3786 so you probably don't want to set to non-nil if you use case-sensitive
3787 filesystems via ange-ftp. */);
3788 Vw32_downcase_file_names = Qnil;
3790 #if 0
3791 DEFVAR_LISP ("w32-generate-fake-inodes", Vw32_generate_fake_inodes,
3792 doc: /* Non-nil means attempt to fake realistic inode values.
3793 This works by hashing the truename of files, and should detect
3794 aliasing between long and short (8.3 DOS) names, but can have
3795 false positives because of hash collisions. Note that determining
3796 the truename of a file can be slow. */);
3797 Vw32_generate_fake_inodes = Qnil;
3798 #endif
3800 DEFVAR_LISP ("w32-get-true-file-attributes", Vw32_get_true_file_attributes,
3801 doc: /* Non-nil means determine accurate file attributes in `file-attributes'.
3802 This option controls whether to issue additional system calls to determine
3803 accurate link counts, file type, and ownership information. It is more
3804 useful for files on NTFS volumes, where hard links and file security are
3805 supported, than on volumes of the FAT family.
3807 Without these system calls, link count will always be reported as 1 and file
3808 ownership will be attributed to the current user.
3809 The default value `local' means only issue these system calls for files
3810 on local fixed drives. A value of nil means never issue them.
3811 Any other non-nil value means do this even on remote and removable drives
3812 where the performance impact may be noticeable even on modern hardware. */);
3813 Vw32_get_true_file_attributes = Qlocal;
3815 DEFVAR_LISP ("w32-collate-ignore-punctuation",
3816 Vw32_collate_ignore_punctuation,
3817 doc: /* Non-nil causes string collation functions ignore punctuation on MS-Windows.
3818 On Posix platforms, `string-collate-lessp' and `string-collate-equalp'
3819 ignore punctuation characters when they compare strings, if the
3820 locale's codeset is UTF-8, as in \"en_US.UTF-8\". Binding this option
3821 to a non-nil value will achieve a similar effect on MS-Windows, where
3822 locales with UTF-8 codeset are not supported.
3824 Note that setting this to non-nil will also ignore blanks and symbols
3825 in the strings. So do NOT use this option when comparing file names
3826 for equality, only when you need to sort them. */);
3827 Vw32_collate_ignore_punctuation = Qnil;
3829 staticpro (&Vw32_valid_locale_ids);
3830 staticpro (&Vw32_valid_codepages);
3832 /* end of w32proc.c */