1 /* Process support for GNU Emacs on the Microsoft Windows API.
2 Copyright (C) 1992, 1995, 1999-2012 Free Software Foundation, Inc.
4 This file is part of GNU Emacs.
6 GNU Emacs is free software: you can redistribute it and/or modify
7 it under the terms of the GNU General Public License as published by
8 the Free Software Foundation, either version 3 of the License, or
9 (at your option) any later version.
11 GNU Emacs is distributed in the hope that it will be useful,
12 but WITHOUT ANY WARRANTY; without even the implied warranty of
13 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14 GNU General Public License for more details.
16 You should have received a copy of the GNU General Public License
17 along with GNU Emacs. If not, see <http://www.gnu.org/licenses/>. */
20 Drew Bliss Oct 14, 1993
21 Adapted from alarm.c by Tim Fleehart
33 /* must include CRT headers *before* config.h */
44 /* This definition is missing from mingw32 headers. */
45 extern BOOL WINAPI
IsValidLocale (LCID
, DWORD
);
48 #ifdef HAVE_LANGINFO_CODESET
55 #include "w32common.h"
60 #include "syssignal.h"
62 #include "dispextern.h" /* for xstrcasecmp */
65 #define RVA_TO_PTR(var,section,filedata) \
66 ((void *)((section)->PointerToRawData \
67 + ((DWORD_PTR)(var) - (section)->VirtualAddress) \
68 + (filedata).file_base))
70 Lisp_Object Qhigh
, Qlow
;
72 /* Signal handlers...SIG_DFL == 0 so this is initialized correctly. */
73 static signal_handler sig_handlers
[NSIG
];
75 static sigset_t sig_mask
;
77 static CRITICAL_SECTION crit_sig
;
79 /* Improve on the CRT 'signal' implementation so that we could record
80 the SIGCHLD handler and fake interval timers. */
82 sys_signal (int sig
, signal_handler handler
)
86 /* SIGCHLD is needed for supporting subprocesses, see sys_kill
87 below. SIGALRM and SIGPROF are used by setitimer. All the
88 others are the only ones supported by the MS runtime. */
89 if (!(sig
== SIGCHLD
|| sig
== SIGSEGV
|| sig
== SIGILL
90 || sig
== SIGFPE
|| sig
== SIGABRT
|| sig
== SIGTERM
91 || sig
== SIGALRM
|| sig
== SIGPROF
))
96 old
= sig_handlers
[sig
];
97 /* SIGABRT is treated specially because w32.c installs term_ntproc
98 as its handler, so we don't want to override that afterwards.
99 Aborting Emacs works specially anyway: either by calling
100 emacs_abort directly or through terminate_due_to_signal, which
101 calls emacs_abort through emacs_raise. */
102 if (!(sig
== SIGABRT
&& old
== term_ntproc
))
104 sig_handlers
[sig
] = handler
;
105 if (!(sig
== SIGCHLD
|| sig
== SIGALRM
|| sig
== SIGPROF
))
106 signal (sig
, handler
);
111 /* Emulate sigaction. */
113 sigaction (int sig
, const struct sigaction
*act
, struct sigaction
*oact
)
115 signal_handler old
= SIG_DFL
;
119 old
= sys_signal (sig
, act
->sa_handler
);
121 old
= sig_handlers
[sig
];
130 oact
->sa_handler
= old
;
132 oact
->sa_mask
= empty_mask
;
137 /* Emulate signal sets and blocking of signals used by timers. */
140 sigemptyset (sigset_t
*set
)
147 sigaddset (sigset_t
*set
, int signo
)
154 if (signo
< 0 || signo
>= NSIG
)
160 *set
|= (1U << signo
);
166 sigfillset (sigset_t
*set
)
179 sigprocmask (int how
, const sigset_t
*set
, sigset_t
*oset
)
181 if (!(how
== SIG_BLOCK
|| how
== SIG_UNBLOCK
|| how
== SIG_SETMASK
))
202 /* FIXME: Catch signals that are blocked and reissue them when
203 they are unblocked. Important for SIGALRM and SIGPROF only. */
212 pthread_sigmask (int how
, const sigset_t
*set
, sigset_t
*oset
)
214 if (sigprocmask (how
, set
, oset
) == -1)
220 sigismember (const sigset_t
*set
, int signo
)
222 if (signo
< 0 || signo
>= NSIG
)
227 if (signo
> sizeof (*set
) * BITS_PER_CHAR
)
230 return (*set
& (1U << signo
)) != 0;
246 setpgid (pid_t pid
, pid_t pgid
)
257 /* Emulations of interval timers.
259 Limitations: only ITIMER_REAL and ITIMER_PROF are supported.
261 Implementation: a separate thread is started for each timer type,
262 the thread calls the appropriate signal handler when the timer
263 expires, after stopping the thread which installed the timer. */
266 volatile ULONGLONG expire
;
267 volatile ULONGLONG reload
;
268 volatile int terminate
;
270 HANDLE caller_thread
;
274 static ULONGLONG ticks_now
;
275 static struct itimer_data real_itimer
, prof_itimer
;
276 static ULONGLONG clocks_min
;
277 /* If non-zero, itimers are disabled. Used during shutdown, when we
278 delete the critical sections used by the timer threads. */
279 static int disable_itimers
;
281 static CRITICAL_SECTION crit_real
, crit_prof
;
283 /* GetThreadTimes is not available on Windows 9X and possibly also on 2K. */
284 typedef BOOL (WINAPI
*GetThreadTimes_Proc
) (
286 LPFILETIME lpCreationTime
,
287 LPFILETIME lpExitTime
,
288 LPFILETIME lpKernelTime
,
289 LPFILETIME lpUserTime
);
291 static GetThreadTimes_Proc s_pfn_Get_Thread_Times
;
293 #define MAX_SINGLE_SLEEP 30
294 #define TIMER_TICKS_PER_SEC 1000
296 /* Return a suitable time value, in 1-ms units, for THREAD, a handle
297 to a thread. If THREAD is NULL or an invalid handle, return the
298 current wall-clock time since January 1, 1601 (UTC). Otherwise,
299 return the sum of kernel and user times used by THREAD since it was
300 created, plus its creation time. */
302 w32_get_timer_time (HANDLE thread
)
305 int use_system_time
= 1;
306 /* The functions below return times in 100-ns units. */
307 const int tscale
= 10 * TIMER_TICKS_PER_SEC
;
309 if (thread
&& thread
!= INVALID_HANDLE_VALUE
310 && s_pfn_Get_Thread_Times
!= NULL
)
312 FILETIME creation_ftime
, exit_ftime
, kernel_ftime
, user_ftime
;
313 ULARGE_INTEGER temp_creation
, temp_kernel
, temp_user
;
315 if (s_pfn_Get_Thread_Times (thread
, &creation_ftime
, &exit_ftime
,
316 &kernel_ftime
, &user_ftime
))
319 temp_creation
.LowPart
= creation_ftime
.dwLowDateTime
;
320 temp_creation
.HighPart
= creation_ftime
.dwHighDateTime
;
321 temp_kernel
.LowPart
= kernel_ftime
.dwLowDateTime
;
322 temp_kernel
.HighPart
= kernel_ftime
.dwHighDateTime
;
323 temp_user
.LowPart
= user_ftime
.dwLowDateTime
;
324 temp_user
.HighPart
= user_ftime
.dwHighDateTime
;
326 temp_creation
.QuadPart
/ tscale
+ temp_kernel
.QuadPart
/ tscale
327 + temp_user
.QuadPart
/ tscale
;
330 DebPrint (("GetThreadTimes failed with error code %lu\n",
336 FILETIME current_ftime
;
339 GetSystemTimeAsFileTime (¤t_ftime
);
341 temp
.LowPart
= current_ftime
.dwLowDateTime
;
342 temp
.HighPart
= current_ftime
.dwHighDateTime
;
344 retval
= temp
.QuadPart
/ tscale
;
350 /* Thread function for a timer thread. */
352 timer_loop (LPVOID arg
)
354 struct itimer_data
*itimer
= (struct itimer_data
*)arg
;
355 int which
= itimer
->type
;
356 int sig
= (which
== ITIMER_REAL
) ? SIGALRM
: SIGPROF
;
357 CRITICAL_SECTION
*crit
= (which
== ITIMER_REAL
) ? &crit_real
: &crit_prof
;
358 const DWORD max_sleep
= MAX_SINGLE_SLEEP
* 1000 / TIMER_TICKS_PER_SEC
;
359 HANDLE hth
= (which
== ITIMER_REAL
) ? NULL
: itimer
->caller_thread
;
364 signal_handler handler
;
365 ULONGLONG now
, expire
, reload
;
367 /* Load new values if requested by setitimer. */
368 EnterCriticalSection (crit
);
369 expire
= itimer
->expire
;
370 reload
= itimer
->reload
;
371 LeaveCriticalSection (crit
);
372 if (itimer
->terminate
)
382 if (expire
> (now
= w32_get_timer_time (hth
)))
383 sleep_time
= expire
- now
;
386 /* Don't sleep too long at a time, to be able to see the
387 termination flag without too long a delay. */
388 while (sleep_time
> max_sleep
)
390 if (itimer
->terminate
)
393 EnterCriticalSection (crit
);
394 expire
= itimer
->expire
;
395 LeaveCriticalSection (crit
);
397 (expire
> (now
= w32_get_timer_time (hth
))) ? expire
- now
: 0;
399 if (itimer
->terminate
)
403 Sleep (sleep_time
* 1000 / TIMER_TICKS_PER_SEC
);
404 /* Always sleep past the expiration time, to make sure we
405 never call the handler _before_ the expiration time,
406 always slightly after it. Sleep(5) makes sure we don't
407 hog the CPU by calling 'w32_get_timer_time' with high
408 frequency, and also let other threads work. */
409 while (w32_get_timer_time (hth
) < expire
)
413 EnterCriticalSection (crit
);
414 expire
= itimer
->expire
;
415 LeaveCriticalSection (crit
);
420 handler
= sig_handlers
[sig
];
421 if (!(handler
== SIG_DFL
|| handler
== SIG_IGN
|| handler
== SIG_ERR
)
422 /* FIXME: Don't ignore masked signals. Instead, record that
423 they happened and reissue them when the signal is
425 && !sigismember (&sig_mask
, sig
)
426 /* Simulate masking of SIGALRM and SIGPROF when processing
428 && !fatal_error_in_progress
429 && itimer
->caller_thread
)
431 /* Simulate a signal delivered to the thread which installed
432 the timer, by suspending that thread while the handler
434 HANDLE th
= itimer
->caller_thread
;
435 DWORD result
= SuspendThread (th
);
437 if (result
== (DWORD
)-1)
444 /* Update expiration time and loop. */
445 EnterCriticalSection (crit
);
446 expire
= itimer
->expire
;
449 LeaveCriticalSection (crit
);
452 reload
= itimer
->reload
;
455 now
= w32_get_timer_time (hth
);
458 ULONGLONG lag
= now
- expire
;
460 /* If we missed some opportunities (presumably while
461 sleeping or while the signal handler ran), skip
464 expire
= now
- (lag
% reload
);
470 expire
= 0; /* become idle */
471 itimer
->expire
= expire
;
472 LeaveCriticalSection (crit
);
478 stop_timer_thread (int which
)
480 struct itimer_data
*itimer
=
481 (which
== ITIMER_REAL
) ? &real_itimer
: &prof_itimer
;
483 DWORD err
, exit_code
= 255;
486 /* Signal the thread that it should terminate. */
487 itimer
->terminate
= 1;
489 if (itimer
->timer_thread
== NULL
)
492 /* Wait for the timer thread to terminate voluntarily, then kill it
493 if it doesn't. This loop waits twice more than the maximum
494 amount of time a timer thread sleeps, see above. */
495 for (i
= 0; i
< MAX_SINGLE_SLEEP
/ 5; i
++)
497 if (!((status
= GetExitCodeThread (itimer
->timer_thread
, &exit_code
))
498 && exit_code
== STILL_ACTIVE
))
502 if ((status
== FALSE
&& (err
= GetLastError ()) == ERROR_INVALID_HANDLE
)
503 || exit_code
== STILL_ACTIVE
)
505 if (!(status
== FALSE
&& err
== ERROR_INVALID_HANDLE
))
506 TerminateThread (itimer
->timer_thread
, 0);
510 CloseHandle (itimer
->timer_thread
);
511 itimer
->timer_thread
= NULL
;
512 if (itimer
->caller_thread
)
514 CloseHandle (itimer
->caller_thread
);
515 itimer
->caller_thread
= NULL
;
519 /* This is called at shutdown time from term_ntproc. */
523 if (real_itimer
.timer_thread
)
524 stop_timer_thread (ITIMER_REAL
);
525 if (prof_itimer
.timer_thread
)
526 stop_timer_thread (ITIMER_PROF
);
528 /* We are going to delete the critical sections, so timers cannot
532 DeleteCriticalSection (&crit_real
);
533 DeleteCriticalSection (&crit_prof
);
534 DeleteCriticalSection (&crit_sig
);
537 /* This is called at initialization time from init_ntproc. */
541 /* GetThreadTimes is not available on all versions of Windows, so
542 need to probe for its availability dynamically, and call it
543 through a pointer. */
544 s_pfn_Get_Thread_Times
= NULL
; /* in case dumped Emacs comes with a value */
545 if (os_subtype
!= OS_9X
)
546 s_pfn_Get_Thread_Times
=
547 (GetThreadTimes_Proc
)GetProcAddress (GetModuleHandle ("kernel32.dll"),
550 /* Make sure we start with zeroed out itimer structures, since
551 dumping may have left there traces of threads long dead. */
552 memset (&real_itimer
, 0, sizeof real_itimer
);
553 memset (&prof_itimer
, 0, sizeof prof_itimer
);
555 InitializeCriticalSection (&crit_real
);
556 InitializeCriticalSection (&crit_prof
);
557 InitializeCriticalSection (&crit_sig
);
563 start_timer_thread (int which
)
567 struct itimer_data
*itimer
=
568 (which
== ITIMER_REAL
) ? &real_itimer
: &prof_itimer
;
570 if (itimer
->timer_thread
571 && GetExitCodeThread (itimer
->timer_thread
, &exit_code
)
572 && exit_code
== STILL_ACTIVE
)
575 /* Clean up after possibly exited thread. */
576 if (itimer
->timer_thread
)
578 CloseHandle (itimer
->timer_thread
);
579 itimer
->timer_thread
= NULL
;
581 if (itimer
->caller_thread
)
583 CloseHandle (itimer
->caller_thread
);
584 itimer
->caller_thread
= NULL
;
587 /* Start a new thread. */
588 if (!DuplicateHandle (GetCurrentProcess (), GetCurrentThread (),
589 GetCurrentProcess (), &th
, 0, FALSE
,
590 DUPLICATE_SAME_ACCESS
))
595 itimer
->terminate
= 0;
596 itimer
->type
= which
;
597 itimer
->caller_thread
= th
;
598 /* Request that no more than 64KB of stack be reserved for this
599 thread, to avoid reserving too much memory, which would get in
600 the way of threads we start to wait for subprocesses. See also
602 itimer
->timer_thread
= CreateThread (NULL
, 64 * 1024, timer_loop
,
603 (void *)itimer
, 0x00010000, NULL
);
605 if (!itimer
->timer_thread
)
607 CloseHandle (itimer
->caller_thread
);
608 itimer
->caller_thread
= NULL
;
613 /* This is needed to make sure that the timer thread running for
614 profiling gets CPU as soon as the Sleep call terminates. */
615 if (which
== ITIMER_PROF
)
616 SetThreadPriority (itimer
->timer_thread
, THREAD_PRIORITY_TIME_CRITICAL
);
621 /* Most of the code of getitimer and setitimer (but not of their
622 subroutines) was shamelessly stolen from itimer.c in the DJGPP
623 library, see www.delorie.com/djgpp. */
625 getitimer (int which
, struct itimerval
*value
)
627 volatile ULONGLONG
*t_expire
;
628 volatile ULONGLONG
*t_reload
;
629 ULONGLONG expire
, reload
;
631 CRITICAL_SECTION
*crit
;
632 struct itimer_data
*itimer
;
643 if (which
!= ITIMER_REAL
&& which
!= ITIMER_PROF
)
649 itimer
= (which
== ITIMER_REAL
) ? &real_itimer
: &prof_itimer
;
651 ticks_now
= w32_get_timer_time ((which
== ITIMER_REAL
)
653 : GetCurrentThread ());
655 t_expire
= &itimer
->expire
;
656 t_reload
= &itimer
->reload
;
657 crit
= (which
== ITIMER_REAL
) ? &crit_real
: &crit_prof
;
659 EnterCriticalSection (crit
);
662 LeaveCriticalSection (crit
);
667 value
->it_value
.tv_sec
= expire
/ TIMER_TICKS_PER_SEC
;
669 (expire
% TIMER_TICKS_PER_SEC
) * (__int64
)1000000 / TIMER_TICKS_PER_SEC
;
670 value
->it_value
.tv_usec
= usecs
;
671 value
->it_interval
.tv_sec
= reload
/ TIMER_TICKS_PER_SEC
;
673 (reload
% TIMER_TICKS_PER_SEC
) * (__int64
)1000000 / TIMER_TICKS_PER_SEC
;
674 value
->it_interval
.tv_usec
= usecs
;
680 setitimer(int which
, struct itimerval
*value
, struct itimerval
*ovalue
)
682 volatile ULONGLONG
*t_expire
, *t_reload
;
683 ULONGLONG expire
, reload
, expire_old
, reload_old
;
685 CRITICAL_SECTION
*crit
;
686 struct itimerval tem
, *ptem
;
691 /* Posix systems expect timer values smaller than the resolution of
692 the system clock be rounded up to the clock resolution. First
693 time we are called, measure the clock tick resolution. */
698 for (t1
= w32_get_timer_time (NULL
);
699 (t2
= w32_get_timer_time (NULL
)) == t1
; )
701 clocks_min
= t2
- t1
;
709 if (getitimer (which
, ptem
)) /* also sets ticks_now */
710 return -1; /* errno already set */
713 (which
== ITIMER_REAL
) ? &real_itimer
.expire
: &prof_itimer
.expire
;
715 (which
== ITIMER_REAL
) ? &real_itimer
.reload
: &prof_itimer
.reload
;
717 crit
= (which
== ITIMER_REAL
) ? &crit_real
: &crit_prof
;
720 || (value
->it_value
.tv_sec
== 0 && value
->it_value
.tv_usec
== 0))
722 EnterCriticalSection (crit
);
723 /* Disable the timer. */
726 LeaveCriticalSection (crit
);
730 reload
= value
->it_interval
.tv_sec
* TIMER_TICKS_PER_SEC
;
732 usecs
= value
->it_interval
.tv_usec
;
733 if (value
->it_interval
.tv_sec
== 0
734 && usecs
&& usecs
* TIMER_TICKS_PER_SEC
< clocks_min
* 1000000)
738 usecs
*= TIMER_TICKS_PER_SEC
;
739 reload
+= usecs
/ 1000000;
742 expire
= value
->it_value
.tv_sec
* TIMER_TICKS_PER_SEC
;
743 usecs
= value
->it_value
.tv_usec
;
744 if (value
->it_value
.tv_sec
== 0
745 && usecs
* TIMER_TICKS_PER_SEC
< clocks_min
* 1000000)
749 usecs
*= TIMER_TICKS_PER_SEC
;
750 expire
+= usecs
/ 1000000;
755 EnterCriticalSection (crit
);
756 expire_old
= *t_expire
;
757 reload_old
= *t_reload
;
758 if (!(expire
== expire_old
&& reload
== reload_old
))
763 LeaveCriticalSection (crit
);
765 return start_timer_thread (which
);
771 #ifdef HAVE_SETITIMER
772 struct itimerval new_values
, old_values
;
774 new_values
.it_value
.tv_sec
= seconds
;
775 new_values
.it_value
.tv_usec
= 0;
776 new_values
.it_interval
.tv_sec
= new_values
.it_interval
.tv_usec
= 0;
778 if (setitimer (ITIMER_REAL
, &new_values
, &old_values
) < 0)
780 return old_values
.it_value
.tv_sec
;
786 /* Defined in <process.h> which conflicts with the local copy */
789 /* Child process management list. */
790 int child_proc_count
= 0;
791 child_process child_procs
[ MAX_CHILDREN
];
793 static DWORD WINAPI
reader_thread (void *arg
);
795 /* Find an unused process slot. */
802 for (cp
= child_procs
+ (child_proc_count
-1); cp
>= child_procs
; cp
--)
803 if (!CHILD_ACTIVE (cp
))
805 if (child_proc_count
== MAX_CHILDREN
)
807 cp
= &child_procs
[child_proc_count
++];
810 memset (cp
, 0, sizeof (*cp
));
813 cp
->procinfo
.hProcess
= NULL
;
814 cp
->status
= STATUS_READ_ERROR
;
816 /* use manual reset event so that select() will function properly */
817 cp
->char_avail
= CreateEvent (NULL
, TRUE
, FALSE
, NULL
);
820 cp
->char_consumed
= CreateEvent (NULL
, FALSE
, FALSE
, NULL
);
821 if (cp
->char_consumed
)
823 /* The 0x00010000 flag is STACK_SIZE_PARAM_IS_A_RESERVATION.
824 It means that the 64K stack we are requesting in the 2nd
825 argument is how much memory should be reserved for the
826 stack. If we don't use this flag, the memory requested
827 by the 2nd argument is the amount actually _committed_,
828 but Windows reserves 8MB of memory for each thread's
829 stack. (The 8MB figure comes from the -stack
830 command-line argument we pass to the linker when building
831 Emacs, but that's because we need a large stack for
832 Emacs's main thread.) Since we request 2GB of reserved
833 memory at startup (see w32heap.c), which is close to the
834 maximum memory available for a 32-bit process on Windows,
835 the 8MB reservation for each thread causes failures in
836 starting subprocesses, because we create a thread running
837 reader_thread for each subprocess. As 8MB of stack is
838 way too much for reader_thread, forcing Windows to
839 reserve less wins the day. */
840 cp
->thrd
= CreateThread (NULL
, 64 * 1024, reader_thread
, cp
,
851 delete_child (child_process
*cp
)
855 /* Should not be deleting a child that is still needed. */
856 for (i
= 0; i
< MAXDESC
; i
++)
857 if (fd_info
[i
].cp
== cp
)
860 if (!CHILD_ACTIVE (cp
))
863 /* reap thread if necessary */
868 if (GetExitCodeThread (cp
->thrd
, &rc
) && rc
== STILL_ACTIVE
)
870 /* let the thread exit cleanly if possible */
871 cp
->status
= STATUS_READ_ERROR
;
872 SetEvent (cp
->char_consumed
);
874 /* We used to forcibly terminate the thread here, but it
875 is normally unnecessary, and in abnormal cases, the worst that
876 will happen is we have an extra idle thread hanging around
877 waiting for the zombie process. */
878 if (WaitForSingleObject (cp
->thrd
, 1000) != WAIT_OBJECT_0
)
880 DebPrint (("delete_child.WaitForSingleObject (thread) failed "
881 "with %lu for fd %ld\n", GetLastError (), cp
->fd
));
882 TerminateThread (cp
->thrd
, 0);
886 CloseHandle (cp
->thrd
);
891 CloseHandle (cp
->char_avail
);
892 cp
->char_avail
= NULL
;
894 if (cp
->char_consumed
)
896 CloseHandle (cp
->char_consumed
);
897 cp
->char_consumed
= NULL
;
900 /* update child_proc_count (highest numbered slot in use plus one) */
901 if (cp
== child_procs
+ child_proc_count
- 1)
903 for (i
= child_proc_count
-1; i
>= 0; i
--)
904 if (CHILD_ACTIVE (&child_procs
[i
]))
906 child_proc_count
= i
+ 1;
911 child_proc_count
= 0;
914 /* Find a child by pid. */
915 static child_process
*
916 find_child_pid (DWORD pid
)
920 for (cp
= child_procs
+ (child_proc_count
-1); cp
>= child_procs
; cp
--)
921 if (CHILD_ACTIVE (cp
) && pid
== cp
->pid
)
927 /* Thread proc for child process and socket reader threads. Each thread
928 is normally blocked until woken by select() to check for input by
929 reading one char. When the read completes, char_avail is signaled
930 to wake up the select emulator and the thread blocks itself again. */
932 reader_thread (void *arg
)
937 cp
= (child_process
*)arg
;
939 /* We have to wait for the go-ahead before we can start */
941 || WaitForSingleObject (cp
->char_consumed
, INFINITE
) != WAIT_OBJECT_0
949 if (fd_info
[cp
->fd
].flags
& FILE_LISTEN
)
950 rc
= _sys_wait_accept (cp
->fd
);
952 rc
= _sys_read_ahead (cp
->fd
);
954 /* The name char_avail is a misnomer - it really just means the
955 read-ahead has completed, whether successfully or not. */
956 if (!SetEvent (cp
->char_avail
))
958 DebPrint (("reader_thread.SetEvent failed with %lu for fd %ld\n",
959 GetLastError (), cp
->fd
));
963 if (rc
== STATUS_READ_ERROR
)
966 /* If the read died, the child has died so let the thread die */
967 if (rc
== STATUS_READ_FAILED
)
970 /* Wait until our input is acknowledged before reading again */
971 if (WaitForSingleObject (cp
->char_consumed
, INFINITE
) != WAIT_OBJECT_0
)
973 DebPrint (("reader_thread.WaitForSingleObject failed with "
974 "%lu for fd %ld\n", GetLastError (), cp
->fd
));
981 /* To avoid Emacs changing directory, we just record here the directory
982 the new process should start in. This is set just before calling
983 sys_spawnve, and is not generally valid at any other time. */
984 static char * process_dir
;
987 create_child (char *exe
, char *cmdline
, char *env
, int is_gui_app
,
988 int * pPid
, child_process
*cp
)
991 SECURITY_ATTRIBUTES sec_attrs
;
993 SECURITY_DESCRIPTOR sec_desc
;
996 char dir
[ MAXPATHLEN
];
998 if (cp
== NULL
) emacs_abort ();
1000 memset (&start
, 0, sizeof (start
));
1001 start
.cb
= sizeof (start
);
1004 if (NILP (Vw32_start_process_show_window
) && !is_gui_app
)
1005 start
.dwFlags
= STARTF_USESTDHANDLES
| STARTF_USESHOWWINDOW
;
1007 start
.dwFlags
= STARTF_USESTDHANDLES
;
1008 start
.wShowWindow
= SW_HIDE
;
1010 start
.hStdInput
= GetStdHandle (STD_INPUT_HANDLE
);
1011 start
.hStdOutput
= GetStdHandle (STD_OUTPUT_HANDLE
);
1012 start
.hStdError
= GetStdHandle (STD_ERROR_HANDLE
);
1013 #endif /* HAVE_NTGUI */
1016 /* Explicitly specify no security */
1017 if (!InitializeSecurityDescriptor (&sec_desc
, SECURITY_DESCRIPTOR_REVISION
))
1019 if (!SetSecurityDescriptorDacl (&sec_desc
, TRUE
, NULL
, FALSE
))
1022 sec_attrs
.nLength
= sizeof (sec_attrs
);
1023 sec_attrs
.lpSecurityDescriptor
= NULL
/* &sec_desc */;
1024 sec_attrs
.bInheritHandle
= FALSE
;
1026 strcpy (dir
, process_dir
);
1027 unixtodos_filename (dir
);
1029 flags
= (!NILP (Vw32_start_process_share_console
)
1030 ? CREATE_NEW_PROCESS_GROUP
1031 : CREATE_NEW_CONSOLE
);
1032 if (NILP (Vw32_start_process_inherit_error_mode
))
1033 flags
|= CREATE_DEFAULT_ERROR_MODE
;
1034 if (!CreateProcess (exe
, cmdline
, &sec_attrs
, NULL
, TRUE
,
1035 flags
, env
, dir
, &start
, &cp
->procinfo
))
1038 cp
->pid
= (int) cp
->procinfo
.dwProcessId
;
1040 /* Hack for Windows 95, which assigns large (ie negative) pids */
1049 DebPrint (("create_child.CreateProcess failed: %ld\n", GetLastError ()););
1053 /* create_child doesn't know what emacs' file handle will be for waiting
1054 on output from the child, so we need to make this additional call
1055 to register the handle with the process
1056 This way the select emulator knows how to match file handles with
1057 entries in child_procs. */
1059 register_child (int pid
, int fd
)
1063 cp
= find_child_pid (pid
);
1066 DebPrint (("register_child unable to find pid %lu\n", pid
));
1071 DebPrint (("register_child registered fd %d with pid %lu\n", fd
, pid
));
1076 /* thread is initially blocked until select is called; set status so
1077 that select will release thread */
1078 cp
->status
= STATUS_READ_ACKNOWLEDGED
;
1080 /* attach child_process to fd_info */
1081 if (fd_info
[fd
].cp
!= NULL
)
1083 DebPrint (("register_child: fd_info[%d] apparently in use!\n", fd
));
1087 fd_info
[fd
].cp
= cp
;
1090 /* When a process dies its pipe will break so the reader thread will
1091 signal failure to the select emulator.
1092 The select emulator then calls this routine to clean up.
1093 Since the thread signaled failure we can assume it is exiting. */
1095 reap_subprocess (child_process
*cp
)
1097 if (cp
->procinfo
.hProcess
)
1099 /* Reap the process */
1101 /* Process should have already died before we are called. */
1102 if (WaitForSingleObject (cp
->procinfo
.hProcess
, 0) != WAIT_OBJECT_0
)
1103 DebPrint (("reap_subprocess: child fpr fd %d has not died yet!", cp
->fd
));
1105 CloseHandle (cp
->procinfo
.hProcess
);
1106 cp
->procinfo
.hProcess
= NULL
;
1107 CloseHandle (cp
->procinfo
.hThread
);
1108 cp
->procinfo
.hThread
= NULL
;
1111 /* For asynchronous children, the child_proc resources will be freed
1112 when the last pipe read descriptor is closed; for synchronous
1113 children, we must explicitly free the resources now because
1114 register_child has not been called. */
1119 /* Wait for a child process specified by PID, or for any of our
1120 existing child processes (if PID is nonpositive) to die. When it
1121 does, close its handle. Return the pid of the process that died
1122 and fill in STATUS if non-NULL. */
1125 waitpid (pid_t pid
, int *status
, int options
)
1127 DWORD active
, retval
;
1129 child_process
*cp
, *cps
[MAX_CHILDREN
];
1130 HANDLE wait_hnd
[MAX_CHILDREN
];
1132 int dont_wait
= (options
& WNOHANG
) != 0;
1135 /* According to Posix:
1137 PID = -1 means status is requested for any child process.
1139 PID > 0 means status is requested for a single child process
1142 PID = 0 means status is requested for any child process whose
1143 process group ID is equal to that of the calling process. But
1144 since Windows has only a limited support for process groups (only
1145 for console processes and only for the purposes of passing
1146 Ctrl-BREAK signal to them), and since we have no documented way
1147 of determining whether a given process belongs to our group, we
1150 PID < -1 means status is requested for any child process whose
1151 process group ID is equal to the absolute value of PID. Again,
1152 since we don't support process groups, we treat that as -1. */
1157 /* We are requested to wait for a specific child. */
1158 for (cp
= child_procs
+ (child_proc_count
-1); cp
>= child_procs
; cp
--)
1160 /* Some child_procs might be sockets; ignore them. Also
1161 ignore subprocesses whose output is not yet completely
1163 if (CHILD_ACTIVE (cp
)
1164 && cp
->procinfo
.hProcess
1173 if (cp
->fd
< 0 || (fd_info
[cp
->fd
].flags
& FILE_AT_EOF
) != 0)
1175 wait_hnd
[nh
] = cp
->procinfo
.hProcess
;
1181 /* PID specifies our subprocess, but its status is not
1188 /* No such child process, or nothing to wait for, so fail. */
1195 for (cp
= child_procs
+ (child_proc_count
-1); cp
>= child_procs
; cp
--)
1197 if (CHILD_ACTIVE (cp
)
1198 && cp
->procinfo
.hProcess
1199 && (cp
->fd
< 0 || (fd_info
[cp
->fd
].flags
& FILE_AT_EOF
) != 0))
1201 wait_hnd
[nh
] = cp
->procinfo
.hProcess
;
1208 /* Nothing to wait on, so fail. */
1217 timeout_ms
= 1000; /* check for quit about once a second. */
1222 active
= WaitForMultipleObjects (nh
, wait_hnd
, FALSE
, timeout_ms
);
1223 } while (active
== WAIT_TIMEOUT
);
1225 if (active
== WAIT_FAILED
)
1230 else if (active
>= WAIT_OBJECT_0
1231 && active
< WAIT_OBJECT_0
+MAXIMUM_WAIT_OBJECTS
)
1233 active
-= WAIT_OBJECT_0
;
1235 else if (active
>= WAIT_ABANDONED_0
1236 && active
< WAIT_ABANDONED_0
+MAXIMUM_WAIT_OBJECTS
)
1238 active
-= WAIT_ABANDONED_0
;
1243 if (!GetExitCodeProcess (wait_hnd
[active
], &retval
))
1245 DebPrint (("Wait.GetExitCodeProcess failed with %lu\n",
1249 if (retval
== STILL_ACTIVE
)
1251 /* Should never happen. */
1252 DebPrint (("Wait.WaitForMultipleObjects returned an active process\n"));
1253 if (pid
> 0 && dont_wait
)
1259 /* Massage the exit code from the process to match the format expected
1260 by the WIFSTOPPED et al macros in syswait.h. Only WIFSIGNALED and
1261 WIFEXITED are supported; WIFSTOPPED doesn't make sense under NT. */
1263 if (retval
== STATUS_CONTROL_C_EXIT
)
1268 if (pid
> 0 && active
!= 0)
1273 DebPrint (("Wait signaled with process pid %d\n", cp
->pid
));
1278 reap_subprocess (cp
);
1283 /* Old versions of w32api headers don't have separate 32-bit and
1284 64-bit defines, but the one they have matches the 32-bit variety. */
1285 #ifndef IMAGE_NT_OPTIONAL_HDR32_MAGIC
1286 # define IMAGE_NT_OPTIONAL_HDR32_MAGIC IMAGE_NT_OPTIONAL_HDR_MAGIC
1287 # define IMAGE_OPTIONAL_HEADER32 IMAGE_OPTIONAL_HEADER
1291 w32_executable_type (char * filename
,
1293 int * is_cygnus_app
,
1296 file_data executable
;
1299 /* Default values in case we can't tell for sure. */
1300 *is_dos_app
= FALSE
;
1301 *is_cygnus_app
= FALSE
;
1302 *is_gui_app
= FALSE
;
1304 if (!open_input_file (&executable
, filename
))
1307 p
= strrchr (filename
, '.');
1309 /* We can only identify DOS .com programs from the extension. */
1310 if (p
&& xstrcasecmp (p
, ".com") == 0)
1312 else if (p
&& (xstrcasecmp (p
, ".bat") == 0
1313 || xstrcasecmp (p
, ".cmd") == 0))
1315 /* A DOS shell script - it appears that CreateProcess is happy to
1316 accept this (somewhat surprisingly); presumably it looks at
1317 COMSPEC to determine what executable to actually invoke.
1318 Therefore, we have to do the same here as well. */
1319 /* Actually, I think it uses the program association for that
1320 extension, which is defined in the registry. */
1321 p
= egetenv ("COMSPEC");
1323 w32_executable_type (p
, is_dos_app
, is_cygnus_app
, is_gui_app
);
1327 /* Look for DOS .exe signature - if found, we must also check that
1328 it isn't really a 16- or 32-bit Windows exe, since both formats
1329 start with a DOS program stub. Note that 16-bit Windows
1330 executables use the OS/2 1.x format. */
1332 IMAGE_DOS_HEADER
* dos_header
;
1333 IMAGE_NT_HEADERS
* nt_header
;
1335 dos_header
= (PIMAGE_DOS_HEADER
) executable
.file_base
;
1336 if (dos_header
->e_magic
!= IMAGE_DOS_SIGNATURE
)
1339 nt_header
= (PIMAGE_NT_HEADERS
) ((unsigned char *) dos_header
+ dos_header
->e_lfanew
);
1341 if ((char *) nt_header
> (char *) dos_header
+ executable
.size
)
1343 /* Some dos headers (pkunzip) have bogus e_lfanew fields. */
1346 else if (nt_header
->Signature
!= IMAGE_NT_SIGNATURE
1347 && LOWORD (nt_header
->Signature
) != IMAGE_OS2_SIGNATURE
)
1351 else if (nt_header
->Signature
== IMAGE_NT_SIGNATURE
)
1353 IMAGE_DATA_DIRECTORY
*data_dir
= NULL
;
1354 if (nt_header
->OptionalHeader
.Magic
== IMAGE_NT_OPTIONAL_HDR32_MAGIC
)
1356 /* Ensure we are using the 32 bit structure. */
1357 IMAGE_OPTIONAL_HEADER32
*opt
1358 = (IMAGE_OPTIONAL_HEADER32
*) &(nt_header
->OptionalHeader
);
1359 data_dir
= opt
->DataDirectory
;
1360 *is_gui_app
= (opt
->Subsystem
== IMAGE_SUBSYSTEM_WINDOWS_GUI
);
1362 /* MingW 3.12 has the required 64 bit structs, but in case older
1363 versions don't, only check 64 bit exes if we know how. */
1364 #ifdef IMAGE_NT_OPTIONAL_HDR64_MAGIC
1365 else if (nt_header
->OptionalHeader
.Magic
1366 == IMAGE_NT_OPTIONAL_HDR64_MAGIC
)
1368 IMAGE_OPTIONAL_HEADER64
*opt
1369 = (IMAGE_OPTIONAL_HEADER64
*) &(nt_header
->OptionalHeader
);
1370 data_dir
= opt
->DataDirectory
;
1371 *is_gui_app
= (opt
->Subsystem
== IMAGE_SUBSYSTEM_WINDOWS_GUI
);
1376 /* Look for cygwin.dll in DLL import list. */
1377 IMAGE_DATA_DIRECTORY import_dir
=
1378 data_dir
[IMAGE_DIRECTORY_ENTRY_IMPORT
];
1379 IMAGE_IMPORT_DESCRIPTOR
* imports
;
1380 IMAGE_SECTION_HEADER
* section
;
1382 section
= rva_to_section (import_dir
.VirtualAddress
, nt_header
);
1383 imports
= RVA_TO_PTR (import_dir
.VirtualAddress
, section
,
1386 for ( ; imports
->Name
; imports
++)
1388 char * dllname
= RVA_TO_PTR (imports
->Name
, section
,
1391 /* The exact name of the cygwin dll has changed with
1392 various releases, but hopefully this will be reasonably
1394 if (strncmp (dllname
, "cygwin", 6) == 0)
1396 *is_cygnus_app
= TRUE
;
1405 close_file_data (&executable
);
1409 compare_env (const void *strp1
, const void *strp2
)
1411 const char *str1
= *(const char **)strp1
, *str2
= *(const char **)strp2
;
1413 while (*str1
&& *str2
&& *str1
!= '=' && *str2
!= '=')
1415 /* Sort order in command.com/cmd.exe is based on uppercasing
1416 names, so do the same here. */
1417 if (toupper (*str1
) > toupper (*str2
))
1419 else if (toupper (*str1
) < toupper (*str2
))
1424 if (*str1
== '=' && *str2
== '=')
1426 else if (*str1
== '=')
1433 merge_and_sort_env (char **envp1
, char **envp2
, char **new_envp
)
1435 char **optr
, **nptr
;
1447 num
+= optr
- envp2
;
1449 qsort (new_envp
, num
, sizeof (char *), compare_env
);
1454 /* When a new child process is created we need to register it in our list,
1455 so intercept spawn requests. */
1457 sys_spawnve (int mode
, char *cmdname
, char **argv
, char **envp
)
1459 Lisp_Object program
, full
;
1460 char *cmdline
, *env
, *parg
, **targ
;
1464 int is_dos_app
, is_cygnus_app
, is_gui_app
;
1467 /* We pass our process ID to our children by setting up an environment
1468 variable in their environment. */
1469 char ppid_env_var_buffer
[64];
1470 char *extra_env
[] = {ppid_env_var_buffer
, NULL
};
1471 /* These are the characters that cause an argument to need quoting.
1472 Arguments with whitespace characters need quoting to prevent the
1473 argument being split into two or more. Arguments with wildcards
1474 are also quoted, for consistency with posix platforms, where wildcards
1475 are not expanded if we run the program directly without a shell.
1476 Some extra whitespace characters need quoting in Cygwin programs,
1477 so this list is conditionally modified below. */
1478 char *sepchars
= " \t*?";
1480 /* We don't care about the other modes */
1481 if (mode
!= _P_NOWAIT
)
1487 /* Handle executable names without an executable suffix. */
1488 program
= build_string (cmdname
);
1489 if (NILP (Ffile_executable_p (program
)))
1491 struct gcpro gcpro1
;
1495 openp (Vexec_path
, program
, Vexec_suffixes
, &full
, make_number (X_OK
));
1505 /* make sure argv[0] and cmdname are both in DOS format */
1506 cmdname
= SDATA (program
);
1507 unixtodos_filename (cmdname
);
1510 /* Determine whether program is a 16-bit DOS executable, or a 32-bit Windows
1511 executable that is implicitly linked to the Cygnus dll (implying it
1512 was compiled with the Cygnus GNU toolchain and hence relies on
1513 cygwin.dll to parse the command line - we use this to decide how to
1514 escape quote chars in command line args that must be quoted).
1516 Also determine whether it is a GUI app, so that we don't hide its
1517 initial window unless specifically requested. */
1518 w32_executable_type (cmdname
, &is_dos_app
, &is_cygnus_app
, &is_gui_app
);
1520 /* On Windows 95, if cmdname is a DOS app, we invoke a helper
1521 application to start it by specifying the helper app as cmdname,
1522 while leaving the real app name as argv[0]. */
1525 cmdname
= alloca (MAXPATHLEN
);
1526 if (egetenv ("CMDPROXY"))
1527 strcpy (cmdname
, egetenv ("CMDPROXY"));
1530 strcpy (cmdname
, SDATA (Vinvocation_directory
));
1531 strcat (cmdname
, "cmdproxy.exe");
1533 unixtodos_filename (cmdname
);
1536 /* we have to do some conjuring here to put argv and envp into the
1537 form CreateProcess wants... argv needs to be a space separated/null
1538 terminated list of parameters, and envp is a null
1539 separated/double-null terminated list of parameters.
1541 Additionally, zero-length args and args containing whitespace or
1542 quote chars need to be wrapped in double quotes - for this to work,
1543 embedded quotes need to be escaped as well. The aim is to ensure
1544 the child process reconstructs the argv array we start with
1545 exactly, so we treat quotes at the beginning and end of arguments
1548 The w32 GNU-based library from Cygnus doubles quotes to escape
1549 them, while MSVC uses backslash for escaping. (Actually the MSVC
1550 startup code does attempt to recognize doubled quotes and accept
1551 them, but gets it wrong and ends up requiring three quotes to get a
1552 single embedded quote!) So by default we decide whether to use
1553 quote or backslash as the escape character based on whether the
1554 binary is apparently a Cygnus compiled app.
1556 Note that using backslash to escape embedded quotes requires
1557 additional special handling if an embedded quote is already
1558 preceded by backslash, or if an arg requiring quoting ends with
1559 backslash. In such cases, the run of escape characters needs to be
1560 doubled. For consistency, we apply this special handling as long
1561 as the escape character is not quote.
1563 Since we have no idea how large argv and envp are likely to be we
1564 figure out list lengths on the fly and allocate them. */
1566 if (!NILP (Vw32_quote_process_args
))
1569 /* Override escape char by binding w32-quote-process-args to
1570 desired character, or use t for auto-selection. */
1571 if (INTEGERP (Vw32_quote_process_args
))
1572 escape_char
= XINT (Vw32_quote_process_args
);
1574 escape_char
= is_cygnus_app
? '"' : '\\';
1577 /* Cygwin apps needs quoting a bit more often. */
1578 if (escape_char
== '"')
1579 sepchars
= "\r\n\t\f '";
1587 int need_quotes
= 0;
1588 int escape_char_run
= 0;
1594 if (escape_char
== '"' && *p
== '\\')
1595 /* If it's a Cygwin app, \ needs to be escaped. */
1599 /* allow for embedded quotes to be escaped */
1602 /* handle the case where the embedded quote is already escaped */
1603 if (escape_char_run
> 0)
1605 /* To preserve the arg exactly, we need to double the
1606 preceding escape characters (plus adding one to
1607 escape the quote character itself). */
1608 arglen
+= escape_char_run
;
1611 else if (strchr (sepchars
, *p
) != NULL
)
1616 if (*p
== escape_char
&& escape_char
!= '"')
1619 escape_char_run
= 0;
1624 /* handle the case where the arg ends with an escape char - we
1625 must not let the enclosing quote be escaped. */
1626 if (escape_char_run
> 0)
1627 arglen
+= escape_char_run
;
1629 arglen
+= strlen (*targ
++) + 1;
1631 cmdline
= alloca (arglen
);
1637 int need_quotes
= 0;
1645 if ((strchr (sepchars
, *p
) != NULL
) || *p
== '"')
1650 int escape_char_run
= 0;
1656 last
= p
+ strlen (p
) - 1;
1659 /* This version does not escape quotes if they occur at the
1660 beginning or end of the arg - this could lead to incorrect
1661 behavior when the arg itself represents a command line
1662 containing quoted args. I believe this was originally done
1663 as a hack to make some things work, before
1664 `w32-quote-process-args' was added. */
1667 if (*p
== '"' && p
> first
&& p
< last
)
1668 *parg
++ = escape_char
; /* escape embedded quotes */
1676 /* double preceding escape chars if any */
1677 while (escape_char_run
> 0)
1679 *parg
++ = escape_char
;
1682 /* escape all quote chars, even at beginning or end */
1683 *parg
++ = escape_char
;
1685 else if (escape_char
== '"' && *p
== '\\')
1689 if (*p
== escape_char
&& escape_char
!= '"')
1692 escape_char_run
= 0;
1694 /* double escape chars before enclosing quote */
1695 while (escape_char_run
> 0)
1697 *parg
++ = escape_char
;
1705 strcpy (parg
, *targ
);
1706 parg
+= strlen (*targ
);
1716 numenv
= 1; /* for end null */
1719 arglen
+= strlen (*targ
++) + 1;
1722 /* extra env vars... */
1723 sprintf (ppid_env_var_buffer
, "EM_PARENT_PROCESS_ID=%lu",
1724 GetCurrentProcessId ());
1725 arglen
+= strlen (ppid_env_var_buffer
) + 1;
1728 /* merge env passed in and extra env into one, and sort it. */
1729 targ
= (char **) alloca (numenv
* sizeof (char *));
1730 merge_and_sort_env (envp
, extra_env
, targ
);
1732 /* concatenate env entries. */
1733 env
= alloca (arglen
);
1737 strcpy (parg
, *targ
);
1738 parg
+= strlen (*targ
++);
1751 /* Now create the process. */
1752 if (!create_child (cmdname
, cmdline
, env
, is_gui_app
, &pid
, cp
))
1762 /* Emulate the select call
1763 Wait for available input on any of the given rfds, or timeout if
1764 a timeout is given and no input is detected
1765 wfds and efds are not supported and must be NULL.
1767 For simplicity, we detect the death of child processes here and
1768 synchronously call the SIGCHLD handler. Since it is possible for
1769 children to be created without a corresponding pipe handle from which
1770 to read output, we wait separately on the process handles as well as
1771 the char_avail events for each process pipe. We only call
1772 wait/reap_process when the process actually terminates.
1774 To reduce the number of places in which Emacs can be hung such that
1775 C-g is not able to interrupt it, we always wait on interrupt_handle
1776 (which is signaled by the input thread when C-g is detected). If we
1777 detect that we were woken up by C-g, we return -1 with errno set to
1778 EINTR as on Unix. */
1780 /* From w32console.c */
1781 extern HANDLE keyboard_handle
;
1783 /* From w32xfns.c */
1784 extern HANDLE interrupt_handle
;
1786 /* From process.c */
1787 extern int proc_buffered_char
[];
1790 sys_select (int nfds
, SELECT_TYPE
*rfds
, SELECT_TYPE
*wfds
, SELECT_TYPE
*efds
,
1791 EMACS_TIME
*timeout
, void *ignored
)
1794 DWORD timeout_ms
, start_time
;
1797 child_process
*cp
, *cps
[MAX_CHILDREN
];
1798 HANDLE wait_hnd
[MAXDESC
+ MAX_CHILDREN
];
1799 int fdindex
[MAXDESC
]; /* mapping from wait handles back to descriptors */
1802 timeout
? (timeout
->tv_sec
* 1000 + timeout
->tv_nsec
/ 1000000) : INFINITE
;
1804 /* If the descriptor sets are NULL but timeout isn't, then just Sleep. */
1805 if (rfds
== NULL
&& wfds
== NULL
&& efds
== NULL
&& timeout
!= NULL
)
1811 /* Otherwise, we only handle rfds, so fail otherwise. */
1812 if (rfds
== NULL
|| wfds
!= NULL
|| efds
!= NULL
)
1822 /* Always wait on interrupt_handle, to detect C-g (quit). */
1823 wait_hnd
[0] = interrupt_handle
;
1826 /* Build a list of pipe handles to wait on. */
1828 for (i
= 0; i
< nfds
; i
++)
1829 if (FD_ISSET (i
, &orfds
))
1833 if (keyboard_handle
)
1835 /* Handle stdin specially */
1836 wait_hnd
[nh
] = keyboard_handle
;
1841 /* Check for any emacs-generated input in the queue since
1842 it won't be detected in the wait */
1843 if (detect_input_pending ())
1851 /* Child process and socket input */
1855 int current_status
= cp
->status
;
1857 if (current_status
== STATUS_READ_ACKNOWLEDGED
)
1859 /* Tell reader thread which file handle to use. */
1861 /* Wake up the reader thread for this process */
1862 cp
->status
= STATUS_READ_READY
;
1863 if (!SetEvent (cp
->char_consumed
))
1864 DebPrint (("nt_select.SetEvent failed with "
1865 "%lu for fd %ld\n", GetLastError (), i
));
1868 #ifdef CHECK_INTERLOCK
1869 /* slightly crude cross-checking of interlock between threads */
1871 current_status
= cp
->status
;
1872 if (WaitForSingleObject (cp
->char_avail
, 0) == WAIT_OBJECT_0
)
1874 /* char_avail has been signaled, so status (which may
1875 have changed) should indicate read has completed
1876 but has not been acknowledged. */
1877 current_status
= cp
->status
;
1878 if (current_status
!= STATUS_READ_SUCCEEDED
1879 && current_status
!= STATUS_READ_FAILED
)
1880 DebPrint (("char_avail set, but read not completed: status %d\n",
1885 /* char_avail has not been signaled, so status should
1886 indicate that read is in progress; small possibility
1887 that read has completed but event wasn't yet signaled
1888 when we tested it (because a context switch occurred
1889 or if running on separate CPUs). */
1890 if (current_status
!= STATUS_READ_READY
1891 && current_status
!= STATUS_READ_IN_PROGRESS
1892 && current_status
!= STATUS_READ_SUCCEEDED
1893 && current_status
!= STATUS_READ_FAILED
)
1894 DebPrint (("char_avail reset, but read status is bad: %d\n",
1898 wait_hnd
[nh
] = cp
->char_avail
;
1900 if (!wait_hnd
[nh
]) emacs_abort ();
1903 DebPrint (("select waiting on child %d fd %d\n",
1904 cp
-child_procs
, i
));
1909 /* Unable to find something to wait on for this fd, skip */
1911 /* Note that this is not a fatal error, and can in fact
1912 happen in unusual circumstances. Specifically, if
1913 sys_spawnve fails, eg. because the program doesn't
1914 exist, and debug-on-error is t so Fsignal invokes a
1915 nested input loop, then the process output pipe is
1916 still included in input_wait_mask with no child_proc
1917 associated with it. (It is removed when the debugger
1918 exits the nested input loop and the error is thrown.) */
1920 DebPrint (("sys_select: fd %ld is invalid! ignoring\n", i
));
1926 /* Add handles of child processes. */
1928 for (cp
= child_procs
+ (child_proc_count
-1); cp
>= child_procs
; cp
--)
1929 /* Some child_procs might be sockets; ignore them. Also some
1930 children may have died already, but we haven't finished reading
1931 the process output; ignore them too. */
1932 if (CHILD_ACTIVE (cp
) && cp
->procinfo
.hProcess
1934 || (fd_info
[cp
->fd
].flags
& FILE_SEND_SIGCHLD
) == 0
1935 || (fd_info
[cp
->fd
].flags
& FILE_AT_EOF
) != 0)
1938 wait_hnd
[nh
+ nc
] = cp
->procinfo
.hProcess
;
1943 /* Nothing to look for, so we didn't find anything */
1951 start_time
= GetTickCount ();
1953 /* Wait for input or child death to be signaled. If user input is
1954 allowed, then also accept window messages. */
1955 if (FD_ISSET (0, &orfds
))
1956 active
= MsgWaitForMultipleObjects (nh
+ nc
, wait_hnd
, FALSE
, timeout_ms
,
1959 active
= WaitForMultipleObjects (nh
+ nc
, wait_hnd
, FALSE
, timeout_ms
);
1961 if (active
== WAIT_FAILED
)
1963 DebPrint (("select.WaitForMultipleObjects (%d, %lu) failed with %lu\n",
1964 nh
+ nc
, timeout_ms
, GetLastError ()));
1965 /* don't return EBADF - this causes wait_reading_process_output to
1966 abort; WAIT_FAILED is returned when single-stepping under
1967 Windows 95 after switching thread focus in debugger, and
1968 possibly at other times. */
1972 else if (active
== WAIT_TIMEOUT
)
1976 else if (active
>= WAIT_OBJECT_0
1977 && active
< WAIT_OBJECT_0
+MAXIMUM_WAIT_OBJECTS
)
1979 active
-= WAIT_OBJECT_0
;
1981 else if (active
>= WAIT_ABANDONED_0
1982 && active
< WAIT_ABANDONED_0
+MAXIMUM_WAIT_OBJECTS
)
1984 active
-= WAIT_ABANDONED_0
;
1989 /* Loop over all handles after active (now officially documented as
1990 being the first signaled handle in the array). We do this to
1991 ensure fairness, so that all channels with data available will be
1992 processed - otherwise higher numbered channels could be starved. */
1995 if (active
== nh
+ nc
)
1997 /* There are messages in the lisp thread's queue; we must
1998 drain the queue now to ensure they are processed promptly,
1999 because if we don't do so, we will not be woken again until
2000 further messages arrive.
2002 NB. If ever we allow window message procedures to callback
2003 into lisp, we will need to ensure messages are dispatched
2004 at a safe time for lisp code to be run (*), and we may also
2005 want to provide some hooks in the dispatch loop to cater
2006 for modeless dialogs created by lisp (ie. to register
2007 window handles to pass to IsDialogMessage).
2009 (*) Note that MsgWaitForMultipleObjects above is an
2010 internal dispatch point for messages that are sent to
2011 windows created by this thread. */
2012 drain_message_queue ();
2014 else if (active
>= nh
)
2016 cp
= cps
[active
- nh
];
2018 /* We cannot always signal SIGCHLD immediately; if we have not
2019 finished reading the process output, we must delay sending
2020 SIGCHLD until we do. */
2022 if (cp
->fd
>= 0 && (fd_info
[cp
->fd
].flags
& FILE_AT_EOF
) == 0)
2023 fd_info
[cp
->fd
].flags
|= FILE_SEND_SIGCHLD
;
2024 /* SIG_DFL for SIGCHLD is ignore */
2025 else if (sig_handlers
[SIGCHLD
] != SIG_DFL
&&
2026 sig_handlers
[SIGCHLD
] != SIG_IGN
)
2029 DebPrint (("select calling SIGCHLD handler for pid %d\n",
2032 sig_handlers
[SIGCHLD
] (SIGCHLD
);
2035 else if (fdindex
[active
] == -1)
2037 /* Quit (C-g) was detected. */
2041 else if (fdindex
[active
] == 0)
2043 /* Keyboard input available */
2049 /* must be a socket or pipe - read ahead should have
2050 completed, either succeeding or failing. */
2051 FD_SET (fdindex
[active
], rfds
);
2055 /* Even though wait_reading_process_output only reads from at most
2056 one channel, we must process all channels here so that we reap
2057 all children that have died. */
2058 while (++active
< nh
+ nc
)
2059 if (WaitForSingleObject (wait_hnd
[active
], 0) == WAIT_OBJECT_0
)
2061 } while (active
< nh
+ nc
);
2063 /* If no input has arrived and timeout hasn't expired, wait again. */
2066 DWORD elapsed
= GetTickCount () - start_time
;
2068 if (timeout_ms
> elapsed
) /* INFINITE is MAX_UINT */
2070 if (timeout_ms
!= INFINITE
)
2071 timeout_ms
-= elapsed
;
2072 goto count_children
;
2079 /* Substitute for certain kill () operations */
2081 static BOOL CALLBACK
2082 find_child_console (HWND hwnd
, LPARAM arg
)
2084 child_process
* cp
= (child_process
*) arg
;
2088 thread_id
= GetWindowThreadProcessId (hwnd
, &process_id
);
2089 if (process_id
== cp
->procinfo
.dwProcessId
)
2091 char window_class
[32];
2093 GetClassName (hwnd
, window_class
, sizeof (window_class
));
2094 if (strcmp (window_class
,
2095 (os_subtype
== OS_9X
)
2097 : "ConsoleWindowClass") == 0)
2107 /* Emulate 'kill', but only for other processes. */
2109 sys_kill (int pid
, int sig
)
2113 int need_to_free
= 0;
2116 /* Only handle signals that will result in the process dying */
2117 if (sig
!= SIGINT
&& sig
!= SIGKILL
&& sig
!= SIGQUIT
&& sig
!= SIGHUP
)
2123 cp
= find_child_pid (pid
);
2126 /* We were passed a PID of something other than our subprocess.
2127 If that is our own PID, we will send to ourself a message to
2128 close the selected frame, which does not necessarily
2129 terminates Emacs. But then we are not supposed to call
2130 sys_kill with our own PID. */
2131 proc_hand
= OpenProcess (PROCESS_TERMINATE
, 0, pid
);
2132 if (proc_hand
== NULL
)
2141 proc_hand
= cp
->procinfo
.hProcess
;
2142 pid
= cp
->procinfo
.dwProcessId
;
2144 /* Try to locate console window for process. */
2145 EnumWindows (find_child_console
, (LPARAM
) cp
);
2148 if (sig
== SIGINT
|| sig
== SIGQUIT
)
2150 if (NILP (Vw32_start_process_share_console
) && cp
&& cp
->hwnd
)
2152 BYTE control_scan_code
= (BYTE
) MapVirtualKey (VK_CONTROL
, 0);
2153 /* Fake Ctrl-C for SIGINT, and Ctrl-Break for SIGQUIT. */
2154 BYTE vk_break_code
= (sig
== SIGINT
) ? 'C' : VK_CANCEL
;
2155 BYTE break_scan_code
= (BYTE
) MapVirtualKey (vk_break_code
, 0);
2156 HWND foreground_window
;
2158 if (break_scan_code
== 0)
2160 /* Fake Ctrl-C for SIGQUIT if we can't manage Ctrl-Break. */
2161 vk_break_code
= 'C';
2162 break_scan_code
= (BYTE
) MapVirtualKey (vk_break_code
, 0);
2165 foreground_window
= GetForegroundWindow ();
2166 if (foreground_window
)
2168 /* NT 5.0, and apparently also Windows 98, will not allow
2169 a Window to be set to foreground directly without the
2170 user's involvement. The workaround is to attach
2171 ourselves to the thread that owns the foreground
2172 window, since that is the only thread that can set the
2173 foreground window. */
2174 DWORD foreground_thread
, child_thread
;
2176 GetWindowThreadProcessId (foreground_window
, NULL
);
2177 if (foreground_thread
== GetCurrentThreadId ()
2178 || !AttachThreadInput (GetCurrentThreadId (),
2179 foreground_thread
, TRUE
))
2180 foreground_thread
= 0;
2182 child_thread
= GetWindowThreadProcessId (cp
->hwnd
, NULL
);
2183 if (child_thread
== GetCurrentThreadId ()
2184 || !AttachThreadInput (GetCurrentThreadId (),
2185 child_thread
, TRUE
))
2188 /* Set the foreground window to the child. */
2189 if (SetForegroundWindow (cp
->hwnd
))
2191 /* Generate keystrokes as if user had typed Ctrl-Break or
2193 keybd_event (VK_CONTROL
, control_scan_code
, 0, 0);
2194 keybd_event (vk_break_code
, break_scan_code
,
2195 (vk_break_code
== 'C' ? 0 : KEYEVENTF_EXTENDEDKEY
), 0);
2196 keybd_event (vk_break_code
, break_scan_code
,
2197 (vk_break_code
== 'C' ? 0 : KEYEVENTF_EXTENDEDKEY
)
2198 | KEYEVENTF_KEYUP
, 0);
2199 keybd_event (VK_CONTROL
, control_scan_code
,
2200 KEYEVENTF_KEYUP
, 0);
2202 /* Sleep for a bit to give time for Emacs frame to respond
2203 to focus change events (if Emacs was active app). */
2206 SetForegroundWindow (foreground_window
);
2208 /* Detach from the foreground and child threads now that
2209 the foreground switching is over. */
2210 if (foreground_thread
)
2211 AttachThreadInput (GetCurrentThreadId (),
2212 foreground_thread
, FALSE
);
2214 AttachThreadInput (GetCurrentThreadId (),
2215 child_thread
, FALSE
);
2218 /* Ctrl-Break is NT equivalent of SIGINT. */
2219 else if (!GenerateConsoleCtrlEvent (CTRL_BREAK_EVENT
, pid
))
2221 DebPrint (("sys_kill.GenerateConsoleCtrlEvent return %d "
2222 "for pid %lu\n", GetLastError (), pid
));
2229 if (NILP (Vw32_start_process_share_console
) && cp
&& cp
->hwnd
)
2232 if (os_subtype
== OS_9X
)
2235 Another possibility is to try terminating the VDM out-right by
2236 calling the Shell VxD (id 0x17) V86 interface, function #4
2237 "SHELL_Destroy_VM", ie.
2243 First need to determine the current VM handle, and then arrange for
2244 the shellapi call to be made from the system vm (by using
2245 Switch_VM_and_callback).
2247 Could try to invoke DestroyVM through CallVxD.
2251 /* On Windows 95, posting WM_QUIT causes the 16-bit subsystem
2252 to hang when cmdproxy is used in conjunction with
2253 command.com for an interactive shell. Posting
2254 WM_CLOSE pops up a dialog that, when Yes is selected,
2255 does the same thing. TerminateProcess is also less
2256 than ideal in that subprocesses tend to stick around
2257 until the machine is shutdown, but at least it
2258 doesn't freeze the 16-bit subsystem. */
2259 PostMessage (cp
->hwnd
, WM_QUIT
, 0xff, 0);
2261 if (!TerminateProcess (proc_hand
, 0xff))
2263 DebPrint (("sys_kill.TerminateProcess returned %d "
2264 "for pid %lu\n", GetLastError (), pid
));
2271 PostMessage (cp
->hwnd
, WM_CLOSE
, 0, 0);
2273 /* Kill the process. On W32 this doesn't kill child processes
2274 so it doesn't work very well for shells which is why it's not
2275 used in every case. */
2276 else if (!TerminateProcess (proc_hand
, 0xff))
2278 DebPrint (("sys_kill.TerminateProcess returned %d "
2279 "for pid %lu\n", GetLastError (), pid
));
2286 CloseHandle (proc_hand
);
2291 /* The following two routines are used to manipulate stdin, stdout, and
2292 stderr of our child processes.
2294 Assuming that in, out, and err are *not* inheritable, we make them
2295 stdin, stdout, and stderr of the child as follows:
2297 - Save the parent's current standard handles.
2298 - Set the std handles to inheritable duplicates of the ones being passed in.
2299 (Note that _get_osfhandle() is an io.h procedure that retrieves the
2300 NT file handle for a crt file descriptor.)
2301 - Spawn the child, which inherits in, out, and err as stdin,
2302 stdout, and stderr. (see Spawnve)
2303 - Close the std handles passed to the child.
2304 - Reset the parent's standard handles to the saved handles.
2305 (see reset_standard_handles)
2306 We assume that the caller closes in, out, and err after calling us. */
2309 prepare_standard_handles (int in
, int out
, int err
, HANDLE handles
[3])
2312 HANDLE newstdin
, newstdout
, newstderr
;
2314 parent
= GetCurrentProcess ();
2316 handles
[0] = GetStdHandle (STD_INPUT_HANDLE
);
2317 handles
[1] = GetStdHandle (STD_OUTPUT_HANDLE
);
2318 handles
[2] = GetStdHandle (STD_ERROR_HANDLE
);
2320 /* make inheritable copies of the new handles */
2321 if (!DuplicateHandle (parent
,
2322 (HANDLE
) _get_osfhandle (in
),
2327 DUPLICATE_SAME_ACCESS
))
2328 report_file_error ("Duplicating input handle for child", Qnil
);
2330 if (!DuplicateHandle (parent
,
2331 (HANDLE
) _get_osfhandle (out
),
2336 DUPLICATE_SAME_ACCESS
))
2337 report_file_error ("Duplicating output handle for child", Qnil
);
2339 if (!DuplicateHandle (parent
,
2340 (HANDLE
) _get_osfhandle (err
),
2345 DUPLICATE_SAME_ACCESS
))
2346 report_file_error ("Duplicating error handle for child", Qnil
);
2348 /* and store them as our std handles */
2349 if (!SetStdHandle (STD_INPUT_HANDLE
, newstdin
))
2350 report_file_error ("Changing stdin handle", Qnil
);
2352 if (!SetStdHandle (STD_OUTPUT_HANDLE
, newstdout
))
2353 report_file_error ("Changing stdout handle", Qnil
);
2355 if (!SetStdHandle (STD_ERROR_HANDLE
, newstderr
))
2356 report_file_error ("Changing stderr handle", Qnil
);
2360 reset_standard_handles (int in
, int out
, int err
, HANDLE handles
[3])
2362 /* close the duplicated handles passed to the child */
2363 CloseHandle (GetStdHandle (STD_INPUT_HANDLE
));
2364 CloseHandle (GetStdHandle (STD_OUTPUT_HANDLE
));
2365 CloseHandle (GetStdHandle (STD_ERROR_HANDLE
));
2367 /* now restore parent's saved std handles */
2368 SetStdHandle (STD_INPUT_HANDLE
, handles
[0]);
2369 SetStdHandle (STD_OUTPUT_HANDLE
, handles
[1]);
2370 SetStdHandle (STD_ERROR_HANDLE
, handles
[2]);
2374 set_process_dir (char * dir
)
2379 /* To avoid problems with winsock implementations that work over dial-up
2380 connections causing or requiring a connection to exist while Emacs is
2381 running, Emacs no longer automatically loads winsock on startup if it
2382 is present. Instead, it will be loaded when open-network-stream is
2385 To allow full control over when winsock is loaded, we provide these
2386 two functions to dynamically load and unload winsock. This allows
2387 dial-up users to only be connected when they actually need to use
2391 extern HANDLE winsock_lib
;
2392 extern BOOL
term_winsock (void);
2393 extern BOOL
init_winsock (int load_now
);
2395 DEFUN ("w32-has-winsock", Fw32_has_winsock
, Sw32_has_winsock
, 0, 1, 0,
2396 doc
: /* Test for presence of the Windows socket library `winsock'.
2397 Returns non-nil if winsock support is present, nil otherwise.
2399 If the optional argument LOAD-NOW is non-nil, the winsock library is
2400 also loaded immediately if not already loaded. If winsock is loaded,
2401 the winsock local hostname is returned (since this may be different from
2402 the value of `system-name' and should supplant it), otherwise t is
2403 returned to indicate winsock support is present. */)
2404 (Lisp_Object load_now
)
2408 have_winsock
= init_winsock (!NILP (load_now
));
2411 if (winsock_lib
!= NULL
)
2413 /* Return new value for system-name. The best way to do this
2414 is to call init_system_name, saving and restoring the
2415 original value to avoid side-effects. */
2416 Lisp_Object orig_hostname
= Vsystem_name
;
2417 Lisp_Object hostname
;
2419 init_system_name ();
2420 hostname
= Vsystem_name
;
2421 Vsystem_name
= orig_hostname
;
2429 DEFUN ("w32-unload-winsock", Fw32_unload_winsock
, Sw32_unload_winsock
,
2431 doc
: /* Unload the Windows socket library `winsock' if loaded.
2432 This is provided to allow dial-up socket connections to be disconnected
2433 when no longer needed. Returns nil without unloading winsock if any
2434 socket connections still exist. */)
2437 return term_winsock () ? Qt
: Qnil
;
2441 /* Some miscellaneous functions that are Windows specific, but not GUI
2442 specific (ie. are applicable in terminal or batch mode as well). */
2444 DEFUN ("w32-short-file-name", Fw32_short_file_name
, Sw32_short_file_name
, 1, 1, 0,
2445 doc
: /* Return the short file name version (8.3) of the full path of FILENAME.
2446 If FILENAME does not exist, return nil.
2447 All path elements in FILENAME are converted to their short names. */)
2448 (Lisp_Object filename
)
2450 char shortname
[MAX_PATH
];
2452 CHECK_STRING (filename
);
2454 /* first expand it. */
2455 filename
= Fexpand_file_name (filename
, Qnil
);
2457 /* luckily, this returns the short version of each element in the path. */
2458 if (GetShortPathName (SDATA (ENCODE_FILE (filename
)), shortname
, MAX_PATH
) == 0)
2461 dostounix_filename (shortname
);
2463 return build_string (shortname
);
2467 DEFUN ("w32-long-file-name", Fw32_long_file_name
, Sw32_long_file_name
,
2469 doc
: /* Return the long file name version of the full path of FILENAME.
2470 If FILENAME does not exist, return nil.
2471 All path elements in FILENAME are converted to their long names. */)
2472 (Lisp_Object filename
)
2474 char longname
[ MAX_PATH
];
2477 CHECK_STRING (filename
);
2479 if (SBYTES (filename
) == 2
2480 && *(SDATA (filename
) + 1) == ':')
2483 /* first expand it. */
2484 filename
= Fexpand_file_name (filename
, Qnil
);
2486 if (!w32_get_long_filename (SDATA (ENCODE_FILE (filename
)), longname
, MAX_PATH
))
2489 dostounix_filename (longname
);
2491 /* If we were passed only a drive, make sure that a slash is not appended
2492 for consistency with directories. Allow for drive mapping via SUBST
2493 in case expand-file-name is ever changed to expand those. */
2494 if (drive_only
&& longname
[1] == ':' && longname
[2] == '/' && !longname
[3])
2497 return DECODE_FILE (build_string (longname
));
2500 DEFUN ("w32-set-process-priority", Fw32_set_process_priority
,
2501 Sw32_set_process_priority
, 2, 2, 0,
2502 doc
: /* Set the priority of PROCESS to PRIORITY.
2503 If PROCESS is nil, the priority of Emacs is changed, otherwise the
2504 priority of the process whose pid is PROCESS is changed.
2505 PRIORITY should be one of the symbols high, normal, or low;
2506 any other symbol will be interpreted as normal.
2508 If successful, the return value is t, otherwise nil. */)
2509 (Lisp_Object process
, Lisp_Object priority
)
2511 HANDLE proc_handle
= GetCurrentProcess ();
2512 DWORD priority_class
= NORMAL_PRIORITY_CLASS
;
2513 Lisp_Object result
= Qnil
;
2515 CHECK_SYMBOL (priority
);
2517 if (!NILP (process
))
2522 CHECK_NUMBER (process
);
2524 /* Allow pid to be an internally generated one, or one obtained
2525 externally. This is necessary because real pids on Windows 95 are
2528 pid
= XINT (process
);
2529 cp
= find_child_pid (pid
);
2531 pid
= cp
->procinfo
.dwProcessId
;
2533 proc_handle
= OpenProcess (PROCESS_SET_INFORMATION
, FALSE
, pid
);
2536 if (EQ (priority
, Qhigh
))
2537 priority_class
= HIGH_PRIORITY_CLASS
;
2538 else if (EQ (priority
, Qlow
))
2539 priority_class
= IDLE_PRIORITY_CLASS
;
2541 if (proc_handle
!= NULL
)
2543 if (SetPriorityClass (proc_handle
, priority_class
))
2545 if (!NILP (process
))
2546 CloseHandle (proc_handle
);
2552 #ifdef HAVE_LANGINFO_CODESET
2553 /* Emulation of nl_langinfo. Used in fns.c:Flocale_info. */
2555 nl_langinfo (nl_item item
)
2557 /* Conversion of Posix item numbers to their Windows equivalents. */
2558 static const LCTYPE w32item
[] = {
2559 LOCALE_IDEFAULTANSICODEPAGE
,
2560 LOCALE_SDAYNAME1
, LOCALE_SDAYNAME2
, LOCALE_SDAYNAME3
,
2561 LOCALE_SDAYNAME4
, LOCALE_SDAYNAME5
, LOCALE_SDAYNAME6
, LOCALE_SDAYNAME7
,
2562 LOCALE_SMONTHNAME1
, LOCALE_SMONTHNAME2
, LOCALE_SMONTHNAME3
,
2563 LOCALE_SMONTHNAME4
, LOCALE_SMONTHNAME5
, LOCALE_SMONTHNAME6
,
2564 LOCALE_SMONTHNAME7
, LOCALE_SMONTHNAME8
, LOCALE_SMONTHNAME9
,
2565 LOCALE_SMONTHNAME10
, LOCALE_SMONTHNAME11
, LOCALE_SMONTHNAME12
2568 static char *nl_langinfo_buf
= NULL
;
2569 static int nl_langinfo_len
= 0;
2571 if (nl_langinfo_len
<= 0)
2572 nl_langinfo_buf
= xmalloc (nl_langinfo_len
= 1);
2574 if (item
< 0 || item
>= _NL_NUM
)
2575 nl_langinfo_buf
[0] = 0;
2578 LCID cloc
= GetThreadLocale ();
2579 int need_len
= GetLocaleInfo (cloc
, w32item
[item
] | LOCALE_USE_CP_ACP
,
2583 nl_langinfo_buf
[0] = 0;
2586 if (item
== CODESET
)
2588 need_len
+= 2; /* for the "cp" prefix */
2589 if (need_len
< 8) /* for the case we call GetACP */
2592 if (nl_langinfo_len
<= need_len
)
2593 nl_langinfo_buf
= xrealloc (nl_langinfo_buf
,
2594 nl_langinfo_len
= need_len
);
2595 if (!GetLocaleInfo (cloc
, w32item
[item
] | LOCALE_USE_CP_ACP
,
2596 nl_langinfo_buf
, nl_langinfo_len
))
2597 nl_langinfo_buf
[0] = 0;
2598 else if (item
== CODESET
)
2600 if (strcmp (nl_langinfo_buf
, "0") == 0 /* CP_ACP */
2601 || strcmp (nl_langinfo_buf
, "1") == 0) /* CP_OEMCP */
2602 sprintf (nl_langinfo_buf
, "cp%u", GetACP ());
2605 memmove (nl_langinfo_buf
+ 2, nl_langinfo_buf
,
2606 strlen (nl_langinfo_buf
) + 1);
2607 nl_langinfo_buf
[0] = 'c';
2608 nl_langinfo_buf
[1] = 'p';
2613 return nl_langinfo_buf
;
2615 #endif /* HAVE_LANGINFO_CODESET */
2617 DEFUN ("w32-get-locale-info", Fw32_get_locale_info
,
2618 Sw32_get_locale_info
, 1, 2, 0,
2619 doc
: /* Return information about the Windows locale LCID.
2620 By default, return a three letter locale code which encodes the default
2621 language as the first two characters, and the country or regional variant
2622 as the third letter. For example, ENU refers to `English (United States)',
2623 while ENC means `English (Canadian)'.
2625 If the optional argument LONGFORM is t, the long form of the locale
2626 name is returned, e.g. `English (United States)' instead; if LONGFORM
2627 is a number, it is interpreted as an LCTYPE constant and the corresponding
2628 locale information is returned.
2630 If LCID (a 16-bit number) is not a valid locale, the result is nil. */)
2631 (Lisp_Object lcid
, Lisp_Object longform
)
2635 char abbrev_name
[32] = { 0 };
2636 char full_name
[256] = { 0 };
2638 CHECK_NUMBER (lcid
);
2640 if (!IsValidLocale (XINT (lcid
), LCID_SUPPORTED
))
2643 if (NILP (longform
))
2645 got_abbrev
= GetLocaleInfo (XINT (lcid
),
2646 LOCALE_SABBREVLANGNAME
| LOCALE_USE_CP_ACP
,
2647 abbrev_name
, sizeof (abbrev_name
));
2649 return build_string (abbrev_name
);
2651 else if (EQ (longform
, Qt
))
2653 got_full
= GetLocaleInfo (XINT (lcid
),
2654 LOCALE_SLANGUAGE
| LOCALE_USE_CP_ACP
,
2655 full_name
, sizeof (full_name
));
2657 return DECODE_SYSTEM (build_string (full_name
));
2659 else if (NUMBERP (longform
))
2661 got_full
= GetLocaleInfo (XINT (lcid
),
2663 full_name
, sizeof (full_name
));
2664 /* GetLocaleInfo's return value includes the terminating null
2665 character, when the returned information is a string, whereas
2666 make_unibyte_string needs the string length without the
2667 terminating null. */
2669 return make_unibyte_string (full_name
, got_full
- 1);
2676 DEFUN ("w32-get-current-locale-id", Fw32_get_current_locale_id
,
2677 Sw32_get_current_locale_id
, 0, 0, 0,
2678 doc
: /* Return Windows locale id for current locale setting.
2679 This is a numerical value; use `w32-get-locale-info' to convert to a
2680 human-readable form. */)
2683 return make_number (GetThreadLocale ());
2687 int_from_hex (char * s
)
2690 static char hex
[] = "0123456789abcdefABCDEF";
2693 while (*s
&& (p
= strchr (hex
, *s
)) != NULL
)
2695 unsigned digit
= p
- hex
;
2698 val
= val
* 16 + digit
;
2704 /* We need to build a global list, since the EnumSystemLocale callback
2705 function isn't given a context pointer. */
2706 Lisp_Object Vw32_valid_locale_ids
;
2708 static BOOL CALLBACK
2709 enum_locale_fn (LPTSTR localeNum
)
2711 DWORD id
= int_from_hex (localeNum
);
2712 Vw32_valid_locale_ids
= Fcons (make_number (id
), Vw32_valid_locale_ids
);
2716 DEFUN ("w32-get-valid-locale-ids", Fw32_get_valid_locale_ids
,
2717 Sw32_get_valid_locale_ids
, 0, 0, 0,
2718 doc
: /* Return list of all valid Windows locale ids.
2719 Each id is a numerical value; use `w32-get-locale-info' to convert to a
2720 human-readable form. */)
2723 Vw32_valid_locale_ids
= Qnil
;
2725 EnumSystemLocales (enum_locale_fn
, LCID_SUPPORTED
);
2727 Vw32_valid_locale_ids
= Fnreverse (Vw32_valid_locale_ids
);
2728 return Vw32_valid_locale_ids
;
2732 DEFUN ("w32-get-default-locale-id", Fw32_get_default_locale_id
, Sw32_get_default_locale_id
, 0, 1, 0,
2733 doc
: /* Return Windows locale id for default locale setting.
2734 By default, the system default locale setting is returned; if the optional
2735 parameter USERP is non-nil, the user default locale setting is returned.
2736 This is a numerical value; use `w32-get-locale-info' to convert to a
2737 human-readable form. */)
2741 return make_number (GetSystemDefaultLCID ());
2742 return make_number (GetUserDefaultLCID ());
2746 DEFUN ("w32-set-current-locale", Fw32_set_current_locale
, Sw32_set_current_locale
, 1, 1, 0,
2747 doc
: /* Make Windows locale LCID be the current locale setting for Emacs.
2748 If successful, the new locale id is returned, otherwise nil. */)
2751 CHECK_NUMBER (lcid
);
2753 if (!IsValidLocale (XINT (lcid
), LCID_SUPPORTED
))
2756 if (!SetThreadLocale (XINT (lcid
)))
2759 /* Need to set input thread locale if present. */
2760 if (dwWindowsThreadId
)
2761 /* Reply is not needed. */
2762 PostThreadMessage (dwWindowsThreadId
, WM_EMACS_SETLOCALE
, XINT (lcid
), 0);
2764 return make_number (GetThreadLocale ());
2768 /* We need to build a global list, since the EnumCodePages callback
2769 function isn't given a context pointer. */
2770 Lisp_Object Vw32_valid_codepages
;
2772 static BOOL CALLBACK
2773 enum_codepage_fn (LPTSTR codepageNum
)
2775 DWORD id
= atoi (codepageNum
);
2776 Vw32_valid_codepages
= Fcons (make_number (id
), Vw32_valid_codepages
);
2780 DEFUN ("w32-get-valid-codepages", Fw32_get_valid_codepages
,
2781 Sw32_get_valid_codepages
, 0, 0, 0,
2782 doc
: /* Return list of all valid Windows codepages. */)
2785 Vw32_valid_codepages
= Qnil
;
2787 EnumSystemCodePages (enum_codepage_fn
, CP_SUPPORTED
);
2789 Vw32_valid_codepages
= Fnreverse (Vw32_valid_codepages
);
2790 return Vw32_valid_codepages
;
2794 DEFUN ("w32-get-console-codepage", Fw32_get_console_codepage
,
2795 Sw32_get_console_codepage
, 0, 0, 0,
2796 doc
: /* Return current Windows codepage for console input. */)
2799 return make_number (GetConsoleCP ());
2803 DEFUN ("w32-set-console-codepage", Fw32_set_console_codepage
,
2804 Sw32_set_console_codepage
, 1, 1, 0,
2805 doc
: /* Make Windows codepage CP be the codepage for Emacs tty keyboard input.
2806 This codepage setting affects keyboard input in tty mode.
2807 If successful, the new CP is returned, otherwise nil. */)
2812 if (!IsValidCodePage (XINT (cp
)))
2815 if (!SetConsoleCP (XINT (cp
)))
2818 return make_number (GetConsoleCP ());
2822 DEFUN ("w32-get-console-output-codepage", Fw32_get_console_output_codepage
,
2823 Sw32_get_console_output_codepage
, 0, 0, 0,
2824 doc
: /* Return current Windows codepage for console output. */)
2827 return make_number (GetConsoleOutputCP ());
2831 DEFUN ("w32-set-console-output-codepage", Fw32_set_console_output_codepage
,
2832 Sw32_set_console_output_codepage
, 1, 1, 0,
2833 doc
: /* Make Windows codepage CP be the codepage for Emacs console output.
2834 This codepage setting affects display in tty mode.
2835 If successful, the new CP is returned, otherwise nil. */)
2840 if (!IsValidCodePage (XINT (cp
)))
2843 if (!SetConsoleOutputCP (XINT (cp
)))
2846 return make_number (GetConsoleOutputCP ());
2850 DEFUN ("w32-get-codepage-charset", Fw32_get_codepage_charset
,
2851 Sw32_get_codepage_charset
, 1, 1, 0,
2852 doc
: /* Return charset ID corresponding to codepage CP.
2853 Returns nil if the codepage is not valid. */)
2860 if (!IsValidCodePage (XINT (cp
)))
2863 if (TranslateCharsetInfo ((DWORD
*) XINT (cp
), &info
, TCI_SRCCODEPAGE
))
2864 return make_number (info
.ciCharset
);
2870 DEFUN ("w32-get-valid-keyboard-layouts", Fw32_get_valid_keyboard_layouts
,
2871 Sw32_get_valid_keyboard_layouts
, 0, 0, 0,
2872 doc
: /* Return list of Windows keyboard languages and layouts.
2873 The return value is a list of pairs of language id and layout id. */)
2876 int num_layouts
= GetKeyboardLayoutList (0, NULL
);
2877 HKL
* layouts
= (HKL
*) alloca (num_layouts
* sizeof (HKL
));
2878 Lisp_Object obj
= Qnil
;
2880 if (GetKeyboardLayoutList (num_layouts
, layouts
) == num_layouts
)
2882 while (--num_layouts
>= 0)
2884 DWORD kl
= (DWORD
) layouts
[num_layouts
];
2886 obj
= Fcons (Fcons (make_number (kl
& 0xffff),
2887 make_number ((kl
>> 16) & 0xffff)),
2896 DEFUN ("w32-get-keyboard-layout", Fw32_get_keyboard_layout
,
2897 Sw32_get_keyboard_layout
, 0, 0, 0,
2898 doc
: /* Return current Windows keyboard language and layout.
2899 The return value is the cons of the language id and the layout id. */)
2902 DWORD kl
= (DWORD
) GetKeyboardLayout (dwWindowsThreadId
);
2904 return Fcons (make_number (kl
& 0xffff),
2905 make_number ((kl
>> 16) & 0xffff));
2909 DEFUN ("w32-set-keyboard-layout", Fw32_set_keyboard_layout
,
2910 Sw32_set_keyboard_layout
, 1, 1, 0,
2911 doc
: /* Make LAYOUT be the current keyboard layout for Emacs.
2912 The keyboard layout setting affects interpretation of keyboard input.
2913 If successful, the new layout id is returned, otherwise nil. */)
2914 (Lisp_Object layout
)
2918 CHECK_CONS (layout
);
2919 CHECK_NUMBER_CAR (layout
);
2920 CHECK_NUMBER_CDR (layout
);
2922 kl
= (XINT (XCAR (layout
)) & 0xffff)
2923 | (XINT (XCDR (layout
)) << 16);
2925 /* Synchronize layout with input thread. */
2926 if (dwWindowsThreadId
)
2928 if (PostThreadMessage (dwWindowsThreadId
, WM_EMACS_SETKEYBOARDLAYOUT
,
2932 GetMessage (&msg
, NULL
, WM_EMACS_DONE
, WM_EMACS_DONE
);
2934 if (msg
.wParam
== 0)
2938 else if (!ActivateKeyboardLayout ((HKL
) kl
, 0))
2941 return Fw32_get_keyboard_layout ();
2946 syms_of_ntproc (void)
2948 DEFSYM (Qhigh
, "high");
2949 DEFSYM (Qlow
, "low");
2951 defsubr (&Sw32_has_winsock
);
2952 defsubr (&Sw32_unload_winsock
);
2954 defsubr (&Sw32_short_file_name
);
2955 defsubr (&Sw32_long_file_name
);
2956 defsubr (&Sw32_set_process_priority
);
2957 defsubr (&Sw32_get_locale_info
);
2958 defsubr (&Sw32_get_current_locale_id
);
2959 defsubr (&Sw32_get_default_locale_id
);
2960 defsubr (&Sw32_get_valid_locale_ids
);
2961 defsubr (&Sw32_set_current_locale
);
2963 defsubr (&Sw32_get_console_codepage
);
2964 defsubr (&Sw32_set_console_codepage
);
2965 defsubr (&Sw32_get_console_output_codepage
);
2966 defsubr (&Sw32_set_console_output_codepage
);
2967 defsubr (&Sw32_get_valid_codepages
);
2968 defsubr (&Sw32_get_codepage_charset
);
2970 defsubr (&Sw32_get_valid_keyboard_layouts
);
2971 defsubr (&Sw32_get_keyboard_layout
);
2972 defsubr (&Sw32_set_keyboard_layout
);
2974 DEFVAR_LISP ("w32-quote-process-args", Vw32_quote_process_args
,
2975 doc
: /* Non-nil enables quoting of process arguments to ensure correct parsing.
2976 Because Windows does not directly pass argv arrays to child processes,
2977 programs have to reconstruct the argv array by parsing the command
2978 line string. For an argument to contain a space, it must be enclosed
2979 in double quotes or it will be parsed as multiple arguments.
2981 If the value is a character, that character will be used to escape any
2982 quote characters that appear, otherwise a suitable escape character
2983 will be chosen based on the type of the program. */);
2984 Vw32_quote_process_args
= Qt
;
2986 DEFVAR_LISP ("w32-start-process-show-window",
2987 Vw32_start_process_show_window
,
2988 doc
: /* When nil, new child processes hide their windows.
2989 When non-nil, they show their window in the method of their choice.
2990 This variable doesn't affect GUI applications, which will never be hidden. */);
2991 Vw32_start_process_show_window
= Qnil
;
2993 DEFVAR_LISP ("w32-start-process-share-console",
2994 Vw32_start_process_share_console
,
2995 doc
: /* When nil, new child processes are given a new console.
2996 When non-nil, they share the Emacs console; this has the limitation of
2997 allowing only one DOS subprocess to run at a time (whether started directly
2998 or indirectly by Emacs), and preventing Emacs from cleanly terminating the
2999 subprocess group, but may allow Emacs to interrupt a subprocess that doesn't
3000 otherwise respond to interrupts from Emacs. */);
3001 Vw32_start_process_share_console
= Qnil
;
3003 DEFVAR_LISP ("w32-start-process-inherit-error-mode",
3004 Vw32_start_process_inherit_error_mode
,
3005 doc
: /* When nil, new child processes revert to the default error mode.
3006 When non-nil, they inherit their error mode setting from Emacs, which stops
3007 them blocking when trying to access unmounted drives etc. */);
3008 Vw32_start_process_inherit_error_mode
= Qt
;
3010 DEFVAR_INT ("w32-pipe-read-delay", w32_pipe_read_delay
,
3011 doc
: /* Forced delay before reading subprocess output.
3012 This is done to improve the buffering of subprocess output, by
3013 avoiding the inefficiency of frequently reading small amounts of data.
3015 If positive, the value is the number of milliseconds to sleep before
3016 reading the subprocess output. If negative, the magnitude is the number
3017 of time slices to wait (effectively boosting the priority of the child
3018 process temporarily). A value of zero disables waiting entirely. */);
3019 w32_pipe_read_delay
= 50;
3021 DEFVAR_LISP ("w32-downcase-file-names", Vw32_downcase_file_names
,
3022 doc
: /* Non-nil means convert all-upper case file names to lower case.
3023 This applies when performing completions and file name expansion.
3024 Note that the value of this setting also affects remote file names,
3025 so you probably don't want to set to non-nil if you use case-sensitive
3026 filesystems via ange-ftp. */);
3027 Vw32_downcase_file_names
= Qnil
;
3030 DEFVAR_LISP ("w32-generate-fake-inodes", Vw32_generate_fake_inodes
,
3031 doc
: /* Non-nil means attempt to fake realistic inode values.
3032 This works by hashing the truename of files, and should detect
3033 aliasing between long and short (8.3 DOS) names, but can have
3034 false positives because of hash collisions. Note that determining
3035 the truename of a file can be slow. */);
3036 Vw32_generate_fake_inodes
= Qnil
;
3039 DEFVAR_LISP ("w32-get-true-file-attributes", Vw32_get_true_file_attributes
,
3040 doc
: /* Non-nil means determine accurate file attributes in `file-attributes'.
3041 This option controls whether to issue additional system calls to determine
3042 accurate link counts, file type, and ownership information. It is more
3043 useful for files on NTFS volumes, where hard links and file security are
3044 supported, than on volumes of the FAT family.
3046 Without these system calls, link count will always be reported as 1 and file
3047 ownership will be attributed to the current user.
3048 The default value `local' means only issue these system calls for files
3049 on local fixed drives. A value of nil means never issue them.
3050 Any other non-nil value means do this even on remote and removable drives
3051 where the performance impact may be noticeable even on modern hardware. */);
3052 Vw32_get_true_file_attributes
= Qlocal
;
3054 staticpro (&Vw32_valid_locale_ids
);
3055 staticpro (&Vw32_valid_codepages
);
3057 /* end of w32proc.c */