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;
234 setpgrp (int pid
, int gid
)
239 /* Emulations of interval timers.
241 Limitations: only ITIMER_REAL and ITIMER_PROF are supported.
243 Implementation: a separate thread is started for each timer type,
244 the thread calls the appropriate signal handler when the timer
245 expires, after stopping the thread which installed the timer. */
248 volatile ULONGLONG expire
;
249 volatile ULONGLONG reload
;
250 volatile int terminate
;
252 HANDLE caller_thread
;
256 static ULONGLONG ticks_now
;
257 static struct itimer_data real_itimer
, prof_itimer
;
258 static ULONGLONG clocks_min
;
259 /* If non-zero, itimers are disabled. Used during shutdown, when we
260 delete the critical sections used by the timer threads. */
261 static int disable_itimers
;
263 static CRITICAL_SECTION crit_real
, crit_prof
;
265 /* GetThreadTimes is not available on Windows 9X and possibly also on 2K. */
266 typedef BOOL (WINAPI
*GetThreadTimes_Proc
) (
268 LPFILETIME lpCreationTime
,
269 LPFILETIME lpExitTime
,
270 LPFILETIME lpKernelTime
,
271 LPFILETIME lpUserTime
);
273 static GetThreadTimes_Proc s_pfn_Get_Thread_Times
;
275 #define MAX_SINGLE_SLEEP 30
276 #define TIMER_TICKS_PER_SEC 1000
278 /* Return a suitable time value, in 1-ms units, for THREAD, a handle
279 to a thread. If THREAD is NULL or an invalid handle, return the
280 current wall-clock time since January 1, 1601 (UTC). Otherwise,
281 return the sum of kernel and user times used by THREAD since it was
282 created, plus its creation time. */
284 w32_get_timer_time (HANDLE thread
)
287 int use_system_time
= 1;
288 /* The functions below return times in 100-ns units. */
289 const int tscale
= 10 * TIMER_TICKS_PER_SEC
;
291 if (thread
&& thread
!= INVALID_HANDLE_VALUE
292 && s_pfn_Get_Thread_Times
!= NULL
)
294 FILETIME creation_ftime
, exit_ftime
, kernel_ftime
, user_ftime
;
295 ULARGE_INTEGER temp_creation
, temp_kernel
, temp_user
;
297 if (s_pfn_Get_Thread_Times (thread
, &creation_ftime
, &exit_ftime
,
298 &kernel_ftime
, &user_ftime
))
301 temp_creation
.LowPart
= creation_ftime
.dwLowDateTime
;
302 temp_creation
.HighPart
= creation_ftime
.dwHighDateTime
;
303 temp_kernel
.LowPart
= kernel_ftime
.dwLowDateTime
;
304 temp_kernel
.HighPart
= kernel_ftime
.dwHighDateTime
;
305 temp_user
.LowPart
= user_ftime
.dwLowDateTime
;
306 temp_user
.HighPart
= user_ftime
.dwHighDateTime
;
308 temp_creation
.QuadPart
/ tscale
+ temp_kernel
.QuadPart
/ tscale
309 + temp_user
.QuadPart
/ tscale
;
312 DebPrint (("GetThreadTimes failed with error code %lu\n",
318 FILETIME current_ftime
;
321 GetSystemTimeAsFileTime (¤t_ftime
);
323 temp
.LowPart
= current_ftime
.dwLowDateTime
;
324 temp
.HighPart
= current_ftime
.dwHighDateTime
;
326 retval
= temp
.QuadPart
/ tscale
;
332 /* Thread function for a timer thread. */
334 timer_loop (LPVOID arg
)
336 struct itimer_data
*itimer
= (struct itimer_data
*)arg
;
337 int which
= itimer
->type
;
338 int sig
= (which
== ITIMER_REAL
) ? SIGALRM
: SIGPROF
;
339 CRITICAL_SECTION
*crit
= (which
== ITIMER_REAL
) ? &crit_real
: &crit_prof
;
340 const DWORD max_sleep
= MAX_SINGLE_SLEEP
* 1000 / TIMER_TICKS_PER_SEC
;
341 HANDLE hth
= (which
== ITIMER_REAL
) ? NULL
: itimer
->caller_thread
;
346 signal_handler handler
;
347 ULONGLONG now
, expire
, reload
;
349 /* Load new values if requested by setitimer. */
350 EnterCriticalSection (crit
);
351 expire
= itimer
->expire
;
352 reload
= itimer
->reload
;
353 LeaveCriticalSection (crit
);
354 if (itimer
->terminate
)
364 if (expire
> (now
= w32_get_timer_time (hth
)))
365 sleep_time
= expire
- now
;
368 /* Don't sleep too long at a time, to be able to see the
369 termination flag without too long a delay. */
370 while (sleep_time
> max_sleep
)
372 if (itimer
->terminate
)
375 EnterCriticalSection (crit
);
376 expire
= itimer
->expire
;
377 LeaveCriticalSection (crit
);
379 (expire
> (now
= w32_get_timer_time (hth
))) ? expire
- now
: 0;
381 if (itimer
->terminate
)
385 Sleep (sleep_time
* 1000 / TIMER_TICKS_PER_SEC
);
386 /* Always sleep past the expiration time, to make sure we
387 never call the handler _before_ the expiration time,
388 always slightly after it. Sleep(5) makes sure we don't
389 hog the CPU by calling 'w32_get_timer_time' with high
390 frequency, and also let other threads work. */
391 while (w32_get_timer_time (hth
) < expire
)
395 EnterCriticalSection (crit
);
396 expire
= itimer
->expire
;
397 LeaveCriticalSection (crit
);
402 handler
= sig_handlers
[sig
];
403 if (!(handler
== SIG_DFL
|| handler
== SIG_IGN
|| handler
== SIG_ERR
)
404 /* FIXME: Don't ignore masked signals. Instead, record that
405 they happened and reissue them when the signal is
407 && !sigismember (&sig_mask
, sig
)
408 /* Simulate masking of SIGALRM and SIGPROF when processing
410 && !fatal_error_in_progress
411 && itimer
->caller_thread
)
413 /* Simulate a signal delivered to the thread which installed
414 the timer, by suspending that thread while the handler
416 DWORD result
= SuspendThread (itimer
->caller_thread
);
418 if (result
== (DWORD
)-1)
422 ResumeThread (itimer
->caller_thread
);
425 /* Update expiration time and loop. */
426 EnterCriticalSection (crit
);
427 expire
= itimer
->expire
;
430 LeaveCriticalSection (crit
);
433 reload
= itimer
->reload
;
436 now
= w32_get_timer_time (hth
);
439 ULONGLONG lag
= now
- expire
;
441 /* If we missed some opportunities (presumably while
442 sleeping or while the signal handler ran), skip
445 expire
= now
- (lag
% reload
);
451 expire
= 0; /* become idle */
452 itimer
->expire
= expire
;
453 LeaveCriticalSection (crit
);
459 stop_timer_thread (int which
)
461 struct itimer_data
*itimer
=
462 (which
== ITIMER_REAL
) ? &real_itimer
: &prof_itimer
;
464 DWORD err
, exit_code
= 255;
467 /* Signal the thread that it should terminate. */
468 itimer
->terminate
= 1;
470 if (itimer
->timer_thread
== NULL
)
473 /* Wait for the timer thread to terminate voluntarily, then kill it
474 if it doesn't. This loop waits twice more than the maximum
475 amount of time a timer thread sleeps, see above. */
476 for (i
= 0; i
< MAX_SINGLE_SLEEP
/ 5; i
++)
478 if (!((status
= GetExitCodeThread (itimer
->timer_thread
, &exit_code
))
479 && exit_code
== STILL_ACTIVE
))
483 if ((status
== FALSE
&& (err
= GetLastError ()) == ERROR_INVALID_HANDLE
)
484 || exit_code
== STILL_ACTIVE
)
486 if (!(status
== FALSE
&& err
== ERROR_INVALID_HANDLE
))
487 TerminateThread (itimer
->timer_thread
, 0);
491 CloseHandle (itimer
->timer_thread
);
492 itimer
->timer_thread
= NULL
;
493 if (itimer
->caller_thread
)
495 CloseHandle (itimer
->caller_thread
);
496 itimer
->caller_thread
= NULL
;
500 /* This is called at shutdown time from term_ntproc. */
504 if (real_itimer
.timer_thread
)
505 stop_timer_thread (ITIMER_REAL
);
506 if (prof_itimer
.timer_thread
)
507 stop_timer_thread (ITIMER_PROF
);
509 /* We are going to delete the critical sections, so timers cannot
513 DeleteCriticalSection (&crit_real
);
514 DeleteCriticalSection (&crit_prof
);
515 DeleteCriticalSection (&crit_sig
);
518 /* This is called at initialization time from init_ntproc. */
522 /* GetThreadTimes is not available on all versions of Windows, so
523 need to probe for its availability dynamically, and call it
524 through a pointer. */
525 s_pfn_Get_Thread_Times
= NULL
; /* in case dumped Emacs comes with a value */
526 if (os_subtype
!= OS_9X
)
527 s_pfn_Get_Thread_Times
=
528 (GetThreadTimes_Proc
)GetProcAddress (GetModuleHandle ("kernel32.dll"),
531 /* Make sure we start with zeroed out itimer structures, since
532 dumping may have left there traces of threads long dead. */
533 memset (&real_itimer
, 0, sizeof real_itimer
);
534 memset (&prof_itimer
, 0, sizeof prof_itimer
);
536 InitializeCriticalSection (&crit_real
);
537 InitializeCriticalSection (&crit_prof
);
538 InitializeCriticalSection (&crit_sig
);
544 start_timer_thread (int which
)
547 struct itimer_data
*itimer
=
548 (which
== ITIMER_REAL
) ? &real_itimer
: &prof_itimer
;
550 if (itimer
->timer_thread
551 && GetExitCodeThread (itimer
->timer_thread
, &exit_code
)
552 && exit_code
== STILL_ACTIVE
)
555 /* Start a new thread. */
556 itimer
->terminate
= 0;
557 itimer
->type
= which
;
558 /* Request that no more than 64KB of stack be reserved for this
559 thread, to avoid reserving too much memory, which would get in
560 the way of threads we start to wait for subprocesses. See also
562 itimer
->timer_thread
= CreateThread (NULL
, 64 * 1024, timer_loop
,
563 (void *)itimer
, 0x00010000, NULL
);
565 if (!itimer
->timer_thread
)
567 CloseHandle (itimer
->caller_thread
);
568 itimer
->caller_thread
= NULL
;
573 /* This is needed to make sure that the timer thread running for
574 profiling gets CPU as soon as the Sleep call terminates. */
575 if (which
== ITIMER_PROF
)
576 SetThreadPriority (itimer
->caller_thread
, THREAD_PRIORITY_TIME_CRITICAL
);
581 /* Most of the code of getitimer and setitimer (but not of their
582 subroutines) was shamelessly stolen from itimer.c in the DJGPP
583 library, see www.delorie.com/djgpp. */
585 getitimer (int which
, struct itimerval
*value
)
587 volatile ULONGLONG
*t_expire
;
588 volatile ULONGLONG
*t_reload
;
589 ULONGLONG expire
, reload
;
591 CRITICAL_SECTION
*crit
;
592 struct itimer_data
*itimer
;
603 if (which
!= ITIMER_REAL
&& which
!= ITIMER_PROF
)
609 itimer
= (which
== ITIMER_REAL
) ? &real_itimer
: &prof_itimer
;
611 if (!DuplicateHandle (GetCurrentProcess (), GetCurrentThread (),
612 GetCurrentProcess (), &itimer
->caller_thread
, 0,
613 FALSE
, DUPLICATE_SAME_ACCESS
))
619 ticks_now
= w32_get_timer_time ((which
== ITIMER_REAL
)
621 : itimer
->caller_thread
);
623 t_expire
= &itimer
->expire
;
624 t_reload
= &itimer
->reload
;
625 crit
= (which
== ITIMER_REAL
) ? &crit_real
: &crit_prof
;
627 EnterCriticalSection (crit
);
630 LeaveCriticalSection (crit
);
635 value
->it_value
.tv_sec
= expire
/ TIMER_TICKS_PER_SEC
;
637 (expire
% TIMER_TICKS_PER_SEC
) * (__int64
)1000000 / TIMER_TICKS_PER_SEC
;
638 value
->it_value
.tv_usec
= usecs
;
639 value
->it_interval
.tv_sec
= reload
/ TIMER_TICKS_PER_SEC
;
641 (reload
% TIMER_TICKS_PER_SEC
) * (__int64
)1000000 / TIMER_TICKS_PER_SEC
;
642 value
->it_interval
.tv_usec
= usecs
;
648 setitimer(int which
, struct itimerval
*value
, struct itimerval
*ovalue
)
650 volatile ULONGLONG
*t_expire
, *t_reload
;
651 ULONGLONG expire
, reload
, expire_old
, reload_old
;
653 CRITICAL_SECTION
*crit
;
654 struct itimerval tem
, *ptem
;
659 /* Posix systems expect timer values smaller than the resolution of
660 the system clock be rounded up to the clock resolution. First
661 time we are called, measure the clock tick resolution. */
666 for (t1
= w32_get_timer_time (NULL
);
667 (t2
= w32_get_timer_time (NULL
)) == t1
; )
669 clocks_min
= t2
- t1
;
677 if (getitimer (which
, ptem
)) /* also sets ticks_now */
678 return -1; /* errno already set */
681 (which
== ITIMER_REAL
) ? &real_itimer
.expire
: &prof_itimer
.expire
;
683 (which
== ITIMER_REAL
) ? &real_itimer
.reload
: &prof_itimer
.reload
;
685 crit
= (which
== ITIMER_REAL
) ? &crit_real
: &crit_prof
;
688 || (value
->it_value
.tv_sec
== 0 && value
->it_value
.tv_usec
== 0))
690 EnterCriticalSection (crit
);
691 /* Disable the timer. */
694 LeaveCriticalSection (crit
);
698 reload
= value
->it_interval
.tv_sec
* TIMER_TICKS_PER_SEC
;
700 usecs
= value
->it_interval
.tv_usec
;
701 if (value
->it_interval
.tv_sec
== 0
702 && usecs
&& usecs
* TIMER_TICKS_PER_SEC
< clocks_min
* 1000000)
706 usecs
*= TIMER_TICKS_PER_SEC
;
707 reload
+= usecs
/ 1000000;
710 expire
= value
->it_value
.tv_sec
* TIMER_TICKS_PER_SEC
;
711 usecs
= value
->it_value
.tv_usec
;
712 if (value
->it_value
.tv_sec
== 0
713 && usecs
* TIMER_TICKS_PER_SEC
< clocks_min
* 1000000)
717 usecs
*= TIMER_TICKS_PER_SEC
;
718 expire
+= usecs
/ 1000000;
723 EnterCriticalSection (crit
);
724 expire_old
= *t_expire
;
725 reload_old
= *t_reload
;
726 if (!(expire
== expire_old
&& reload
== reload_old
))
731 LeaveCriticalSection (crit
);
733 return start_timer_thread (which
);
739 #ifdef HAVE_SETITIMER
740 struct itimerval new_values
, old_values
;
742 new_values
.it_value
.tv_sec
= seconds
;
743 new_values
.it_value
.tv_usec
= 0;
744 new_values
.it_interval
.tv_sec
= new_values
.it_interval
.tv_usec
= 0;
746 if (setitimer (ITIMER_REAL
, &new_values
, &old_values
) < 0)
748 return old_values
.it_value
.tv_sec
;
754 /* Defined in <process.h> which conflicts with the local copy */
757 /* Child process management list. */
758 int child_proc_count
= 0;
759 child_process child_procs
[ MAX_CHILDREN
];
760 child_process
*dead_child
= NULL
;
762 static DWORD WINAPI
reader_thread (void *arg
);
764 /* Find an unused process slot. */
771 for (cp
= child_procs
+ (child_proc_count
-1); cp
>= child_procs
; cp
--)
772 if (!CHILD_ACTIVE (cp
))
774 if (child_proc_count
== MAX_CHILDREN
)
776 cp
= &child_procs
[child_proc_count
++];
779 memset (cp
, 0, sizeof (*cp
));
782 cp
->procinfo
.hProcess
= NULL
;
783 cp
->status
= STATUS_READ_ERROR
;
785 /* use manual reset event so that select() will function properly */
786 cp
->char_avail
= CreateEvent (NULL
, TRUE
, FALSE
, NULL
);
789 cp
->char_consumed
= CreateEvent (NULL
, FALSE
, FALSE
, NULL
);
790 if (cp
->char_consumed
)
792 /* The 0x00010000 flag is STACK_SIZE_PARAM_IS_A_RESERVATION.
793 It means that the 64K stack we are requesting in the 2nd
794 argument is how much memory should be reserved for the
795 stack. If we don't use this flag, the memory requested
796 by the 2nd argument is the amount actually _committed_,
797 but Windows reserves 8MB of memory for each thread's
798 stack. (The 8MB figure comes from the -stack
799 command-line argument we pass to the linker when building
800 Emacs, but that's because we need a large stack for
801 Emacs's main thread.) Since we request 2GB of reserved
802 memory at startup (see w32heap.c), which is close to the
803 maximum memory available for a 32-bit process on Windows,
804 the 8MB reservation for each thread causes failures in
805 starting subprocesses, because we create a thread running
806 reader_thread for each subprocess. As 8MB of stack is
807 way too much for reader_thread, forcing Windows to
808 reserve less wins the day. */
809 cp
->thrd
= CreateThread (NULL
, 64 * 1024, reader_thread
, cp
,
820 delete_child (child_process
*cp
)
824 /* Should not be deleting a child that is still needed. */
825 for (i
= 0; i
< MAXDESC
; i
++)
826 if (fd_info
[i
].cp
== cp
)
829 if (!CHILD_ACTIVE (cp
))
832 /* reap thread if necessary */
837 if (GetExitCodeThread (cp
->thrd
, &rc
) && rc
== STILL_ACTIVE
)
839 /* let the thread exit cleanly if possible */
840 cp
->status
= STATUS_READ_ERROR
;
841 SetEvent (cp
->char_consumed
);
843 /* We used to forcibly terminate the thread here, but it
844 is normally unnecessary, and in abnormal cases, the worst that
845 will happen is we have an extra idle thread hanging around
846 waiting for the zombie process. */
847 if (WaitForSingleObject (cp
->thrd
, 1000) != WAIT_OBJECT_0
)
849 DebPrint (("delete_child.WaitForSingleObject (thread) failed "
850 "with %lu for fd %ld\n", GetLastError (), cp
->fd
));
851 TerminateThread (cp
->thrd
, 0);
855 CloseHandle (cp
->thrd
);
860 CloseHandle (cp
->char_avail
);
861 cp
->char_avail
= NULL
;
863 if (cp
->char_consumed
)
865 CloseHandle (cp
->char_consumed
);
866 cp
->char_consumed
= NULL
;
869 /* update child_proc_count (highest numbered slot in use plus one) */
870 if (cp
== child_procs
+ child_proc_count
- 1)
872 for (i
= child_proc_count
-1; i
>= 0; i
--)
873 if (CHILD_ACTIVE (&child_procs
[i
]))
875 child_proc_count
= i
+ 1;
880 child_proc_count
= 0;
883 /* Find a child by pid. */
884 static child_process
*
885 find_child_pid (DWORD pid
)
889 for (cp
= child_procs
+ (child_proc_count
-1); cp
>= child_procs
; cp
--)
890 if (CHILD_ACTIVE (cp
) && pid
== cp
->pid
)
896 /* Thread proc for child process and socket reader threads. Each thread
897 is normally blocked until woken by select() to check for input by
898 reading one char. When the read completes, char_avail is signaled
899 to wake up the select emulator and the thread blocks itself again. */
901 reader_thread (void *arg
)
906 cp
= (child_process
*)arg
;
908 /* We have to wait for the go-ahead before we can start */
910 || WaitForSingleObject (cp
->char_consumed
, INFINITE
) != WAIT_OBJECT_0
918 if (fd_info
[cp
->fd
].flags
& FILE_LISTEN
)
919 rc
= _sys_wait_accept (cp
->fd
);
921 rc
= _sys_read_ahead (cp
->fd
);
923 /* The name char_avail is a misnomer - it really just means the
924 read-ahead has completed, whether successfully or not. */
925 if (!SetEvent (cp
->char_avail
))
927 DebPrint (("reader_thread.SetEvent failed with %lu for fd %ld\n",
928 GetLastError (), cp
->fd
));
932 if (rc
== STATUS_READ_ERROR
)
935 /* If the read died, the child has died so let the thread die */
936 if (rc
== STATUS_READ_FAILED
)
939 /* Wait until our input is acknowledged before reading again */
940 if (WaitForSingleObject (cp
->char_consumed
, INFINITE
) != WAIT_OBJECT_0
)
942 DebPrint (("reader_thread.WaitForSingleObject failed with "
943 "%lu for fd %ld\n", GetLastError (), cp
->fd
));
950 /* To avoid Emacs changing directory, we just record here the directory
951 the new process should start in. This is set just before calling
952 sys_spawnve, and is not generally valid at any other time. */
953 static char * process_dir
;
956 create_child (char *exe
, char *cmdline
, char *env
, int is_gui_app
,
957 int * pPid
, child_process
*cp
)
960 SECURITY_ATTRIBUTES sec_attrs
;
962 SECURITY_DESCRIPTOR sec_desc
;
965 char dir
[ MAXPATHLEN
];
967 if (cp
== NULL
) emacs_abort ();
969 memset (&start
, 0, sizeof (start
));
970 start
.cb
= sizeof (start
);
973 if (NILP (Vw32_start_process_show_window
) && !is_gui_app
)
974 start
.dwFlags
= STARTF_USESTDHANDLES
| STARTF_USESHOWWINDOW
;
976 start
.dwFlags
= STARTF_USESTDHANDLES
;
977 start
.wShowWindow
= SW_HIDE
;
979 start
.hStdInput
= GetStdHandle (STD_INPUT_HANDLE
);
980 start
.hStdOutput
= GetStdHandle (STD_OUTPUT_HANDLE
);
981 start
.hStdError
= GetStdHandle (STD_ERROR_HANDLE
);
982 #endif /* HAVE_NTGUI */
985 /* Explicitly specify no security */
986 if (!InitializeSecurityDescriptor (&sec_desc
, SECURITY_DESCRIPTOR_REVISION
))
988 if (!SetSecurityDescriptorDacl (&sec_desc
, TRUE
, NULL
, FALSE
))
991 sec_attrs
.nLength
= sizeof (sec_attrs
);
992 sec_attrs
.lpSecurityDescriptor
= NULL
/* &sec_desc */;
993 sec_attrs
.bInheritHandle
= FALSE
;
995 strcpy (dir
, process_dir
);
996 unixtodos_filename (dir
);
998 flags
= (!NILP (Vw32_start_process_share_console
)
999 ? CREATE_NEW_PROCESS_GROUP
1000 : CREATE_NEW_CONSOLE
);
1001 if (NILP (Vw32_start_process_inherit_error_mode
))
1002 flags
|= CREATE_DEFAULT_ERROR_MODE
;
1003 if (!CreateProcess (exe
, cmdline
, &sec_attrs
, NULL
, TRUE
,
1004 flags
, env
, dir
, &start
, &cp
->procinfo
))
1007 cp
->pid
= (int) cp
->procinfo
.dwProcessId
;
1009 /* Hack for Windows 95, which assigns large (ie negative) pids */
1013 /* pid must fit in a Lisp_Int */
1014 cp
->pid
= cp
->pid
& INTMASK
;
1021 DebPrint (("create_child.CreateProcess failed: %ld\n", GetLastError ()););
1025 /* create_child doesn't know what emacs' file handle will be for waiting
1026 on output from the child, so we need to make this additional call
1027 to register the handle with the process
1028 This way the select emulator knows how to match file handles with
1029 entries in child_procs. */
1031 register_child (int pid
, int fd
)
1035 cp
= find_child_pid (pid
);
1038 DebPrint (("register_child unable to find pid %lu\n", pid
));
1043 DebPrint (("register_child registered fd %d with pid %lu\n", fd
, pid
));
1048 /* thread is initially blocked until select is called; set status so
1049 that select will release thread */
1050 cp
->status
= STATUS_READ_ACKNOWLEDGED
;
1052 /* attach child_process to fd_info */
1053 if (fd_info
[fd
].cp
!= NULL
)
1055 DebPrint (("register_child: fd_info[%d] apparently in use!\n", fd
));
1059 fd_info
[fd
].cp
= cp
;
1062 /* When a process dies its pipe will break so the reader thread will
1063 signal failure to the select emulator.
1064 The select emulator then calls this routine to clean up.
1065 Since the thread signaled failure we can assume it is exiting. */
1067 reap_subprocess (child_process
*cp
)
1069 if (cp
->procinfo
.hProcess
)
1071 /* Reap the process */
1073 /* Process should have already died before we are called. */
1074 if (WaitForSingleObject (cp
->procinfo
.hProcess
, 0) != WAIT_OBJECT_0
)
1075 DebPrint (("reap_subprocess: child fpr fd %d has not died yet!", cp
->fd
));
1077 CloseHandle (cp
->procinfo
.hProcess
);
1078 cp
->procinfo
.hProcess
= NULL
;
1079 CloseHandle (cp
->procinfo
.hThread
);
1080 cp
->procinfo
.hThread
= NULL
;
1083 /* For asynchronous children, the child_proc resources will be freed
1084 when the last pipe read descriptor is closed; for synchronous
1085 children, we must explicitly free the resources now because
1086 register_child has not been called. */
1091 /* Wait for any of our existing child processes to die
1092 When it does, close its handle
1093 Return the pid and fill in the status if non-NULL. */
1096 sys_wait (int *status
)
1098 DWORD active
, retval
;
1101 child_process
*cp
, *cps
[MAX_CHILDREN
];
1102 HANDLE wait_hnd
[MAX_CHILDREN
];
1105 if (dead_child
!= NULL
)
1107 /* We want to wait for a specific child */
1108 wait_hnd
[nh
] = dead_child
->procinfo
.hProcess
;
1109 cps
[nh
] = dead_child
;
1110 if (!wait_hnd
[nh
]) emacs_abort ();
1117 for (cp
= child_procs
+ (child_proc_count
-1); cp
>= child_procs
; cp
--)
1118 /* some child_procs might be sockets; ignore them */
1119 if (CHILD_ACTIVE (cp
) && cp
->procinfo
.hProcess
1120 && (cp
->fd
< 0 || (fd_info
[cp
->fd
].flags
& FILE_AT_EOF
) != 0))
1122 wait_hnd
[nh
] = cp
->procinfo
.hProcess
;
1130 /* Nothing to wait on, so fail */
1137 /* Check for quit about once a second. */
1139 active
= WaitForMultipleObjects (nh
, wait_hnd
, FALSE
, 1000);
1140 } while (active
== WAIT_TIMEOUT
);
1142 if (active
== WAIT_FAILED
)
1147 else if (active
>= WAIT_OBJECT_0
1148 && active
< WAIT_OBJECT_0
+MAXIMUM_WAIT_OBJECTS
)
1150 active
-= WAIT_OBJECT_0
;
1152 else if (active
>= WAIT_ABANDONED_0
1153 && active
< WAIT_ABANDONED_0
+MAXIMUM_WAIT_OBJECTS
)
1155 active
-= WAIT_ABANDONED_0
;
1161 if (!GetExitCodeProcess (wait_hnd
[active
], &retval
))
1163 DebPrint (("Wait.GetExitCodeProcess failed with %lu\n",
1167 if (retval
== STILL_ACTIVE
)
1169 /* Should never happen */
1170 DebPrint (("Wait.WaitForMultipleObjects returned an active process\n"));
1175 /* Massage the exit code from the process to match the format expected
1176 by the WIFSTOPPED et al macros in syswait.h. Only WIFSIGNALED and
1177 WIFEXITED are supported; WIFSTOPPED doesn't make sense under NT. */
1179 if (retval
== STATUS_CONTROL_C_EXIT
)
1187 DebPrint (("Wait signaled with process pid %d\n", cp
->pid
));
1194 else if (synch_process_alive
)
1196 synch_process_alive
= 0;
1198 /* Report the status of the synchronous process. */
1199 if (WIFEXITED (retval
))
1200 synch_process_retcode
= WEXITSTATUS (retval
);
1201 else if (WIFSIGNALED (retval
))
1203 int code
= WTERMSIG (retval
);
1204 const char *signame
;
1206 synchronize_system_messages_locale ();
1207 signame
= strsignal (code
);
1210 signame
= "unknown";
1212 synch_process_death
= signame
;
1215 reap_subprocess (cp
);
1218 reap_subprocess (cp
);
1223 /* Old versions of w32api headers don't have separate 32-bit and
1224 64-bit defines, but the one they have matches the 32-bit variety. */
1225 #ifndef IMAGE_NT_OPTIONAL_HDR32_MAGIC
1226 # define IMAGE_NT_OPTIONAL_HDR32_MAGIC IMAGE_NT_OPTIONAL_HDR_MAGIC
1227 # define IMAGE_OPTIONAL_HEADER32 IMAGE_OPTIONAL_HEADER
1231 w32_executable_type (char * filename
,
1233 int * is_cygnus_app
,
1236 file_data executable
;
1239 /* Default values in case we can't tell for sure. */
1240 *is_dos_app
= FALSE
;
1241 *is_cygnus_app
= FALSE
;
1242 *is_gui_app
= FALSE
;
1244 if (!open_input_file (&executable
, filename
))
1247 p
= strrchr (filename
, '.');
1249 /* We can only identify DOS .com programs from the extension. */
1250 if (p
&& xstrcasecmp (p
, ".com") == 0)
1252 else if (p
&& (xstrcasecmp (p
, ".bat") == 0
1253 || xstrcasecmp (p
, ".cmd") == 0))
1255 /* A DOS shell script - it appears that CreateProcess is happy to
1256 accept this (somewhat surprisingly); presumably it looks at
1257 COMSPEC to determine what executable to actually invoke.
1258 Therefore, we have to do the same here as well. */
1259 /* Actually, I think it uses the program association for that
1260 extension, which is defined in the registry. */
1261 p
= egetenv ("COMSPEC");
1263 w32_executable_type (p
, is_dos_app
, is_cygnus_app
, is_gui_app
);
1267 /* Look for DOS .exe signature - if found, we must also check that
1268 it isn't really a 16- or 32-bit Windows exe, since both formats
1269 start with a DOS program stub. Note that 16-bit Windows
1270 executables use the OS/2 1.x format. */
1272 IMAGE_DOS_HEADER
* dos_header
;
1273 IMAGE_NT_HEADERS
* nt_header
;
1275 dos_header
= (PIMAGE_DOS_HEADER
) executable
.file_base
;
1276 if (dos_header
->e_magic
!= IMAGE_DOS_SIGNATURE
)
1279 nt_header
= (PIMAGE_NT_HEADERS
) ((unsigned char *) dos_header
+ dos_header
->e_lfanew
);
1281 if ((char *) nt_header
> (char *) dos_header
+ executable
.size
)
1283 /* Some dos headers (pkunzip) have bogus e_lfanew fields. */
1286 else if (nt_header
->Signature
!= IMAGE_NT_SIGNATURE
1287 && LOWORD (nt_header
->Signature
) != IMAGE_OS2_SIGNATURE
)
1291 else if (nt_header
->Signature
== IMAGE_NT_SIGNATURE
)
1293 IMAGE_DATA_DIRECTORY
*data_dir
= NULL
;
1294 if (nt_header
->OptionalHeader
.Magic
== IMAGE_NT_OPTIONAL_HDR32_MAGIC
)
1296 /* Ensure we are using the 32 bit structure. */
1297 IMAGE_OPTIONAL_HEADER32
*opt
1298 = (IMAGE_OPTIONAL_HEADER32
*) &(nt_header
->OptionalHeader
);
1299 data_dir
= opt
->DataDirectory
;
1300 *is_gui_app
= (opt
->Subsystem
== IMAGE_SUBSYSTEM_WINDOWS_GUI
);
1302 /* MingW 3.12 has the required 64 bit structs, but in case older
1303 versions don't, only check 64 bit exes if we know how. */
1304 #ifdef IMAGE_NT_OPTIONAL_HDR64_MAGIC
1305 else if (nt_header
->OptionalHeader
.Magic
1306 == IMAGE_NT_OPTIONAL_HDR64_MAGIC
)
1308 IMAGE_OPTIONAL_HEADER64
*opt
1309 = (IMAGE_OPTIONAL_HEADER64
*) &(nt_header
->OptionalHeader
);
1310 data_dir
= opt
->DataDirectory
;
1311 *is_gui_app
= (opt
->Subsystem
== IMAGE_SUBSYSTEM_WINDOWS_GUI
);
1316 /* Look for cygwin.dll in DLL import list. */
1317 IMAGE_DATA_DIRECTORY import_dir
=
1318 data_dir
[IMAGE_DIRECTORY_ENTRY_IMPORT
];
1319 IMAGE_IMPORT_DESCRIPTOR
* imports
;
1320 IMAGE_SECTION_HEADER
* section
;
1322 section
= rva_to_section (import_dir
.VirtualAddress
, nt_header
);
1323 imports
= RVA_TO_PTR (import_dir
.VirtualAddress
, section
,
1326 for ( ; imports
->Name
; imports
++)
1328 char * dllname
= RVA_TO_PTR (imports
->Name
, section
,
1331 /* The exact name of the cygwin dll has changed with
1332 various releases, but hopefully this will be reasonably
1334 if (strncmp (dllname
, "cygwin", 6) == 0)
1336 *is_cygnus_app
= TRUE
;
1345 close_file_data (&executable
);
1349 compare_env (const void *strp1
, const void *strp2
)
1351 const char *str1
= *(const char **)strp1
, *str2
= *(const char **)strp2
;
1353 while (*str1
&& *str2
&& *str1
!= '=' && *str2
!= '=')
1355 /* Sort order in command.com/cmd.exe is based on uppercasing
1356 names, so do the same here. */
1357 if (toupper (*str1
) > toupper (*str2
))
1359 else if (toupper (*str1
) < toupper (*str2
))
1364 if (*str1
== '=' && *str2
== '=')
1366 else if (*str1
== '=')
1373 merge_and_sort_env (char **envp1
, char **envp2
, char **new_envp
)
1375 char **optr
, **nptr
;
1387 num
+= optr
- envp2
;
1389 qsort (new_envp
, num
, sizeof (char *), compare_env
);
1394 /* When a new child process is created we need to register it in our list,
1395 so intercept spawn requests. */
1397 sys_spawnve (int mode
, char *cmdname
, char **argv
, char **envp
)
1399 Lisp_Object program
, full
;
1400 char *cmdline
, *env
, *parg
, **targ
;
1404 int is_dos_app
, is_cygnus_app
, is_gui_app
;
1407 /* We pass our process ID to our children by setting up an environment
1408 variable in their environment. */
1409 char ppid_env_var_buffer
[64];
1410 char *extra_env
[] = {ppid_env_var_buffer
, NULL
};
1411 /* These are the characters that cause an argument to need quoting.
1412 Arguments with whitespace characters need quoting to prevent the
1413 argument being split into two or more. Arguments with wildcards
1414 are also quoted, for consistency with posix platforms, where wildcards
1415 are not expanded if we run the program directly without a shell.
1416 Some extra whitespace characters need quoting in Cygwin programs,
1417 so this list is conditionally modified below. */
1418 char *sepchars
= " \t*?";
1420 /* We don't care about the other modes */
1421 if (mode
!= _P_NOWAIT
)
1427 /* Handle executable names without an executable suffix. */
1428 program
= build_string (cmdname
);
1429 if (NILP (Ffile_executable_p (program
)))
1431 struct gcpro gcpro1
;
1435 openp (Vexec_path
, program
, Vexec_suffixes
, &full
, make_number (X_OK
));
1445 /* make sure argv[0] and cmdname are both in DOS format */
1446 cmdname
= SDATA (program
);
1447 unixtodos_filename (cmdname
);
1450 /* Determine whether program is a 16-bit DOS executable, or a 32-bit Windows
1451 executable that is implicitly linked to the Cygnus dll (implying it
1452 was compiled with the Cygnus GNU toolchain and hence relies on
1453 cygwin.dll to parse the command line - we use this to decide how to
1454 escape quote chars in command line args that must be quoted).
1456 Also determine whether it is a GUI app, so that we don't hide its
1457 initial window unless specifically requested. */
1458 w32_executable_type (cmdname
, &is_dos_app
, &is_cygnus_app
, &is_gui_app
);
1460 /* On Windows 95, if cmdname is a DOS app, we invoke a helper
1461 application to start it by specifying the helper app as cmdname,
1462 while leaving the real app name as argv[0]. */
1465 cmdname
= alloca (MAXPATHLEN
);
1466 if (egetenv ("CMDPROXY"))
1467 strcpy (cmdname
, egetenv ("CMDPROXY"));
1470 strcpy (cmdname
, SDATA (Vinvocation_directory
));
1471 strcat (cmdname
, "cmdproxy.exe");
1473 unixtodos_filename (cmdname
);
1476 /* we have to do some conjuring here to put argv and envp into the
1477 form CreateProcess wants... argv needs to be a space separated/null
1478 terminated list of parameters, and envp is a null
1479 separated/double-null terminated list of parameters.
1481 Additionally, zero-length args and args containing whitespace or
1482 quote chars need to be wrapped in double quotes - for this to work,
1483 embedded quotes need to be escaped as well. The aim is to ensure
1484 the child process reconstructs the argv array we start with
1485 exactly, so we treat quotes at the beginning and end of arguments
1488 The w32 GNU-based library from Cygnus doubles quotes to escape
1489 them, while MSVC uses backslash for escaping. (Actually the MSVC
1490 startup code does attempt to recognize doubled quotes and accept
1491 them, but gets it wrong and ends up requiring three quotes to get a
1492 single embedded quote!) So by default we decide whether to use
1493 quote or backslash as the escape character based on whether the
1494 binary is apparently a Cygnus compiled app.
1496 Note that using backslash to escape embedded quotes requires
1497 additional special handling if an embedded quote is already
1498 preceded by backslash, or if an arg requiring quoting ends with
1499 backslash. In such cases, the run of escape characters needs to be
1500 doubled. For consistency, we apply this special handling as long
1501 as the escape character is not quote.
1503 Since we have no idea how large argv and envp are likely to be we
1504 figure out list lengths on the fly and allocate them. */
1506 if (!NILP (Vw32_quote_process_args
))
1509 /* Override escape char by binding w32-quote-process-args to
1510 desired character, or use t for auto-selection. */
1511 if (INTEGERP (Vw32_quote_process_args
))
1512 escape_char
= XINT (Vw32_quote_process_args
);
1514 escape_char
= is_cygnus_app
? '"' : '\\';
1517 /* Cygwin apps needs quoting a bit more often. */
1518 if (escape_char
== '"')
1519 sepchars
= "\r\n\t\f '";
1527 int need_quotes
= 0;
1528 int escape_char_run
= 0;
1534 if (escape_char
== '"' && *p
== '\\')
1535 /* If it's a Cygwin app, \ needs to be escaped. */
1539 /* allow for embedded quotes to be escaped */
1542 /* handle the case where the embedded quote is already escaped */
1543 if (escape_char_run
> 0)
1545 /* To preserve the arg exactly, we need to double the
1546 preceding escape characters (plus adding one to
1547 escape the quote character itself). */
1548 arglen
+= escape_char_run
;
1551 else if (strchr (sepchars
, *p
) != NULL
)
1556 if (*p
== escape_char
&& escape_char
!= '"')
1559 escape_char_run
= 0;
1564 /* handle the case where the arg ends with an escape char - we
1565 must not let the enclosing quote be escaped. */
1566 if (escape_char_run
> 0)
1567 arglen
+= escape_char_run
;
1569 arglen
+= strlen (*targ
++) + 1;
1571 cmdline
= alloca (arglen
);
1577 int need_quotes
= 0;
1585 if ((strchr (sepchars
, *p
) != NULL
) || *p
== '"')
1590 int escape_char_run
= 0;
1596 last
= p
+ strlen (p
) - 1;
1599 /* This version does not escape quotes if they occur at the
1600 beginning or end of the arg - this could lead to incorrect
1601 behavior when the arg itself represents a command line
1602 containing quoted args. I believe this was originally done
1603 as a hack to make some things work, before
1604 `w32-quote-process-args' was added. */
1607 if (*p
== '"' && p
> first
&& p
< last
)
1608 *parg
++ = escape_char
; /* escape embedded quotes */
1616 /* double preceding escape chars if any */
1617 while (escape_char_run
> 0)
1619 *parg
++ = escape_char
;
1622 /* escape all quote chars, even at beginning or end */
1623 *parg
++ = escape_char
;
1625 else if (escape_char
== '"' && *p
== '\\')
1629 if (*p
== escape_char
&& escape_char
!= '"')
1632 escape_char_run
= 0;
1634 /* double escape chars before enclosing quote */
1635 while (escape_char_run
> 0)
1637 *parg
++ = escape_char
;
1645 strcpy (parg
, *targ
);
1646 parg
+= strlen (*targ
);
1656 numenv
= 1; /* for end null */
1659 arglen
+= strlen (*targ
++) + 1;
1662 /* extra env vars... */
1663 sprintf (ppid_env_var_buffer
, "EM_PARENT_PROCESS_ID=%lu",
1664 GetCurrentProcessId ());
1665 arglen
+= strlen (ppid_env_var_buffer
) + 1;
1668 /* merge env passed in and extra env into one, and sort it. */
1669 targ
= (char **) alloca (numenv
* sizeof (char *));
1670 merge_and_sort_env (envp
, extra_env
, targ
);
1672 /* concatenate env entries. */
1673 env
= alloca (arglen
);
1677 strcpy (parg
, *targ
);
1678 parg
+= strlen (*targ
++);
1691 /* Now create the process. */
1692 if (!create_child (cmdname
, cmdline
, env
, is_gui_app
, &pid
, cp
))
1702 /* Emulate the select call
1703 Wait for available input on any of the given rfds, or timeout if
1704 a timeout is given and no input is detected
1705 wfds and efds are not supported and must be NULL.
1707 For simplicity, we detect the death of child processes here and
1708 synchronously call the SIGCHLD handler. Since it is possible for
1709 children to be created without a corresponding pipe handle from which
1710 to read output, we wait separately on the process handles as well as
1711 the char_avail events for each process pipe. We only call
1712 wait/reap_process when the process actually terminates.
1714 To reduce the number of places in which Emacs can be hung such that
1715 C-g is not able to interrupt it, we always wait on interrupt_handle
1716 (which is signaled by the input thread when C-g is detected). If we
1717 detect that we were woken up by C-g, we return -1 with errno set to
1718 EINTR as on Unix. */
1720 /* From w32console.c */
1721 extern HANDLE keyboard_handle
;
1723 /* From w32xfns.c */
1724 extern HANDLE interrupt_handle
;
1726 /* From process.c */
1727 extern int proc_buffered_char
[];
1730 sys_select (int nfds
, SELECT_TYPE
*rfds
, SELECT_TYPE
*wfds
, SELECT_TYPE
*efds
,
1731 EMACS_TIME
*timeout
, void *ignored
)
1734 DWORD timeout_ms
, start_time
;
1737 child_process
*cp
, *cps
[MAX_CHILDREN
];
1738 HANDLE wait_hnd
[MAXDESC
+ MAX_CHILDREN
];
1739 int fdindex
[MAXDESC
]; /* mapping from wait handles back to descriptors */
1742 timeout
? (timeout
->tv_sec
* 1000 + timeout
->tv_nsec
/ 1000000) : INFINITE
;
1744 /* If the descriptor sets are NULL but timeout isn't, then just Sleep. */
1745 if (rfds
== NULL
&& wfds
== NULL
&& efds
== NULL
&& timeout
!= NULL
)
1751 /* Otherwise, we only handle rfds, so fail otherwise. */
1752 if (rfds
== NULL
|| wfds
!= NULL
|| efds
!= NULL
)
1762 /* Always wait on interrupt_handle, to detect C-g (quit). */
1763 wait_hnd
[0] = interrupt_handle
;
1766 /* Build a list of pipe handles to wait on. */
1768 for (i
= 0; i
< nfds
; i
++)
1769 if (FD_ISSET (i
, &orfds
))
1773 if (keyboard_handle
)
1775 /* Handle stdin specially */
1776 wait_hnd
[nh
] = keyboard_handle
;
1781 /* Check for any emacs-generated input in the queue since
1782 it won't be detected in the wait */
1783 if (detect_input_pending ())
1791 /* Child process and socket input */
1795 int current_status
= cp
->status
;
1797 if (current_status
== STATUS_READ_ACKNOWLEDGED
)
1799 /* Tell reader thread which file handle to use. */
1801 /* Wake up the reader thread for this process */
1802 cp
->status
= STATUS_READ_READY
;
1803 if (!SetEvent (cp
->char_consumed
))
1804 DebPrint (("nt_select.SetEvent failed with "
1805 "%lu for fd %ld\n", GetLastError (), i
));
1808 #ifdef CHECK_INTERLOCK
1809 /* slightly crude cross-checking of interlock between threads */
1811 current_status
= cp
->status
;
1812 if (WaitForSingleObject (cp
->char_avail
, 0) == WAIT_OBJECT_0
)
1814 /* char_avail has been signaled, so status (which may
1815 have changed) should indicate read has completed
1816 but has not been acknowledged. */
1817 current_status
= cp
->status
;
1818 if (current_status
!= STATUS_READ_SUCCEEDED
1819 && current_status
!= STATUS_READ_FAILED
)
1820 DebPrint (("char_avail set, but read not completed: status %d\n",
1825 /* char_avail has not been signaled, so status should
1826 indicate that read is in progress; small possibility
1827 that read has completed but event wasn't yet signaled
1828 when we tested it (because a context switch occurred
1829 or if running on separate CPUs). */
1830 if (current_status
!= STATUS_READ_READY
1831 && current_status
!= STATUS_READ_IN_PROGRESS
1832 && current_status
!= STATUS_READ_SUCCEEDED
1833 && current_status
!= STATUS_READ_FAILED
)
1834 DebPrint (("char_avail reset, but read status is bad: %d\n",
1838 wait_hnd
[nh
] = cp
->char_avail
;
1840 if (!wait_hnd
[nh
]) emacs_abort ();
1843 DebPrint (("select waiting on child %d fd %d\n",
1844 cp
-child_procs
, i
));
1849 /* Unable to find something to wait on for this fd, skip */
1851 /* Note that this is not a fatal error, and can in fact
1852 happen in unusual circumstances. Specifically, if
1853 sys_spawnve fails, eg. because the program doesn't
1854 exist, and debug-on-error is t so Fsignal invokes a
1855 nested input loop, then the process output pipe is
1856 still included in input_wait_mask with no child_proc
1857 associated with it. (It is removed when the debugger
1858 exits the nested input loop and the error is thrown.) */
1860 DebPrint (("sys_select: fd %ld is invalid! ignoring\n", i
));
1866 /* Add handles of child processes. */
1868 for (cp
= child_procs
+ (child_proc_count
-1); cp
>= child_procs
; cp
--)
1869 /* Some child_procs might be sockets; ignore them. Also some
1870 children may have died already, but we haven't finished reading
1871 the process output; ignore them too. */
1872 if (CHILD_ACTIVE (cp
) && cp
->procinfo
.hProcess
1874 || (fd_info
[cp
->fd
].flags
& FILE_SEND_SIGCHLD
) == 0
1875 || (fd_info
[cp
->fd
].flags
& FILE_AT_EOF
) != 0)
1878 wait_hnd
[nh
+ nc
] = cp
->procinfo
.hProcess
;
1883 /* Nothing to look for, so we didn't find anything */
1891 start_time
= GetTickCount ();
1893 /* Wait for input or child death to be signaled. If user input is
1894 allowed, then also accept window messages. */
1895 if (FD_ISSET (0, &orfds
))
1896 active
= MsgWaitForMultipleObjects (nh
+ nc
, wait_hnd
, FALSE
, timeout_ms
,
1899 active
= WaitForMultipleObjects (nh
+ nc
, wait_hnd
, FALSE
, timeout_ms
);
1901 if (active
== WAIT_FAILED
)
1903 DebPrint (("select.WaitForMultipleObjects (%d, %lu) failed with %lu\n",
1904 nh
+ nc
, timeout_ms
, GetLastError ()));
1905 /* don't return EBADF - this causes wait_reading_process_output to
1906 abort; WAIT_FAILED is returned when single-stepping under
1907 Windows 95 after switching thread focus in debugger, and
1908 possibly at other times. */
1912 else if (active
== WAIT_TIMEOUT
)
1916 else if (active
>= WAIT_OBJECT_0
1917 && active
< WAIT_OBJECT_0
+MAXIMUM_WAIT_OBJECTS
)
1919 active
-= WAIT_OBJECT_0
;
1921 else if (active
>= WAIT_ABANDONED_0
1922 && active
< WAIT_ABANDONED_0
+MAXIMUM_WAIT_OBJECTS
)
1924 active
-= WAIT_ABANDONED_0
;
1929 /* Loop over all handles after active (now officially documented as
1930 being the first signaled handle in the array). We do this to
1931 ensure fairness, so that all channels with data available will be
1932 processed - otherwise higher numbered channels could be starved. */
1935 if (active
== nh
+ nc
)
1937 /* There are messages in the lisp thread's queue; we must
1938 drain the queue now to ensure they are processed promptly,
1939 because if we don't do so, we will not be woken again until
1940 further messages arrive.
1942 NB. If ever we allow window message procedures to callback
1943 into lisp, we will need to ensure messages are dispatched
1944 at a safe time for lisp code to be run (*), and we may also
1945 want to provide some hooks in the dispatch loop to cater
1946 for modeless dialogs created by lisp (ie. to register
1947 window handles to pass to IsDialogMessage).
1949 (*) Note that MsgWaitForMultipleObjects above is an
1950 internal dispatch point for messages that are sent to
1951 windows created by this thread. */
1952 drain_message_queue ();
1954 else if (active
>= nh
)
1956 cp
= cps
[active
- nh
];
1958 /* We cannot always signal SIGCHLD immediately; if we have not
1959 finished reading the process output, we must delay sending
1960 SIGCHLD until we do. */
1962 if (cp
->fd
>= 0 && (fd_info
[cp
->fd
].flags
& FILE_AT_EOF
) == 0)
1963 fd_info
[cp
->fd
].flags
|= FILE_SEND_SIGCHLD
;
1964 /* SIG_DFL for SIGCHLD is ignore */
1965 else if (sig_handlers
[SIGCHLD
] != SIG_DFL
&&
1966 sig_handlers
[SIGCHLD
] != SIG_IGN
)
1969 DebPrint (("select calling SIGCHLD handler for pid %d\n",
1973 sig_handlers
[SIGCHLD
] (SIGCHLD
);
1977 else if (fdindex
[active
] == -1)
1979 /* Quit (C-g) was detected. */
1983 else if (fdindex
[active
] == 0)
1985 /* Keyboard input available */
1991 /* must be a socket or pipe - read ahead should have
1992 completed, either succeeding or failing. */
1993 FD_SET (fdindex
[active
], rfds
);
1997 /* Even though wait_reading_process_output only reads from at most
1998 one channel, we must process all channels here so that we reap
1999 all children that have died. */
2000 while (++active
< nh
+ nc
)
2001 if (WaitForSingleObject (wait_hnd
[active
], 0) == WAIT_OBJECT_0
)
2003 } while (active
< nh
+ nc
);
2005 /* If no input has arrived and timeout hasn't expired, wait again. */
2008 DWORD elapsed
= GetTickCount () - start_time
;
2010 if (timeout_ms
> elapsed
) /* INFINITE is MAX_UINT */
2012 if (timeout_ms
!= INFINITE
)
2013 timeout_ms
-= elapsed
;
2014 goto count_children
;
2021 /* Substitute for certain kill () operations */
2023 static BOOL CALLBACK
2024 find_child_console (HWND hwnd
, LPARAM arg
)
2026 child_process
* cp
= (child_process
*) arg
;
2030 thread_id
= GetWindowThreadProcessId (hwnd
, &process_id
);
2031 if (process_id
== cp
->procinfo
.dwProcessId
)
2033 char window_class
[32];
2035 GetClassName (hwnd
, window_class
, sizeof (window_class
));
2036 if (strcmp (window_class
,
2037 (os_subtype
== OS_9X
)
2039 : "ConsoleWindowClass") == 0)
2049 /* Emulate 'kill', but only for other processes. */
2051 sys_kill (int pid
, int sig
)
2055 int need_to_free
= 0;
2058 /* Only handle signals that will result in the process dying */
2059 if (sig
!= SIGINT
&& sig
!= SIGKILL
&& sig
!= SIGQUIT
&& sig
!= SIGHUP
)
2065 cp
= find_child_pid (pid
);
2068 /* We were passed a PID of something other than our subprocess.
2069 If that is our own PID, we will send to ourself a message to
2070 close the selected frame, which does not necessarily
2071 terminates Emacs. But then we are not supposed to call
2072 sys_kill with our own PID. */
2073 proc_hand
= OpenProcess (PROCESS_TERMINATE
, 0, pid
);
2074 if (proc_hand
== NULL
)
2083 proc_hand
= cp
->procinfo
.hProcess
;
2084 pid
= cp
->procinfo
.dwProcessId
;
2086 /* Try to locate console window for process. */
2087 EnumWindows (find_child_console
, (LPARAM
) cp
);
2090 if (sig
== SIGINT
|| sig
== SIGQUIT
)
2092 if (NILP (Vw32_start_process_share_console
) && cp
&& cp
->hwnd
)
2094 BYTE control_scan_code
= (BYTE
) MapVirtualKey (VK_CONTROL
, 0);
2095 /* Fake Ctrl-C for SIGINT, and Ctrl-Break for SIGQUIT. */
2096 BYTE vk_break_code
= (sig
== SIGINT
) ? 'C' : VK_CANCEL
;
2097 BYTE break_scan_code
= (BYTE
) MapVirtualKey (vk_break_code
, 0);
2098 HWND foreground_window
;
2100 if (break_scan_code
== 0)
2102 /* Fake Ctrl-C for SIGQUIT if we can't manage Ctrl-Break. */
2103 vk_break_code
= 'C';
2104 break_scan_code
= (BYTE
) MapVirtualKey (vk_break_code
, 0);
2107 foreground_window
= GetForegroundWindow ();
2108 if (foreground_window
)
2110 /* NT 5.0, and apparently also Windows 98, will not allow
2111 a Window to be set to foreground directly without the
2112 user's involvement. The workaround is to attach
2113 ourselves to the thread that owns the foreground
2114 window, since that is the only thread that can set the
2115 foreground window. */
2116 DWORD foreground_thread
, child_thread
;
2118 GetWindowThreadProcessId (foreground_window
, NULL
);
2119 if (foreground_thread
== GetCurrentThreadId ()
2120 || !AttachThreadInput (GetCurrentThreadId (),
2121 foreground_thread
, TRUE
))
2122 foreground_thread
= 0;
2124 child_thread
= GetWindowThreadProcessId (cp
->hwnd
, NULL
);
2125 if (child_thread
== GetCurrentThreadId ()
2126 || !AttachThreadInput (GetCurrentThreadId (),
2127 child_thread
, TRUE
))
2130 /* Set the foreground window to the child. */
2131 if (SetForegroundWindow (cp
->hwnd
))
2133 /* Generate keystrokes as if user had typed Ctrl-Break or
2135 keybd_event (VK_CONTROL
, control_scan_code
, 0, 0);
2136 keybd_event (vk_break_code
, break_scan_code
,
2137 (vk_break_code
== 'C' ? 0 : KEYEVENTF_EXTENDEDKEY
), 0);
2138 keybd_event (vk_break_code
, break_scan_code
,
2139 (vk_break_code
== 'C' ? 0 : KEYEVENTF_EXTENDEDKEY
)
2140 | KEYEVENTF_KEYUP
, 0);
2141 keybd_event (VK_CONTROL
, control_scan_code
,
2142 KEYEVENTF_KEYUP
, 0);
2144 /* Sleep for a bit to give time for Emacs frame to respond
2145 to focus change events (if Emacs was active app). */
2148 SetForegroundWindow (foreground_window
);
2150 /* Detach from the foreground and child threads now that
2151 the foreground switching is over. */
2152 if (foreground_thread
)
2153 AttachThreadInput (GetCurrentThreadId (),
2154 foreground_thread
, FALSE
);
2156 AttachThreadInput (GetCurrentThreadId (),
2157 child_thread
, FALSE
);
2160 /* Ctrl-Break is NT equivalent of SIGINT. */
2161 else if (!GenerateConsoleCtrlEvent (CTRL_BREAK_EVENT
, pid
))
2163 DebPrint (("sys_kill.GenerateConsoleCtrlEvent return %d "
2164 "for pid %lu\n", GetLastError (), pid
));
2171 if (NILP (Vw32_start_process_share_console
) && cp
&& cp
->hwnd
)
2174 if (os_subtype
== OS_9X
)
2177 Another possibility is to try terminating the VDM out-right by
2178 calling the Shell VxD (id 0x17) V86 interface, function #4
2179 "SHELL_Destroy_VM", ie.
2185 First need to determine the current VM handle, and then arrange for
2186 the shellapi call to be made from the system vm (by using
2187 Switch_VM_and_callback).
2189 Could try to invoke DestroyVM through CallVxD.
2193 /* On Windows 95, posting WM_QUIT causes the 16-bit subsystem
2194 to hang when cmdproxy is used in conjunction with
2195 command.com for an interactive shell. Posting
2196 WM_CLOSE pops up a dialog that, when Yes is selected,
2197 does the same thing. TerminateProcess is also less
2198 than ideal in that subprocesses tend to stick around
2199 until the machine is shutdown, but at least it
2200 doesn't freeze the 16-bit subsystem. */
2201 PostMessage (cp
->hwnd
, WM_QUIT
, 0xff, 0);
2203 if (!TerminateProcess (proc_hand
, 0xff))
2205 DebPrint (("sys_kill.TerminateProcess returned %d "
2206 "for pid %lu\n", GetLastError (), pid
));
2213 PostMessage (cp
->hwnd
, WM_CLOSE
, 0, 0);
2215 /* Kill the process. On W32 this doesn't kill child processes
2216 so it doesn't work very well for shells which is why it's not
2217 used in every case. */
2218 else if (!TerminateProcess (proc_hand
, 0xff))
2220 DebPrint (("sys_kill.TerminateProcess returned %d "
2221 "for pid %lu\n", GetLastError (), pid
));
2228 CloseHandle (proc_hand
);
2233 /* The following two routines are used to manipulate stdin, stdout, and
2234 stderr of our child processes.
2236 Assuming that in, out, and err are *not* inheritable, we make them
2237 stdin, stdout, and stderr of the child as follows:
2239 - Save the parent's current standard handles.
2240 - Set the std handles to inheritable duplicates of the ones being passed in.
2241 (Note that _get_osfhandle() is an io.h procedure that retrieves the
2242 NT file handle for a crt file descriptor.)
2243 - Spawn the child, which inherits in, out, and err as stdin,
2244 stdout, and stderr. (see Spawnve)
2245 - Close the std handles passed to the child.
2246 - Reset the parent's standard handles to the saved handles.
2247 (see reset_standard_handles)
2248 We assume that the caller closes in, out, and err after calling us. */
2251 prepare_standard_handles (int in
, int out
, int err
, HANDLE handles
[3])
2254 HANDLE newstdin
, newstdout
, newstderr
;
2256 parent
= GetCurrentProcess ();
2258 handles
[0] = GetStdHandle (STD_INPUT_HANDLE
);
2259 handles
[1] = GetStdHandle (STD_OUTPUT_HANDLE
);
2260 handles
[2] = GetStdHandle (STD_ERROR_HANDLE
);
2262 /* make inheritable copies of the new handles */
2263 if (!DuplicateHandle (parent
,
2264 (HANDLE
) _get_osfhandle (in
),
2269 DUPLICATE_SAME_ACCESS
))
2270 report_file_error ("Duplicating input handle for child", Qnil
);
2272 if (!DuplicateHandle (parent
,
2273 (HANDLE
) _get_osfhandle (out
),
2278 DUPLICATE_SAME_ACCESS
))
2279 report_file_error ("Duplicating output handle for child", Qnil
);
2281 if (!DuplicateHandle (parent
,
2282 (HANDLE
) _get_osfhandle (err
),
2287 DUPLICATE_SAME_ACCESS
))
2288 report_file_error ("Duplicating error handle for child", Qnil
);
2290 /* and store them as our std handles */
2291 if (!SetStdHandle (STD_INPUT_HANDLE
, newstdin
))
2292 report_file_error ("Changing stdin handle", Qnil
);
2294 if (!SetStdHandle (STD_OUTPUT_HANDLE
, newstdout
))
2295 report_file_error ("Changing stdout handle", Qnil
);
2297 if (!SetStdHandle (STD_ERROR_HANDLE
, newstderr
))
2298 report_file_error ("Changing stderr handle", Qnil
);
2302 reset_standard_handles (int in
, int out
, int err
, HANDLE handles
[3])
2304 /* close the duplicated handles passed to the child */
2305 CloseHandle (GetStdHandle (STD_INPUT_HANDLE
));
2306 CloseHandle (GetStdHandle (STD_OUTPUT_HANDLE
));
2307 CloseHandle (GetStdHandle (STD_ERROR_HANDLE
));
2309 /* now restore parent's saved std handles */
2310 SetStdHandle (STD_INPUT_HANDLE
, handles
[0]);
2311 SetStdHandle (STD_OUTPUT_HANDLE
, handles
[1]);
2312 SetStdHandle (STD_ERROR_HANDLE
, handles
[2]);
2316 set_process_dir (char * dir
)
2321 /* To avoid problems with winsock implementations that work over dial-up
2322 connections causing or requiring a connection to exist while Emacs is
2323 running, Emacs no longer automatically loads winsock on startup if it
2324 is present. Instead, it will be loaded when open-network-stream is
2327 To allow full control over when winsock is loaded, we provide these
2328 two functions to dynamically load and unload winsock. This allows
2329 dial-up users to only be connected when they actually need to use
2333 extern HANDLE winsock_lib
;
2334 extern BOOL
term_winsock (void);
2335 extern BOOL
init_winsock (int load_now
);
2337 DEFUN ("w32-has-winsock", Fw32_has_winsock
, Sw32_has_winsock
, 0, 1, 0,
2338 doc
: /* Test for presence of the Windows socket library `winsock'.
2339 Returns non-nil if winsock support is present, nil otherwise.
2341 If the optional argument LOAD-NOW is non-nil, the winsock library is
2342 also loaded immediately if not already loaded. If winsock is loaded,
2343 the winsock local hostname is returned (since this may be different from
2344 the value of `system-name' and should supplant it), otherwise t is
2345 returned to indicate winsock support is present. */)
2346 (Lisp_Object load_now
)
2350 have_winsock
= init_winsock (!NILP (load_now
));
2353 if (winsock_lib
!= NULL
)
2355 /* Return new value for system-name. The best way to do this
2356 is to call init_system_name, saving and restoring the
2357 original value to avoid side-effects. */
2358 Lisp_Object orig_hostname
= Vsystem_name
;
2359 Lisp_Object hostname
;
2361 init_system_name ();
2362 hostname
= Vsystem_name
;
2363 Vsystem_name
= orig_hostname
;
2371 DEFUN ("w32-unload-winsock", Fw32_unload_winsock
, Sw32_unload_winsock
,
2373 doc
: /* Unload the Windows socket library `winsock' if loaded.
2374 This is provided to allow dial-up socket connections to be disconnected
2375 when no longer needed. Returns nil without unloading winsock if any
2376 socket connections still exist. */)
2379 return term_winsock () ? Qt
: Qnil
;
2383 /* Some miscellaneous functions that are Windows specific, but not GUI
2384 specific (ie. are applicable in terminal or batch mode as well). */
2386 DEFUN ("w32-short-file-name", Fw32_short_file_name
, Sw32_short_file_name
, 1, 1, 0,
2387 doc
: /* Return the short file name version (8.3) of the full path of FILENAME.
2388 If FILENAME does not exist, return nil.
2389 All path elements in FILENAME are converted to their short names. */)
2390 (Lisp_Object filename
)
2392 char shortname
[MAX_PATH
];
2394 CHECK_STRING (filename
);
2396 /* first expand it. */
2397 filename
= Fexpand_file_name (filename
, Qnil
);
2399 /* luckily, this returns the short version of each element in the path. */
2400 if (GetShortPathName (SDATA (ENCODE_FILE (filename
)), shortname
, MAX_PATH
) == 0)
2403 dostounix_filename (shortname
);
2405 return build_string (shortname
);
2409 DEFUN ("w32-long-file-name", Fw32_long_file_name
, Sw32_long_file_name
,
2411 doc
: /* Return the long file name version of the full path of FILENAME.
2412 If FILENAME does not exist, return nil.
2413 All path elements in FILENAME are converted to their long names. */)
2414 (Lisp_Object filename
)
2416 char longname
[ MAX_PATH
];
2419 CHECK_STRING (filename
);
2421 if (SBYTES (filename
) == 2
2422 && *(SDATA (filename
) + 1) == ':')
2425 /* first expand it. */
2426 filename
= Fexpand_file_name (filename
, Qnil
);
2428 if (!w32_get_long_filename (SDATA (ENCODE_FILE (filename
)), longname
, MAX_PATH
))
2431 dostounix_filename (longname
);
2433 /* If we were passed only a drive, make sure that a slash is not appended
2434 for consistency with directories. Allow for drive mapping via SUBST
2435 in case expand-file-name is ever changed to expand those. */
2436 if (drive_only
&& longname
[1] == ':' && longname
[2] == '/' && !longname
[3])
2439 return DECODE_FILE (build_string (longname
));
2442 DEFUN ("w32-set-process-priority", Fw32_set_process_priority
,
2443 Sw32_set_process_priority
, 2, 2, 0,
2444 doc
: /* Set the priority of PROCESS to PRIORITY.
2445 If PROCESS is nil, the priority of Emacs is changed, otherwise the
2446 priority of the process whose pid is PROCESS is changed.
2447 PRIORITY should be one of the symbols high, normal, or low;
2448 any other symbol will be interpreted as normal.
2450 If successful, the return value is t, otherwise nil. */)
2451 (Lisp_Object process
, Lisp_Object priority
)
2453 HANDLE proc_handle
= GetCurrentProcess ();
2454 DWORD priority_class
= NORMAL_PRIORITY_CLASS
;
2455 Lisp_Object result
= Qnil
;
2457 CHECK_SYMBOL (priority
);
2459 if (!NILP (process
))
2464 CHECK_NUMBER (process
);
2466 /* Allow pid to be an internally generated one, or one obtained
2467 externally. This is necessary because real pids on Windows 95 are
2470 pid
= XINT (process
);
2471 cp
= find_child_pid (pid
);
2473 pid
= cp
->procinfo
.dwProcessId
;
2475 proc_handle
= OpenProcess (PROCESS_SET_INFORMATION
, FALSE
, pid
);
2478 if (EQ (priority
, Qhigh
))
2479 priority_class
= HIGH_PRIORITY_CLASS
;
2480 else if (EQ (priority
, Qlow
))
2481 priority_class
= IDLE_PRIORITY_CLASS
;
2483 if (proc_handle
!= NULL
)
2485 if (SetPriorityClass (proc_handle
, priority_class
))
2487 if (!NILP (process
))
2488 CloseHandle (proc_handle
);
2494 #ifdef HAVE_LANGINFO_CODESET
2495 /* Emulation of nl_langinfo. Used in fns.c:Flocale_info. */
2497 nl_langinfo (nl_item item
)
2499 /* Conversion of Posix item numbers to their Windows equivalents. */
2500 static const LCTYPE w32item
[] = {
2501 LOCALE_IDEFAULTANSICODEPAGE
,
2502 LOCALE_SDAYNAME1
, LOCALE_SDAYNAME2
, LOCALE_SDAYNAME3
,
2503 LOCALE_SDAYNAME4
, LOCALE_SDAYNAME5
, LOCALE_SDAYNAME6
, LOCALE_SDAYNAME7
,
2504 LOCALE_SMONTHNAME1
, LOCALE_SMONTHNAME2
, LOCALE_SMONTHNAME3
,
2505 LOCALE_SMONTHNAME4
, LOCALE_SMONTHNAME5
, LOCALE_SMONTHNAME6
,
2506 LOCALE_SMONTHNAME7
, LOCALE_SMONTHNAME8
, LOCALE_SMONTHNAME9
,
2507 LOCALE_SMONTHNAME10
, LOCALE_SMONTHNAME11
, LOCALE_SMONTHNAME12
2510 static char *nl_langinfo_buf
= NULL
;
2511 static int nl_langinfo_len
= 0;
2513 if (nl_langinfo_len
<= 0)
2514 nl_langinfo_buf
= xmalloc (nl_langinfo_len
= 1);
2516 if (item
< 0 || item
>= _NL_NUM
)
2517 nl_langinfo_buf
[0] = 0;
2520 LCID cloc
= GetThreadLocale ();
2521 int need_len
= GetLocaleInfo (cloc
, w32item
[item
] | LOCALE_USE_CP_ACP
,
2525 nl_langinfo_buf
[0] = 0;
2528 if (item
== CODESET
)
2530 need_len
+= 2; /* for the "cp" prefix */
2531 if (need_len
< 8) /* for the case we call GetACP */
2534 if (nl_langinfo_len
<= need_len
)
2535 nl_langinfo_buf
= xrealloc (nl_langinfo_buf
,
2536 nl_langinfo_len
= need_len
);
2537 if (!GetLocaleInfo (cloc
, w32item
[item
] | LOCALE_USE_CP_ACP
,
2538 nl_langinfo_buf
, nl_langinfo_len
))
2539 nl_langinfo_buf
[0] = 0;
2540 else if (item
== CODESET
)
2542 if (strcmp (nl_langinfo_buf
, "0") == 0 /* CP_ACP */
2543 || strcmp (nl_langinfo_buf
, "1") == 0) /* CP_OEMCP */
2544 sprintf (nl_langinfo_buf
, "cp%u", GetACP ());
2547 memmove (nl_langinfo_buf
+ 2, nl_langinfo_buf
,
2548 strlen (nl_langinfo_buf
) + 1);
2549 nl_langinfo_buf
[0] = 'c';
2550 nl_langinfo_buf
[1] = 'p';
2555 return nl_langinfo_buf
;
2557 #endif /* HAVE_LANGINFO_CODESET */
2559 DEFUN ("w32-get-locale-info", Fw32_get_locale_info
,
2560 Sw32_get_locale_info
, 1, 2, 0,
2561 doc
: /* Return information about the Windows locale LCID.
2562 By default, return a three letter locale code which encodes the default
2563 language as the first two characters, and the country or regional variant
2564 as the third letter. For example, ENU refers to `English (United States)',
2565 while ENC means `English (Canadian)'.
2567 If the optional argument LONGFORM is t, the long form of the locale
2568 name is returned, e.g. `English (United States)' instead; if LONGFORM
2569 is a number, it is interpreted as an LCTYPE constant and the corresponding
2570 locale information is returned.
2572 If LCID (a 16-bit number) is not a valid locale, the result is nil. */)
2573 (Lisp_Object lcid
, Lisp_Object longform
)
2577 char abbrev_name
[32] = { 0 };
2578 char full_name
[256] = { 0 };
2580 CHECK_NUMBER (lcid
);
2582 if (!IsValidLocale (XINT (lcid
), LCID_SUPPORTED
))
2585 if (NILP (longform
))
2587 got_abbrev
= GetLocaleInfo (XINT (lcid
),
2588 LOCALE_SABBREVLANGNAME
| LOCALE_USE_CP_ACP
,
2589 abbrev_name
, sizeof (abbrev_name
));
2591 return build_string (abbrev_name
);
2593 else if (EQ (longform
, Qt
))
2595 got_full
= GetLocaleInfo (XINT (lcid
),
2596 LOCALE_SLANGUAGE
| LOCALE_USE_CP_ACP
,
2597 full_name
, sizeof (full_name
));
2599 return DECODE_SYSTEM (build_string (full_name
));
2601 else if (NUMBERP (longform
))
2603 got_full
= GetLocaleInfo (XINT (lcid
),
2605 full_name
, sizeof (full_name
));
2606 /* GetLocaleInfo's return value includes the terminating null
2607 character, when the returned information is a string, whereas
2608 make_unibyte_string needs the string length without the
2609 terminating null. */
2611 return make_unibyte_string (full_name
, got_full
- 1);
2618 DEFUN ("w32-get-current-locale-id", Fw32_get_current_locale_id
,
2619 Sw32_get_current_locale_id
, 0, 0, 0,
2620 doc
: /* Return Windows locale id for current locale setting.
2621 This is a numerical value; use `w32-get-locale-info' to convert to a
2622 human-readable form. */)
2625 return make_number (GetThreadLocale ());
2629 int_from_hex (char * s
)
2632 static char hex
[] = "0123456789abcdefABCDEF";
2635 while (*s
&& (p
= strchr (hex
, *s
)) != NULL
)
2637 unsigned digit
= p
- hex
;
2640 val
= val
* 16 + digit
;
2646 /* We need to build a global list, since the EnumSystemLocale callback
2647 function isn't given a context pointer. */
2648 Lisp_Object Vw32_valid_locale_ids
;
2650 static BOOL CALLBACK
2651 enum_locale_fn (LPTSTR localeNum
)
2653 DWORD id
= int_from_hex (localeNum
);
2654 Vw32_valid_locale_ids
= Fcons (make_number (id
), Vw32_valid_locale_ids
);
2658 DEFUN ("w32-get-valid-locale-ids", Fw32_get_valid_locale_ids
,
2659 Sw32_get_valid_locale_ids
, 0, 0, 0,
2660 doc
: /* Return list of all valid Windows locale ids.
2661 Each id is a numerical value; use `w32-get-locale-info' to convert to a
2662 human-readable form. */)
2665 Vw32_valid_locale_ids
= Qnil
;
2667 EnumSystemLocales (enum_locale_fn
, LCID_SUPPORTED
);
2669 Vw32_valid_locale_ids
= Fnreverse (Vw32_valid_locale_ids
);
2670 return Vw32_valid_locale_ids
;
2674 DEFUN ("w32-get-default-locale-id", Fw32_get_default_locale_id
, Sw32_get_default_locale_id
, 0, 1, 0,
2675 doc
: /* Return Windows locale id for default locale setting.
2676 By default, the system default locale setting is returned; if the optional
2677 parameter USERP is non-nil, the user default locale setting is returned.
2678 This is a numerical value; use `w32-get-locale-info' to convert to a
2679 human-readable form. */)
2683 return make_number (GetSystemDefaultLCID ());
2684 return make_number (GetUserDefaultLCID ());
2688 DEFUN ("w32-set-current-locale", Fw32_set_current_locale
, Sw32_set_current_locale
, 1, 1, 0,
2689 doc
: /* Make Windows locale LCID be the current locale setting for Emacs.
2690 If successful, the new locale id is returned, otherwise nil. */)
2693 CHECK_NUMBER (lcid
);
2695 if (!IsValidLocale (XINT (lcid
), LCID_SUPPORTED
))
2698 if (!SetThreadLocale (XINT (lcid
)))
2701 /* Need to set input thread locale if present. */
2702 if (dwWindowsThreadId
)
2703 /* Reply is not needed. */
2704 PostThreadMessage (dwWindowsThreadId
, WM_EMACS_SETLOCALE
, XINT (lcid
), 0);
2706 return make_number (GetThreadLocale ());
2710 /* We need to build a global list, since the EnumCodePages callback
2711 function isn't given a context pointer. */
2712 Lisp_Object Vw32_valid_codepages
;
2714 static BOOL CALLBACK
2715 enum_codepage_fn (LPTSTR codepageNum
)
2717 DWORD id
= atoi (codepageNum
);
2718 Vw32_valid_codepages
= Fcons (make_number (id
), Vw32_valid_codepages
);
2722 DEFUN ("w32-get-valid-codepages", Fw32_get_valid_codepages
,
2723 Sw32_get_valid_codepages
, 0, 0, 0,
2724 doc
: /* Return list of all valid Windows codepages. */)
2727 Vw32_valid_codepages
= Qnil
;
2729 EnumSystemCodePages (enum_codepage_fn
, CP_SUPPORTED
);
2731 Vw32_valid_codepages
= Fnreverse (Vw32_valid_codepages
);
2732 return Vw32_valid_codepages
;
2736 DEFUN ("w32-get-console-codepage", Fw32_get_console_codepage
,
2737 Sw32_get_console_codepage
, 0, 0, 0,
2738 doc
: /* Return current Windows codepage for console input. */)
2741 return make_number (GetConsoleCP ());
2745 DEFUN ("w32-set-console-codepage", Fw32_set_console_codepage
,
2746 Sw32_set_console_codepage
, 1, 1, 0,
2747 doc
: /* Make Windows codepage CP be the codepage for Emacs tty keyboard input.
2748 This codepage setting affects keyboard input in tty mode.
2749 If successful, the new CP is returned, otherwise nil. */)
2754 if (!IsValidCodePage (XINT (cp
)))
2757 if (!SetConsoleCP (XINT (cp
)))
2760 return make_number (GetConsoleCP ());
2764 DEFUN ("w32-get-console-output-codepage", Fw32_get_console_output_codepage
,
2765 Sw32_get_console_output_codepage
, 0, 0, 0,
2766 doc
: /* Return current Windows codepage for console output. */)
2769 return make_number (GetConsoleOutputCP ());
2773 DEFUN ("w32-set-console-output-codepage", Fw32_set_console_output_codepage
,
2774 Sw32_set_console_output_codepage
, 1, 1, 0,
2775 doc
: /* Make Windows codepage CP be the codepage for Emacs console output.
2776 This codepage setting affects display in tty mode.
2777 If successful, the new CP is returned, otherwise nil. */)
2782 if (!IsValidCodePage (XINT (cp
)))
2785 if (!SetConsoleOutputCP (XINT (cp
)))
2788 return make_number (GetConsoleOutputCP ());
2792 DEFUN ("w32-get-codepage-charset", Fw32_get_codepage_charset
,
2793 Sw32_get_codepage_charset
, 1, 1, 0,
2794 doc
: /* Return charset ID corresponding to codepage CP.
2795 Returns nil if the codepage is not valid. */)
2802 if (!IsValidCodePage (XINT (cp
)))
2805 if (TranslateCharsetInfo ((DWORD
*) XINT (cp
), &info
, TCI_SRCCODEPAGE
))
2806 return make_number (info
.ciCharset
);
2812 DEFUN ("w32-get-valid-keyboard-layouts", Fw32_get_valid_keyboard_layouts
,
2813 Sw32_get_valid_keyboard_layouts
, 0, 0, 0,
2814 doc
: /* Return list of Windows keyboard languages and layouts.
2815 The return value is a list of pairs of language id and layout id. */)
2818 int num_layouts
= GetKeyboardLayoutList (0, NULL
);
2819 HKL
* layouts
= (HKL
*) alloca (num_layouts
* sizeof (HKL
));
2820 Lisp_Object obj
= Qnil
;
2822 if (GetKeyboardLayoutList (num_layouts
, layouts
) == num_layouts
)
2824 while (--num_layouts
>= 0)
2826 DWORD kl
= (DWORD
) layouts
[num_layouts
];
2828 obj
= Fcons (Fcons (make_number (kl
& 0xffff),
2829 make_number ((kl
>> 16) & 0xffff)),
2838 DEFUN ("w32-get-keyboard-layout", Fw32_get_keyboard_layout
,
2839 Sw32_get_keyboard_layout
, 0, 0, 0,
2840 doc
: /* Return current Windows keyboard language and layout.
2841 The return value is the cons of the language id and the layout id. */)
2844 DWORD kl
= (DWORD
) GetKeyboardLayout (dwWindowsThreadId
);
2846 return Fcons (make_number (kl
& 0xffff),
2847 make_number ((kl
>> 16) & 0xffff));
2851 DEFUN ("w32-set-keyboard-layout", Fw32_set_keyboard_layout
,
2852 Sw32_set_keyboard_layout
, 1, 1, 0,
2853 doc
: /* Make LAYOUT be the current keyboard layout for Emacs.
2854 The keyboard layout setting affects interpretation of keyboard input.
2855 If successful, the new layout id is returned, otherwise nil. */)
2856 (Lisp_Object layout
)
2860 CHECK_CONS (layout
);
2861 CHECK_NUMBER_CAR (layout
);
2862 CHECK_NUMBER_CDR (layout
);
2864 kl
= (XINT (XCAR (layout
)) & 0xffff)
2865 | (XINT (XCDR (layout
)) << 16);
2867 /* Synchronize layout with input thread. */
2868 if (dwWindowsThreadId
)
2870 if (PostThreadMessage (dwWindowsThreadId
, WM_EMACS_SETKEYBOARDLAYOUT
,
2874 GetMessage (&msg
, NULL
, WM_EMACS_DONE
, WM_EMACS_DONE
);
2876 if (msg
.wParam
== 0)
2880 else if (!ActivateKeyboardLayout ((HKL
) kl
, 0))
2883 return Fw32_get_keyboard_layout ();
2888 syms_of_ntproc (void)
2890 DEFSYM (Qhigh
, "high");
2891 DEFSYM (Qlow
, "low");
2893 defsubr (&Sw32_has_winsock
);
2894 defsubr (&Sw32_unload_winsock
);
2896 defsubr (&Sw32_short_file_name
);
2897 defsubr (&Sw32_long_file_name
);
2898 defsubr (&Sw32_set_process_priority
);
2899 defsubr (&Sw32_get_locale_info
);
2900 defsubr (&Sw32_get_current_locale_id
);
2901 defsubr (&Sw32_get_default_locale_id
);
2902 defsubr (&Sw32_get_valid_locale_ids
);
2903 defsubr (&Sw32_set_current_locale
);
2905 defsubr (&Sw32_get_console_codepage
);
2906 defsubr (&Sw32_set_console_codepage
);
2907 defsubr (&Sw32_get_console_output_codepage
);
2908 defsubr (&Sw32_set_console_output_codepage
);
2909 defsubr (&Sw32_get_valid_codepages
);
2910 defsubr (&Sw32_get_codepage_charset
);
2912 defsubr (&Sw32_get_valid_keyboard_layouts
);
2913 defsubr (&Sw32_get_keyboard_layout
);
2914 defsubr (&Sw32_set_keyboard_layout
);
2916 DEFVAR_LISP ("w32-quote-process-args", Vw32_quote_process_args
,
2917 doc
: /* Non-nil enables quoting of process arguments to ensure correct parsing.
2918 Because Windows does not directly pass argv arrays to child processes,
2919 programs have to reconstruct the argv array by parsing the command
2920 line string. For an argument to contain a space, it must be enclosed
2921 in double quotes or it will be parsed as multiple arguments.
2923 If the value is a character, that character will be used to escape any
2924 quote characters that appear, otherwise a suitable escape character
2925 will be chosen based on the type of the program. */);
2926 Vw32_quote_process_args
= Qt
;
2928 DEFVAR_LISP ("w32-start-process-show-window",
2929 Vw32_start_process_show_window
,
2930 doc
: /* When nil, new child processes hide their windows.
2931 When non-nil, they show their window in the method of their choice.
2932 This variable doesn't affect GUI applications, which will never be hidden. */);
2933 Vw32_start_process_show_window
= Qnil
;
2935 DEFVAR_LISP ("w32-start-process-share-console",
2936 Vw32_start_process_share_console
,
2937 doc
: /* When nil, new child processes are given a new console.
2938 When non-nil, they share the Emacs console; this has the limitation of
2939 allowing only one DOS subprocess to run at a time (whether started directly
2940 or indirectly by Emacs), and preventing Emacs from cleanly terminating the
2941 subprocess group, but may allow Emacs to interrupt a subprocess that doesn't
2942 otherwise respond to interrupts from Emacs. */);
2943 Vw32_start_process_share_console
= Qnil
;
2945 DEFVAR_LISP ("w32-start-process-inherit-error-mode",
2946 Vw32_start_process_inherit_error_mode
,
2947 doc
: /* When nil, new child processes revert to the default error mode.
2948 When non-nil, they inherit their error mode setting from Emacs, which stops
2949 them blocking when trying to access unmounted drives etc. */);
2950 Vw32_start_process_inherit_error_mode
= Qt
;
2952 DEFVAR_INT ("w32-pipe-read-delay", w32_pipe_read_delay
,
2953 doc
: /* Forced delay before reading subprocess output.
2954 This is done to improve the buffering of subprocess output, by
2955 avoiding the inefficiency of frequently reading small amounts of data.
2957 If positive, the value is the number of milliseconds to sleep before
2958 reading the subprocess output. If negative, the magnitude is the number
2959 of time slices to wait (effectively boosting the priority of the child
2960 process temporarily). A value of zero disables waiting entirely. */);
2961 w32_pipe_read_delay
= 50;
2963 DEFVAR_LISP ("w32-downcase-file-names", Vw32_downcase_file_names
,
2964 doc
: /* Non-nil means convert all-upper case file names to lower case.
2965 This applies when performing completions and file name expansion.
2966 Note that the value of this setting also affects remote file names,
2967 so you probably don't want to set to non-nil if you use case-sensitive
2968 filesystems via ange-ftp. */);
2969 Vw32_downcase_file_names
= Qnil
;
2972 DEFVAR_LISP ("w32-generate-fake-inodes", Vw32_generate_fake_inodes
,
2973 doc
: /* Non-nil means attempt to fake realistic inode values.
2974 This works by hashing the truename of files, and should detect
2975 aliasing between long and short (8.3 DOS) names, but can have
2976 false positives because of hash collisions. Note that determining
2977 the truename of a file can be slow. */);
2978 Vw32_generate_fake_inodes
= Qnil
;
2981 DEFVAR_LISP ("w32-get-true-file-attributes", Vw32_get_true_file_attributes
,
2982 doc
: /* Non-nil means determine accurate file attributes in `file-attributes'.
2983 This option controls whether to issue additional system calls to determine
2984 accurate link counts, file type, and ownership information. It is more
2985 useful for files on NTFS volumes, where hard links and file security are
2986 supported, than on volumes of the FAT family.
2988 Without these system calls, link count will always be reported as 1 and file
2989 ownership will be attributed to the current user.
2990 The default value `local' means only issue these system calls for files
2991 on local fixed drives. A value of nil means never issue them.
2992 Any other non-nil value means do this even on remote and removable drives
2993 where the performance impact may be noticeable even on modern hardware. */);
2994 Vw32_get_true_file_attributes
= Qlocal
;
2996 staticpro (&Vw32_valid_locale_ids
);
2997 staticpro (&Vw32_valid_codepages
);
2999 /* end of w32proc.c */