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 DWORD result
= SuspendThread (itimer
->caller_thread
);
436 if (result
== (DWORD
)-1)
440 ResumeThread (itimer
->caller_thread
);
443 /* Update expiration time and loop. */
444 EnterCriticalSection (crit
);
445 expire
= itimer
->expire
;
448 LeaveCriticalSection (crit
);
451 reload
= itimer
->reload
;
454 now
= w32_get_timer_time (hth
);
457 ULONGLONG lag
= now
- expire
;
459 /* If we missed some opportunities (presumably while
460 sleeping or while the signal handler ran), skip
463 expire
= now
- (lag
% reload
);
469 expire
= 0; /* become idle */
470 itimer
->expire
= expire
;
471 LeaveCriticalSection (crit
);
477 stop_timer_thread (int which
)
479 struct itimer_data
*itimer
=
480 (which
== ITIMER_REAL
) ? &real_itimer
: &prof_itimer
;
482 DWORD err
, exit_code
= 255;
485 /* Signal the thread that it should terminate. */
486 itimer
->terminate
= 1;
488 if (itimer
->timer_thread
== NULL
)
491 /* Wait for the timer thread to terminate voluntarily, then kill it
492 if it doesn't. This loop waits twice more than the maximum
493 amount of time a timer thread sleeps, see above. */
494 for (i
= 0; i
< MAX_SINGLE_SLEEP
/ 5; i
++)
496 if (!((status
= GetExitCodeThread (itimer
->timer_thread
, &exit_code
))
497 && exit_code
== STILL_ACTIVE
))
501 if ((status
== FALSE
&& (err
= GetLastError ()) == ERROR_INVALID_HANDLE
)
502 || exit_code
== STILL_ACTIVE
)
504 if (!(status
== FALSE
&& err
== ERROR_INVALID_HANDLE
))
505 TerminateThread (itimer
->timer_thread
, 0);
509 CloseHandle (itimer
->timer_thread
);
510 itimer
->timer_thread
= NULL
;
511 if (itimer
->caller_thread
)
513 CloseHandle (itimer
->caller_thread
);
514 itimer
->caller_thread
= NULL
;
518 /* This is called at shutdown time from term_ntproc. */
522 if (real_itimer
.timer_thread
)
523 stop_timer_thread (ITIMER_REAL
);
524 if (prof_itimer
.timer_thread
)
525 stop_timer_thread (ITIMER_PROF
);
527 /* We are going to delete the critical sections, so timers cannot
531 DeleteCriticalSection (&crit_real
);
532 DeleteCriticalSection (&crit_prof
);
533 DeleteCriticalSection (&crit_sig
);
536 /* This is called at initialization time from init_ntproc. */
540 /* GetThreadTimes is not available on all versions of Windows, so
541 need to probe for its availability dynamically, and call it
542 through a pointer. */
543 s_pfn_Get_Thread_Times
= NULL
; /* in case dumped Emacs comes with a value */
544 if (os_subtype
!= OS_9X
)
545 s_pfn_Get_Thread_Times
=
546 (GetThreadTimes_Proc
)GetProcAddress (GetModuleHandle ("kernel32.dll"),
549 /* Make sure we start with zeroed out itimer structures, since
550 dumping may have left there traces of threads long dead. */
551 memset (&real_itimer
, 0, sizeof real_itimer
);
552 memset (&prof_itimer
, 0, sizeof prof_itimer
);
554 InitializeCriticalSection (&crit_real
);
555 InitializeCriticalSection (&crit_prof
);
556 InitializeCriticalSection (&crit_sig
);
562 start_timer_thread (int which
)
565 struct itimer_data
*itimer
=
566 (which
== ITIMER_REAL
) ? &real_itimer
: &prof_itimer
;
568 if (itimer
->timer_thread
569 && GetExitCodeThread (itimer
->timer_thread
, &exit_code
)
570 && exit_code
== STILL_ACTIVE
)
573 /* Start a new thread. */
574 itimer
->terminate
= 0;
575 itimer
->type
= which
;
576 /* Request that no more than 64KB of stack be reserved for this
577 thread, to avoid reserving too much memory, which would get in
578 the way of threads we start to wait for subprocesses. See also
580 itimer
->timer_thread
= CreateThread (NULL
, 64 * 1024, timer_loop
,
581 (void *)itimer
, 0x00010000, NULL
);
583 if (!itimer
->timer_thread
)
585 CloseHandle (itimer
->caller_thread
);
586 itimer
->caller_thread
= NULL
;
591 /* This is needed to make sure that the timer thread running for
592 profiling gets CPU as soon as the Sleep call terminates. */
593 if (which
== ITIMER_PROF
)
594 SetThreadPriority (itimer
->caller_thread
, THREAD_PRIORITY_TIME_CRITICAL
);
599 /* Most of the code of getitimer and setitimer (but not of their
600 subroutines) was shamelessly stolen from itimer.c in the DJGPP
601 library, see www.delorie.com/djgpp. */
603 getitimer (int which
, struct itimerval
*value
)
605 volatile ULONGLONG
*t_expire
;
606 volatile ULONGLONG
*t_reload
;
607 ULONGLONG expire
, reload
;
609 CRITICAL_SECTION
*crit
;
610 struct itimer_data
*itimer
;
621 if (which
!= ITIMER_REAL
&& which
!= ITIMER_PROF
)
627 itimer
= (which
== ITIMER_REAL
) ? &real_itimer
: &prof_itimer
;
629 if (!DuplicateHandle (GetCurrentProcess (), GetCurrentThread (),
630 GetCurrentProcess (), &itimer
->caller_thread
, 0,
631 FALSE
, DUPLICATE_SAME_ACCESS
))
637 ticks_now
= w32_get_timer_time ((which
== ITIMER_REAL
)
639 : itimer
->caller_thread
);
641 t_expire
= &itimer
->expire
;
642 t_reload
= &itimer
->reload
;
643 crit
= (which
== ITIMER_REAL
) ? &crit_real
: &crit_prof
;
645 EnterCriticalSection (crit
);
648 LeaveCriticalSection (crit
);
653 value
->it_value
.tv_sec
= expire
/ TIMER_TICKS_PER_SEC
;
655 (expire
% TIMER_TICKS_PER_SEC
) * (__int64
)1000000 / TIMER_TICKS_PER_SEC
;
656 value
->it_value
.tv_usec
= usecs
;
657 value
->it_interval
.tv_sec
= reload
/ TIMER_TICKS_PER_SEC
;
659 (reload
% TIMER_TICKS_PER_SEC
) * (__int64
)1000000 / TIMER_TICKS_PER_SEC
;
660 value
->it_interval
.tv_usec
= usecs
;
666 setitimer(int which
, struct itimerval
*value
, struct itimerval
*ovalue
)
668 volatile ULONGLONG
*t_expire
, *t_reload
;
669 ULONGLONG expire
, reload
, expire_old
, reload_old
;
671 CRITICAL_SECTION
*crit
;
672 struct itimerval tem
, *ptem
;
677 /* Posix systems expect timer values smaller than the resolution of
678 the system clock be rounded up to the clock resolution. First
679 time we are called, measure the clock tick resolution. */
684 for (t1
= w32_get_timer_time (NULL
);
685 (t2
= w32_get_timer_time (NULL
)) == t1
; )
687 clocks_min
= t2
- t1
;
695 if (getitimer (which
, ptem
)) /* also sets ticks_now */
696 return -1; /* errno already set */
699 (which
== ITIMER_REAL
) ? &real_itimer
.expire
: &prof_itimer
.expire
;
701 (which
== ITIMER_REAL
) ? &real_itimer
.reload
: &prof_itimer
.reload
;
703 crit
= (which
== ITIMER_REAL
) ? &crit_real
: &crit_prof
;
706 || (value
->it_value
.tv_sec
== 0 && value
->it_value
.tv_usec
== 0))
708 EnterCriticalSection (crit
);
709 /* Disable the timer. */
712 LeaveCriticalSection (crit
);
716 reload
= value
->it_interval
.tv_sec
* TIMER_TICKS_PER_SEC
;
718 usecs
= value
->it_interval
.tv_usec
;
719 if (value
->it_interval
.tv_sec
== 0
720 && usecs
&& usecs
* TIMER_TICKS_PER_SEC
< clocks_min
* 1000000)
724 usecs
*= TIMER_TICKS_PER_SEC
;
725 reload
+= usecs
/ 1000000;
728 expire
= value
->it_value
.tv_sec
* TIMER_TICKS_PER_SEC
;
729 usecs
= value
->it_value
.tv_usec
;
730 if (value
->it_value
.tv_sec
== 0
731 && usecs
* TIMER_TICKS_PER_SEC
< clocks_min
* 1000000)
735 usecs
*= TIMER_TICKS_PER_SEC
;
736 expire
+= usecs
/ 1000000;
741 EnterCriticalSection (crit
);
742 expire_old
= *t_expire
;
743 reload_old
= *t_reload
;
744 if (!(expire
== expire_old
&& reload
== reload_old
))
749 LeaveCriticalSection (crit
);
751 return start_timer_thread (which
);
757 #ifdef HAVE_SETITIMER
758 struct itimerval new_values
, old_values
;
760 new_values
.it_value
.tv_sec
= seconds
;
761 new_values
.it_value
.tv_usec
= 0;
762 new_values
.it_interval
.tv_sec
= new_values
.it_interval
.tv_usec
= 0;
764 if (setitimer (ITIMER_REAL
, &new_values
, &old_values
) < 0)
766 return old_values
.it_value
.tv_sec
;
772 /* Defined in <process.h> which conflicts with the local copy */
775 /* Child process management list. */
776 int child_proc_count
= 0;
777 child_process child_procs
[ MAX_CHILDREN
];
778 child_process
*dead_child
= NULL
;
780 static DWORD WINAPI
reader_thread (void *arg
);
782 /* Find an unused process slot. */
789 for (cp
= child_procs
+ (child_proc_count
-1); cp
>= child_procs
; cp
--)
790 if (!CHILD_ACTIVE (cp
))
792 if (child_proc_count
== MAX_CHILDREN
)
794 cp
= &child_procs
[child_proc_count
++];
797 memset (cp
, 0, sizeof (*cp
));
800 cp
->procinfo
.hProcess
= NULL
;
801 cp
->status
= STATUS_READ_ERROR
;
803 /* use manual reset event so that select() will function properly */
804 cp
->char_avail
= CreateEvent (NULL
, TRUE
, FALSE
, NULL
);
807 cp
->char_consumed
= CreateEvent (NULL
, FALSE
, FALSE
, NULL
);
808 if (cp
->char_consumed
)
810 /* The 0x00010000 flag is STACK_SIZE_PARAM_IS_A_RESERVATION.
811 It means that the 64K stack we are requesting in the 2nd
812 argument is how much memory should be reserved for the
813 stack. If we don't use this flag, the memory requested
814 by the 2nd argument is the amount actually _committed_,
815 but Windows reserves 8MB of memory for each thread's
816 stack. (The 8MB figure comes from the -stack
817 command-line argument we pass to the linker when building
818 Emacs, but that's because we need a large stack for
819 Emacs's main thread.) Since we request 2GB of reserved
820 memory at startup (see w32heap.c), which is close to the
821 maximum memory available for a 32-bit process on Windows,
822 the 8MB reservation for each thread causes failures in
823 starting subprocesses, because we create a thread running
824 reader_thread for each subprocess. As 8MB of stack is
825 way too much for reader_thread, forcing Windows to
826 reserve less wins the day. */
827 cp
->thrd
= CreateThread (NULL
, 64 * 1024, reader_thread
, cp
,
838 delete_child (child_process
*cp
)
842 /* Should not be deleting a child that is still needed. */
843 for (i
= 0; i
< MAXDESC
; i
++)
844 if (fd_info
[i
].cp
== cp
)
847 if (!CHILD_ACTIVE (cp
))
850 /* reap thread if necessary */
855 if (GetExitCodeThread (cp
->thrd
, &rc
) && rc
== STILL_ACTIVE
)
857 /* let the thread exit cleanly if possible */
858 cp
->status
= STATUS_READ_ERROR
;
859 SetEvent (cp
->char_consumed
);
861 /* We used to forcibly terminate the thread here, but it
862 is normally unnecessary, and in abnormal cases, the worst that
863 will happen is we have an extra idle thread hanging around
864 waiting for the zombie process. */
865 if (WaitForSingleObject (cp
->thrd
, 1000) != WAIT_OBJECT_0
)
867 DebPrint (("delete_child.WaitForSingleObject (thread) failed "
868 "with %lu for fd %ld\n", GetLastError (), cp
->fd
));
869 TerminateThread (cp
->thrd
, 0);
873 CloseHandle (cp
->thrd
);
878 CloseHandle (cp
->char_avail
);
879 cp
->char_avail
= NULL
;
881 if (cp
->char_consumed
)
883 CloseHandle (cp
->char_consumed
);
884 cp
->char_consumed
= NULL
;
887 /* update child_proc_count (highest numbered slot in use plus one) */
888 if (cp
== child_procs
+ child_proc_count
- 1)
890 for (i
= child_proc_count
-1; i
>= 0; i
--)
891 if (CHILD_ACTIVE (&child_procs
[i
]))
893 child_proc_count
= i
+ 1;
898 child_proc_count
= 0;
901 /* Find a child by pid. */
902 static child_process
*
903 find_child_pid (DWORD pid
)
907 for (cp
= child_procs
+ (child_proc_count
-1); cp
>= child_procs
; cp
--)
908 if (CHILD_ACTIVE (cp
) && pid
== cp
->pid
)
914 /* Thread proc for child process and socket reader threads. Each thread
915 is normally blocked until woken by select() to check for input by
916 reading one char. When the read completes, char_avail is signaled
917 to wake up the select emulator and the thread blocks itself again. */
919 reader_thread (void *arg
)
924 cp
= (child_process
*)arg
;
926 /* We have to wait for the go-ahead before we can start */
928 || WaitForSingleObject (cp
->char_consumed
, INFINITE
) != WAIT_OBJECT_0
936 if (fd_info
[cp
->fd
].flags
& FILE_LISTEN
)
937 rc
= _sys_wait_accept (cp
->fd
);
939 rc
= _sys_read_ahead (cp
->fd
);
941 /* The name char_avail is a misnomer - it really just means the
942 read-ahead has completed, whether successfully or not. */
943 if (!SetEvent (cp
->char_avail
))
945 DebPrint (("reader_thread.SetEvent failed with %lu for fd %ld\n",
946 GetLastError (), cp
->fd
));
950 if (rc
== STATUS_READ_ERROR
)
953 /* If the read died, the child has died so let the thread die */
954 if (rc
== STATUS_READ_FAILED
)
957 /* Wait until our input is acknowledged before reading again */
958 if (WaitForSingleObject (cp
->char_consumed
, INFINITE
) != WAIT_OBJECT_0
)
960 DebPrint (("reader_thread.WaitForSingleObject failed with "
961 "%lu for fd %ld\n", GetLastError (), cp
->fd
));
968 /* To avoid Emacs changing directory, we just record here the directory
969 the new process should start in. This is set just before calling
970 sys_spawnve, and is not generally valid at any other time. */
971 static char * process_dir
;
974 create_child (char *exe
, char *cmdline
, char *env
, int is_gui_app
,
975 int * pPid
, child_process
*cp
)
978 SECURITY_ATTRIBUTES sec_attrs
;
980 SECURITY_DESCRIPTOR sec_desc
;
983 char dir
[ MAXPATHLEN
];
985 if (cp
== NULL
) emacs_abort ();
987 memset (&start
, 0, sizeof (start
));
988 start
.cb
= sizeof (start
);
991 if (NILP (Vw32_start_process_show_window
) && !is_gui_app
)
992 start
.dwFlags
= STARTF_USESTDHANDLES
| STARTF_USESHOWWINDOW
;
994 start
.dwFlags
= STARTF_USESTDHANDLES
;
995 start
.wShowWindow
= SW_HIDE
;
997 start
.hStdInput
= GetStdHandle (STD_INPUT_HANDLE
);
998 start
.hStdOutput
= GetStdHandle (STD_OUTPUT_HANDLE
);
999 start
.hStdError
= GetStdHandle (STD_ERROR_HANDLE
);
1000 #endif /* HAVE_NTGUI */
1003 /* Explicitly specify no security */
1004 if (!InitializeSecurityDescriptor (&sec_desc
, SECURITY_DESCRIPTOR_REVISION
))
1006 if (!SetSecurityDescriptorDacl (&sec_desc
, TRUE
, NULL
, FALSE
))
1009 sec_attrs
.nLength
= sizeof (sec_attrs
);
1010 sec_attrs
.lpSecurityDescriptor
= NULL
/* &sec_desc */;
1011 sec_attrs
.bInheritHandle
= FALSE
;
1013 strcpy (dir
, process_dir
);
1014 unixtodos_filename (dir
);
1016 flags
= (!NILP (Vw32_start_process_share_console
)
1017 ? CREATE_NEW_PROCESS_GROUP
1018 : CREATE_NEW_CONSOLE
);
1019 if (NILP (Vw32_start_process_inherit_error_mode
))
1020 flags
|= CREATE_DEFAULT_ERROR_MODE
;
1021 if (!CreateProcess (exe
, cmdline
, &sec_attrs
, NULL
, TRUE
,
1022 flags
, env
, dir
, &start
, &cp
->procinfo
))
1025 cp
->pid
= (int) cp
->procinfo
.dwProcessId
;
1027 /* Hack for Windows 95, which assigns large (ie negative) pids */
1031 /* pid must fit in a Lisp_Int */
1032 cp
->pid
= cp
->pid
& INTMASK
;
1039 DebPrint (("create_child.CreateProcess failed: %ld\n", GetLastError ()););
1043 /* create_child doesn't know what emacs' file handle will be for waiting
1044 on output from the child, so we need to make this additional call
1045 to register the handle with the process
1046 This way the select emulator knows how to match file handles with
1047 entries in child_procs. */
1049 register_child (int pid
, int fd
)
1053 cp
= find_child_pid (pid
);
1056 DebPrint (("register_child unable to find pid %lu\n", pid
));
1061 DebPrint (("register_child registered fd %d with pid %lu\n", fd
, pid
));
1066 /* thread is initially blocked until select is called; set status so
1067 that select will release thread */
1068 cp
->status
= STATUS_READ_ACKNOWLEDGED
;
1070 /* attach child_process to fd_info */
1071 if (fd_info
[fd
].cp
!= NULL
)
1073 DebPrint (("register_child: fd_info[%d] apparently in use!\n", fd
));
1077 fd_info
[fd
].cp
= cp
;
1080 /* When a process dies its pipe will break so the reader thread will
1081 signal failure to the select emulator.
1082 The select emulator then calls this routine to clean up.
1083 Since the thread signaled failure we can assume it is exiting. */
1085 reap_subprocess (child_process
*cp
)
1087 if (cp
->procinfo
.hProcess
)
1089 /* Reap the process */
1091 /* Process should have already died before we are called. */
1092 if (WaitForSingleObject (cp
->procinfo
.hProcess
, 0) != WAIT_OBJECT_0
)
1093 DebPrint (("reap_subprocess: child fpr fd %d has not died yet!", cp
->fd
));
1095 CloseHandle (cp
->procinfo
.hProcess
);
1096 cp
->procinfo
.hProcess
= NULL
;
1097 CloseHandle (cp
->procinfo
.hThread
);
1098 cp
->procinfo
.hThread
= NULL
;
1101 /* For asynchronous children, the child_proc resources will be freed
1102 when the last pipe read descriptor is closed; for synchronous
1103 children, we must explicitly free the resources now because
1104 register_child has not been called. */
1109 /* Wait for any of our existing child processes to die
1110 When it does, close its handle
1111 Return the pid and fill in the status if non-NULL. */
1114 sys_wait (int *status
)
1116 DWORD active
, retval
;
1119 child_process
*cp
, *cps
[MAX_CHILDREN
];
1120 HANDLE wait_hnd
[MAX_CHILDREN
];
1123 if (dead_child
!= NULL
)
1125 /* We want to wait for a specific child */
1126 wait_hnd
[nh
] = dead_child
->procinfo
.hProcess
;
1127 cps
[nh
] = dead_child
;
1128 if (!wait_hnd
[nh
]) emacs_abort ();
1135 for (cp
= child_procs
+ (child_proc_count
-1); cp
>= child_procs
; cp
--)
1136 /* some child_procs might be sockets; ignore them */
1137 if (CHILD_ACTIVE (cp
) && cp
->procinfo
.hProcess
1138 && (cp
->fd
< 0 || (fd_info
[cp
->fd
].flags
& FILE_AT_EOF
) != 0))
1140 wait_hnd
[nh
] = cp
->procinfo
.hProcess
;
1148 /* Nothing to wait on, so fail */
1155 /* Check for quit about once a second. */
1157 active
= WaitForMultipleObjects (nh
, wait_hnd
, FALSE
, 1000);
1158 } while (active
== WAIT_TIMEOUT
);
1160 if (active
== WAIT_FAILED
)
1165 else if (active
>= WAIT_OBJECT_0
1166 && active
< WAIT_OBJECT_0
+MAXIMUM_WAIT_OBJECTS
)
1168 active
-= WAIT_OBJECT_0
;
1170 else if (active
>= WAIT_ABANDONED_0
1171 && active
< WAIT_ABANDONED_0
+MAXIMUM_WAIT_OBJECTS
)
1173 active
-= WAIT_ABANDONED_0
;
1179 if (!GetExitCodeProcess (wait_hnd
[active
], &retval
))
1181 DebPrint (("Wait.GetExitCodeProcess failed with %lu\n",
1185 if (retval
== STILL_ACTIVE
)
1187 /* Should never happen */
1188 DebPrint (("Wait.WaitForMultipleObjects returned an active process\n"));
1193 /* Massage the exit code from the process to match the format expected
1194 by the WIFSTOPPED et al macros in syswait.h. Only WIFSIGNALED and
1195 WIFEXITED are supported; WIFSTOPPED doesn't make sense under NT. */
1197 if (retval
== STATUS_CONTROL_C_EXIT
)
1205 DebPrint (("Wait signaled with process pid %d\n", cp
->pid
));
1212 else if (synch_process_alive
)
1214 synch_process_alive
= 0;
1216 /* Report the status of the synchronous process. */
1217 if (WIFEXITED (retval
))
1218 synch_process_retcode
= WEXITSTATUS (retval
);
1219 else if (WIFSIGNALED (retval
))
1221 int code
= WTERMSIG (retval
);
1222 const char *signame
;
1224 synchronize_system_messages_locale ();
1225 signame
= strsignal (code
);
1228 signame
= "unknown";
1230 synch_process_death
= signame
;
1233 reap_subprocess (cp
);
1236 reap_subprocess (cp
);
1241 /* Old versions of w32api headers don't have separate 32-bit and
1242 64-bit defines, but the one they have matches the 32-bit variety. */
1243 #ifndef IMAGE_NT_OPTIONAL_HDR32_MAGIC
1244 # define IMAGE_NT_OPTIONAL_HDR32_MAGIC IMAGE_NT_OPTIONAL_HDR_MAGIC
1245 # define IMAGE_OPTIONAL_HEADER32 IMAGE_OPTIONAL_HEADER
1249 w32_executable_type (char * filename
,
1251 int * is_cygnus_app
,
1254 file_data executable
;
1257 /* Default values in case we can't tell for sure. */
1258 *is_dos_app
= FALSE
;
1259 *is_cygnus_app
= FALSE
;
1260 *is_gui_app
= FALSE
;
1262 if (!open_input_file (&executable
, filename
))
1265 p
= strrchr (filename
, '.');
1267 /* We can only identify DOS .com programs from the extension. */
1268 if (p
&& xstrcasecmp (p
, ".com") == 0)
1270 else if (p
&& (xstrcasecmp (p
, ".bat") == 0
1271 || xstrcasecmp (p
, ".cmd") == 0))
1273 /* A DOS shell script - it appears that CreateProcess is happy to
1274 accept this (somewhat surprisingly); presumably it looks at
1275 COMSPEC to determine what executable to actually invoke.
1276 Therefore, we have to do the same here as well. */
1277 /* Actually, I think it uses the program association for that
1278 extension, which is defined in the registry. */
1279 p
= egetenv ("COMSPEC");
1281 w32_executable_type (p
, is_dos_app
, is_cygnus_app
, is_gui_app
);
1285 /* Look for DOS .exe signature - if found, we must also check that
1286 it isn't really a 16- or 32-bit Windows exe, since both formats
1287 start with a DOS program stub. Note that 16-bit Windows
1288 executables use the OS/2 1.x format. */
1290 IMAGE_DOS_HEADER
* dos_header
;
1291 IMAGE_NT_HEADERS
* nt_header
;
1293 dos_header
= (PIMAGE_DOS_HEADER
) executable
.file_base
;
1294 if (dos_header
->e_magic
!= IMAGE_DOS_SIGNATURE
)
1297 nt_header
= (PIMAGE_NT_HEADERS
) ((unsigned char *) dos_header
+ dos_header
->e_lfanew
);
1299 if ((char *) nt_header
> (char *) dos_header
+ executable
.size
)
1301 /* Some dos headers (pkunzip) have bogus e_lfanew fields. */
1304 else if (nt_header
->Signature
!= IMAGE_NT_SIGNATURE
1305 && LOWORD (nt_header
->Signature
) != IMAGE_OS2_SIGNATURE
)
1309 else if (nt_header
->Signature
== IMAGE_NT_SIGNATURE
)
1311 IMAGE_DATA_DIRECTORY
*data_dir
= NULL
;
1312 if (nt_header
->OptionalHeader
.Magic
== IMAGE_NT_OPTIONAL_HDR32_MAGIC
)
1314 /* Ensure we are using the 32 bit structure. */
1315 IMAGE_OPTIONAL_HEADER32
*opt
1316 = (IMAGE_OPTIONAL_HEADER32
*) &(nt_header
->OptionalHeader
);
1317 data_dir
= opt
->DataDirectory
;
1318 *is_gui_app
= (opt
->Subsystem
== IMAGE_SUBSYSTEM_WINDOWS_GUI
);
1320 /* MingW 3.12 has the required 64 bit structs, but in case older
1321 versions don't, only check 64 bit exes if we know how. */
1322 #ifdef IMAGE_NT_OPTIONAL_HDR64_MAGIC
1323 else if (nt_header
->OptionalHeader
.Magic
1324 == IMAGE_NT_OPTIONAL_HDR64_MAGIC
)
1326 IMAGE_OPTIONAL_HEADER64
*opt
1327 = (IMAGE_OPTIONAL_HEADER64
*) &(nt_header
->OptionalHeader
);
1328 data_dir
= opt
->DataDirectory
;
1329 *is_gui_app
= (opt
->Subsystem
== IMAGE_SUBSYSTEM_WINDOWS_GUI
);
1334 /* Look for cygwin.dll in DLL import list. */
1335 IMAGE_DATA_DIRECTORY import_dir
=
1336 data_dir
[IMAGE_DIRECTORY_ENTRY_IMPORT
];
1337 IMAGE_IMPORT_DESCRIPTOR
* imports
;
1338 IMAGE_SECTION_HEADER
* section
;
1340 section
= rva_to_section (import_dir
.VirtualAddress
, nt_header
);
1341 imports
= RVA_TO_PTR (import_dir
.VirtualAddress
, section
,
1344 for ( ; imports
->Name
; imports
++)
1346 char * dllname
= RVA_TO_PTR (imports
->Name
, section
,
1349 /* The exact name of the cygwin dll has changed with
1350 various releases, but hopefully this will be reasonably
1352 if (strncmp (dllname
, "cygwin", 6) == 0)
1354 *is_cygnus_app
= TRUE
;
1363 close_file_data (&executable
);
1367 compare_env (const void *strp1
, const void *strp2
)
1369 const char *str1
= *(const char **)strp1
, *str2
= *(const char **)strp2
;
1371 while (*str1
&& *str2
&& *str1
!= '=' && *str2
!= '=')
1373 /* Sort order in command.com/cmd.exe is based on uppercasing
1374 names, so do the same here. */
1375 if (toupper (*str1
) > toupper (*str2
))
1377 else if (toupper (*str1
) < toupper (*str2
))
1382 if (*str1
== '=' && *str2
== '=')
1384 else if (*str1
== '=')
1391 merge_and_sort_env (char **envp1
, char **envp2
, char **new_envp
)
1393 char **optr
, **nptr
;
1405 num
+= optr
- envp2
;
1407 qsort (new_envp
, num
, sizeof (char *), compare_env
);
1412 /* When a new child process is created we need to register it in our list,
1413 so intercept spawn requests. */
1415 sys_spawnve (int mode
, char *cmdname
, char **argv
, char **envp
)
1417 Lisp_Object program
, full
;
1418 char *cmdline
, *env
, *parg
, **targ
;
1422 int is_dos_app
, is_cygnus_app
, is_gui_app
;
1425 /* We pass our process ID to our children by setting up an environment
1426 variable in their environment. */
1427 char ppid_env_var_buffer
[64];
1428 char *extra_env
[] = {ppid_env_var_buffer
, NULL
};
1429 /* These are the characters that cause an argument to need quoting.
1430 Arguments with whitespace characters need quoting to prevent the
1431 argument being split into two or more. Arguments with wildcards
1432 are also quoted, for consistency with posix platforms, where wildcards
1433 are not expanded if we run the program directly without a shell.
1434 Some extra whitespace characters need quoting in Cygwin programs,
1435 so this list is conditionally modified below. */
1436 char *sepchars
= " \t*?";
1438 /* We don't care about the other modes */
1439 if (mode
!= _P_NOWAIT
)
1445 /* Handle executable names without an executable suffix. */
1446 program
= build_string (cmdname
);
1447 if (NILP (Ffile_executable_p (program
)))
1449 struct gcpro gcpro1
;
1453 openp (Vexec_path
, program
, Vexec_suffixes
, &full
, make_number (X_OK
));
1463 /* make sure argv[0] and cmdname are both in DOS format */
1464 cmdname
= SDATA (program
);
1465 unixtodos_filename (cmdname
);
1468 /* Determine whether program is a 16-bit DOS executable, or a 32-bit Windows
1469 executable that is implicitly linked to the Cygnus dll (implying it
1470 was compiled with the Cygnus GNU toolchain and hence relies on
1471 cygwin.dll to parse the command line - we use this to decide how to
1472 escape quote chars in command line args that must be quoted).
1474 Also determine whether it is a GUI app, so that we don't hide its
1475 initial window unless specifically requested. */
1476 w32_executable_type (cmdname
, &is_dos_app
, &is_cygnus_app
, &is_gui_app
);
1478 /* On Windows 95, if cmdname is a DOS app, we invoke a helper
1479 application to start it by specifying the helper app as cmdname,
1480 while leaving the real app name as argv[0]. */
1483 cmdname
= alloca (MAXPATHLEN
);
1484 if (egetenv ("CMDPROXY"))
1485 strcpy (cmdname
, egetenv ("CMDPROXY"));
1488 strcpy (cmdname
, SDATA (Vinvocation_directory
));
1489 strcat (cmdname
, "cmdproxy.exe");
1491 unixtodos_filename (cmdname
);
1494 /* we have to do some conjuring here to put argv and envp into the
1495 form CreateProcess wants... argv needs to be a space separated/null
1496 terminated list of parameters, and envp is a null
1497 separated/double-null terminated list of parameters.
1499 Additionally, zero-length args and args containing whitespace or
1500 quote chars need to be wrapped in double quotes - for this to work,
1501 embedded quotes need to be escaped as well. The aim is to ensure
1502 the child process reconstructs the argv array we start with
1503 exactly, so we treat quotes at the beginning and end of arguments
1506 The w32 GNU-based library from Cygnus doubles quotes to escape
1507 them, while MSVC uses backslash for escaping. (Actually the MSVC
1508 startup code does attempt to recognize doubled quotes and accept
1509 them, but gets it wrong and ends up requiring three quotes to get a
1510 single embedded quote!) So by default we decide whether to use
1511 quote or backslash as the escape character based on whether the
1512 binary is apparently a Cygnus compiled app.
1514 Note that using backslash to escape embedded quotes requires
1515 additional special handling if an embedded quote is already
1516 preceded by backslash, or if an arg requiring quoting ends with
1517 backslash. In such cases, the run of escape characters needs to be
1518 doubled. For consistency, we apply this special handling as long
1519 as the escape character is not quote.
1521 Since we have no idea how large argv and envp are likely to be we
1522 figure out list lengths on the fly and allocate them. */
1524 if (!NILP (Vw32_quote_process_args
))
1527 /* Override escape char by binding w32-quote-process-args to
1528 desired character, or use t for auto-selection. */
1529 if (INTEGERP (Vw32_quote_process_args
))
1530 escape_char
= XINT (Vw32_quote_process_args
);
1532 escape_char
= is_cygnus_app
? '"' : '\\';
1535 /* Cygwin apps needs quoting a bit more often. */
1536 if (escape_char
== '"')
1537 sepchars
= "\r\n\t\f '";
1545 int need_quotes
= 0;
1546 int escape_char_run
= 0;
1552 if (escape_char
== '"' && *p
== '\\')
1553 /* If it's a Cygwin app, \ needs to be escaped. */
1557 /* allow for embedded quotes to be escaped */
1560 /* handle the case where the embedded quote is already escaped */
1561 if (escape_char_run
> 0)
1563 /* To preserve the arg exactly, we need to double the
1564 preceding escape characters (plus adding one to
1565 escape the quote character itself). */
1566 arglen
+= escape_char_run
;
1569 else if (strchr (sepchars
, *p
) != NULL
)
1574 if (*p
== escape_char
&& escape_char
!= '"')
1577 escape_char_run
= 0;
1582 /* handle the case where the arg ends with an escape char - we
1583 must not let the enclosing quote be escaped. */
1584 if (escape_char_run
> 0)
1585 arglen
+= escape_char_run
;
1587 arglen
+= strlen (*targ
++) + 1;
1589 cmdline
= alloca (arglen
);
1595 int need_quotes
= 0;
1603 if ((strchr (sepchars
, *p
) != NULL
) || *p
== '"')
1608 int escape_char_run
= 0;
1614 last
= p
+ strlen (p
) - 1;
1617 /* This version does not escape quotes if they occur at the
1618 beginning or end of the arg - this could lead to incorrect
1619 behavior when the arg itself represents a command line
1620 containing quoted args. I believe this was originally done
1621 as a hack to make some things work, before
1622 `w32-quote-process-args' was added. */
1625 if (*p
== '"' && p
> first
&& p
< last
)
1626 *parg
++ = escape_char
; /* escape embedded quotes */
1634 /* double preceding escape chars if any */
1635 while (escape_char_run
> 0)
1637 *parg
++ = escape_char
;
1640 /* escape all quote chars, even at beginning or end */
1641 *parg
++ = escape_char
;
1643 else if (escape_char
== '"' && *p
== '\\')
1647 if (*p
== escape_char
&& escape_char
!= '"')
1650 escape_char_run
= 0;
1652 /* double escape chars before enclosing quote */
1653 while (escape_char_run
> 0)
1655 *parg
++ = escape_char
;
1663 strcpy (parg
, *targ
);
1664 parg
+= strlen (*targ
);
1674 numenv
= 1; /* for end null */
1677 arglen
+= strlen (*targ
++) + 1;
1680 /* extra env vars... */
1681 sprintf (ppid_env_var_buffer
, "EM_PARENT_PROCESS_ID=%lu",
1682 GetCurrentProcessId ());
1683 arglen
+= strlen (ppid_env_var_buffer
) + 1;
1686 /* merge env passed in and extra env into one, and sort it. */
1687 targ
= (char **) alloca (numenv
* sizeof (char *));
1688 merge_and_sort_env (envp
, extra_env
, targ
);
1690 /* concatenate env entries. */
1691 env
= alloca (arglen
);
1695 strcpy (parg
, *targ
);
1696 parg
+= strlen (*targ
++);
1709 /* Now create the process. */
1710 if (!create_child (cmdname
, cmdline
, env
, is_gui_app
, &pid
, cp
))
1720 /* Emulate the select call
1721 Wait for available input on any of the given rfds, or timeout if
1722 a timeout is given and no input is detected
1723 wfds and efds are not supported and must be NULL.
1725 For simplicity, we detect the death of child processes here and
1726 synchronously call the SIGCHLD handler. Since it is possible for
1727 children to be created without a corresponding pipe handle from which
1728 to read output, we wait separately on the process handles as well as
1729 the char_avail events for each process pipe. We only call
1730 wait/reap_process when the process actually terminates.
1732 To reduce the number of places in which Emacs can be hung such that
1733 C-g is not able to interrupt it, we always wait on interrupt_handle
1734 (which is signaled by the input thread when C-g is detected). If we
1735 detect that we were woken up by C-g, we return -1 with errno set to
1736 EINTR as on Unix. */
1738 /* From w32console.c */
1739 extern HANDLE keyboard_handle
;
1741 /* From w32xfns.c */
1742 extern HANDLE interrupt_handle
;
1744 /* From process.c */
1745 extern int proc_buffered_char
[];
1748 sys_select (int nfds
, SELECT_TYPE
*rfds
, SELECT_TYPE
*wfds
, SELECT_TYPE
*efds
,
1749 EMACS_TIME
*timeout
, void *ignored
)
1752 DWORD timeout_ms
, start_time
;
1755 child_process
*cp
, *cps
[MAX_CHILDREN
];
1756 HANDLE wait_hnd
[MAXDESC
+ MAX_CHILDREN
];
1757 int fdindex
[MAXDESC
]; /* mapping from wait handles back to descriptors */
1760 timeout
? (timeout
->tv_sec
* 1000 + timeout
->tv_nsec
/ 1000000) : INFINITE
;
1762 /* If the descriptor sets are NULL but timeout isn't, then just Sleep. */
1763 if (rfds
== NULL
&& wfds
== NULL
&& efds
== NULL
&& timeout
!= NULL
)
1769 /* Otherwise, we only handle rfds, so fail otherwise. */
1770 if (rfds
== NULL
|| wfds
!= NULL
|| efds
!= NULL
)
1780 /* Always wait on interrupt_handle, to detect C-g (quit). */
1781 wait_hnd
[0] = interrupt_handle
;
1784 /* Build a list of pipe handles to wait on. */
1786 for (i
= 0; i
< nfds
; i
++)
1787 if (FD_ISSET (i
, &orfds
))
1791 if (keyboard_handle
)
1793 /* Handle stdin specially */
1794 wait_hnd
[nh
] = keyboard_handle
;
1799 /* Check for any emacs-generated input in the queue since
1800 it won't be detected in the wait */
1801 if (detect_input_pending ())
1809 /* Child process and socket input */
1813 int current_status
= cp
->status
;
1815 if (current_status
== STATUS_READ_ACKNOWLEDGED
)
1817 /* Tell reader thread which file handle to use. */
1819 /* Wake up the reader thread for this process */
1820 cp
->status
= STATUS_READ_READY
;
1821 if (!SetEvent (cp
->char_consumed
))
1822 DebPrint (("nt_select.SetEvent failed with "
1823 "%lu for fd %ld\n", GetLastError (), i
));
1826 #ifdef CHECK_INTERLOCK
1827 /* slightly crude cross-checking of interlock between threads */
1829 current_status
= cp
->status
;
1830 if (WaitForSingleObject (cp
->char_avail
, 0) == WAIT_OBJECT_0
)
1832 /* char_avail has been signaled, so status (which may
1833 have changed) should indicate read has completed
1834 but has not been acknowledged. */
1835 current_status
= cp
->status
;
1836 if (current_status
!= STATUS_READ_SUCCEEDED
1837 && current_status
!= STATUS_READ_FAILED
)
1838 DebPrint (("char_avail set, but read not completed: status %d\n",
1843 /* char_avail has not been signaled, so status should
1844 indicate that read is in progress; small possibility
1845 that read has completed but event wasn't yet signaled
1846 when we tested it (because a context switch occurred
1847 or if running on separate CPUs). */
1848 if (current_status
!= STATUS_READ_READY
1849 && current_status
!= STATUS_READ_IN_PROGRESS
1850 && current_status
!= STATUS_READ_SUCCEEDED
1851 && current_status
!= STATUS_READ_FAILED
)
1852 DebPrint (("char_avail reset, but read status is bad: %d\n",
1856 wait_hnd
[nh
] = cp
->char_avail
;
1858 if (!wait_hnd
[nh
]) emacs_abort ();
1861 DebPrint (("select waiting on child %d fd %d\n",
1862 cp
-child_procs
, i
));
1867 /* Unable to find something to wait on for this fd, skip */
1869 /* Note that this is not a fatal error, and can in fact
1870 happen in unusual circumstances. Specifically, if
1871 sys_spawnve fails, eg. because the program doesn't
1872 exist, and debug-on-error is t so Fsignal invokes a
1873 nested input loop, then the process output pipe is
1874 still included in input_wait_mask with no child_proc
1875 associated with it. (It is removed when the debugger
1876 exits the nested input loop and the error is thrown.) */
1878 DebPrint (("sys_select: fd %ld is invalid! ignoring\n", i
));
1884 /* Add handles of child processes. */
1886 for (cp
= child_procs
+ (child_proc_count
-1); cp
>= child_procs
; cp
--)
1887 /* Some child_procs might be sockets; ignore them. Also some
1888 children may have died already, but we haven't finished reading
1889 the process output; ignore them too. */
1890 if (CHILD_ACTIVE (cp
) && cp
->procinfo
.hProcess
1892 || (fd_info
[cp
->fd
].flags
& FILE_SEND_SIGCHLD
) == 0
1893 || (fd_info
[cp
->fd
].flags
& FILE_AT_EOF
) != 0)
1896 wait_hnd
[nh
+ nc
] = cp
->procinfo
.hProcess
;
1901 /* Nothing to look for, so we didn't find anything */
1909 start_time
= GetTickCount ();
1911 /* Wait for input or child death to be signaled. If user input is
1912 allowed, then also accept window messages. */
1913 if (FD_ISSET (0, &orfds
))
1914 active
= MsgWaitForMultipleObjects (nh
+ nc
, wait_hnd
, FALSE
, timeout_ms
,
1917 active
= WaitForMultipleObjects (nh
+ nc
, wait_hnd
, FALSE
, timeout_ms
);
1919 if (active
== WAIT_FAILED
)
1921 DebPrint (("select.WaitForMultipleObjects (%d, %lu) failed with %lu\n",
1922 nh
+ nc
, timeout_ms
, GetLastError ()));
1923 /* don't return EBADF - this causes wait_reading_process_output to
1924 abort; WAIT_FAILED is returned when single-stepping under
1925 Windows 95 after switching thread focus in debugger, and
1926 possibly at other times. */
1930 else if (active
== WAIT_TIMEOUT
)
1934 else if (active
>= WAIT_OBJECT_0
1935 && active
< WAIT_OBJECT_0
+MAXIMUM_WAIT_OBJECTS
)
1937 active
-= WAIT_OBJECT_0
;
1939 else if (active
>= WAIT_ABANDONED_0
1940 && active
< WAIT_ABANDONED_0
+MAXIMUM_WAIT_OBJECTS
)
1942 active
-= WAIT_ABANDONED_0
;
1947 /* Loop over all handles after active (now officially documented as
1948 being the first signaled handle in the array). We do this to
1949 ensure fairness, so that all channels with data available will be
1950 processed - otherwise higher numbered channels could be starved. */
1953 if (active
== nh
+ nc
)
1955 /* There are messages in the lisp thread's queue; we must
1956 drain the queue now to ensure they are processed promptly,
1957 because if we don't do so, we will not be woken again until
1958 further messages arrive.
1960 NB. If ever we allow window message procedures to callback
1961 into lisp, we will need to ensure messages are dispatched
1962 at a safe time for lisp code to be run (*), and we may also
1963 want to provide some hooks in the dispatch loop to cater
1964 for modeless dialogs created by lisp (ie. to register
1965 window handles to pass to IsDialogMessage).
1967 (*) Note that MsgWaitForMultipleObjects above is an
1968 internal dispatch point for messages that are sent to
1969 windows created by this thread. */
1970 drain_message_queue ();
1972 else if (active
>= nh
)
1974 cp
= cps
[active
- nh
];
1976 /* We cannot always signal SIGCHLD immediately; if we have not
1977 finished reading the process output, we must delay sending
1978 SIGCHLD until we do. */
1980 if (cp
->fd
>= 0 && (fd_info
[cp
->fd
].flags
& FILE_AT_EOF
) == 0)
1981 fd_info
[cp
->fd
].flags
|= FILE_SEND_SIGCHLD
;
1982 /* SIG_DFL for SIGCHLD is ignore */
1983 else if (sig_handlers
[SIGCHLD
] != SIG_DFL
&&
1984 sig_handlers
[SIGCHLD
] != SIG_IGN
)
1987 DebPrint (("select calling SIGCHLD handler for pid %d\n",
1991 sig_handlers
[SIGCHLD
] (SIGCHLD
);
1995 else if (fdindex
[active
] == -1)
1997 /* Quit (C-g) was detected. */
2001 else if (fdindex
[active
] == 0)
2003 /* Keyboard input available */
2009 /* must be a socket or pipe - read ahead should have
2010 completed, either succeeding or failing. */
2011 FD_SET (fdindex
[active
], rfds
);
2015 /* Even though wait_reading_process_output only reads from at most
2016 one channel, we must process all channels here so that we reap
2017 all children that have died. */
2018 while (++active
< nh
+ nc
)
2019 if (WaitForSingleObject (wait_hnd
[active
], 0) == WAIT_OBJECT_0
)
2021 } while (active
< nh
+ nc
);
2023 /* If no input has arrived and timeout hasn't expired, wait again. */
2026 DWORD elapsed
= GetTickCount () - start_time
;
2028 if (timeout_ms
> elapsed
) /* INFINITE is MAX_UINT */
2030 if (timeout_ms
!= INFINITE
)
2031 timeout_ms
-= elapsed
;
2032 goto count_children
;
2039 /* Substitute for certain kill () operations */
2041 static BOOL CALLBACK
2042 find_child_console (HWND hwnd
, LPARAM arg
)
2044 child_process
* cp
= (child_process
*) arg
;
2048 thread_id
= GetWindowThreadProcessId (hwnd
, &process_id
);
2049 if (process_id
== cp
->procinfo
.dwProcessId
)
2051 char window_class
[32];
2053 GetClassName (hwnd
, window_class
, sizeof (window_class
));
2054 if (strcmp (window_class
,
2055 (os_subtype
== OS_9X
)
2057 : "ConsoleWindowClass") == 0)
2067 /* Emulate 'kill', but only for other processes. */
2069 sys_kill (int pid
, int sig
)
2073 int need_to_free
= 0;
2076 /* Only handle signals that will result in the process dying */
2077 if (sig
!= SIGINT
&& sig
!= SIGKILL
&& sig
!= SIGQUIT
&& sig
!= SIGHUP
)
2083 cp
= find_child_pid (pid
);
2086 /* We were passed a PID of something other than our subprocess.
2087 If that is our own PID, we will send to ourself a message to
2088 close the selected frame, which does not necessarily
2089 terminates Emacs. But then we are not supposed to call
2090 sys_kill with our own PID. */
2091 proc_hand
= OpenProcess (PROCESS_TERMINATE
, 0, pid
);
2092 if (proc_hand
== NULL
)
2101 proc_hand
= cp
->procinfo
.hProcess
;
2102 pid
= cp
->procinfo
.dwProcessId
;
2104 /* Try to locate console window for process. */
2105 EnumWindows (find_child_console
, (LPARAM
) cp
);
2108 if (sig
== SIGINT
|| sig
== SIGQUIT
)
2110 if (NILP (Vw32_start_process_share_console
) && cp
&& cp
->hwnd
)
2112 BYTE control_scan_code
= (BYTE
) MapVirtualKey (VK_CONTROL
, 0);
2113 /* Fake Ctrl-C for SIGINT, and Ctrl-Break for SIGQUIT. */
2114 BYTE vk_break_code
= (sig
== SIGINT
) ? 'C' : VK_CANCEL
;
2115 BYTE break_scan_code
= (BYTE
) MapVirtualKey (vk_break_code
, 0);
2116 HWND foreground_window
;
2118 if (break_scan_code
== 0)
2120 /* Fake Ctrl-C for SIGQUIT if we can't manage Ctrl-Break. */
2121 vk_break_code
= 'C';
2122 break_scan_code
= (BYTE
) MapVirtualKey (vk_break_code
, 0);
2125 foreground_window
= GetForegroundWindow ();
2126 if (foreground_window
)
2128 /* NT 5.0, and apparently also Windows 98, will not allow
2129 a Window to be set to foreground directly without the
2130 user's involvement. The workaround is to attach
2131 ourselves to the thread that owns the foreground
2132 window, since that is the only thread that can set the
2133 foreground window. */
2134 DWORD foreground_thread
, child_thread
;
2136 GetWindowThreadProcessId (foreground_window
, NULL
);
2137 if (foreground_thread
== GetCurrentThreadId ()
2138 || !AttachThreadInput (GetCurrentThreadId (),
2139 foreground_thread
, TRUE
))
2140 foreground_thread
= 0;
2142 child_thread
= GetWindowThreadProcessId (cp
->hwnd
, NULL
);
2143 if (child_thread
== GetCurrentThreadId ()
2144 || !AttachThreadInput (GetCurrentThreadId (),
2145 child_thread
, TRUE
))
2148 /* Set the foreground window to the child. */
2149 if (SetForegroundWindow (cp
->hwnd
))
2151 /* Generate keystrokes as if user had typed Ctrl-Break or
2153 keybd_event (VK_CONTROL
, control_scan_code
, 0, 0);
2154 keybd_event (vk_break_code
, break_scan_code
,
2155 (vk_break_code
== 'C' ? 0 : KEYEVENTF_EXTENDEDKEY
), 0);
2156 keybd_event (vk_break_code
, break_scan_code
,
2157 (vk_break_code
== 'C' ? 0 : KEYEVENTF_EXTENDEDKEY
)
2158 | KEYEVENTF_KEYUP
, 0);
2159 keybd_event (VK_CONTROL
, control_scan_code
,
2160 KEYEVENTF_KEYUP
, 0);
2162 /* Sleep for a bit to give time for Emacs frame to respond
2163 to focus change events (if Emacs was active app). */
2166 SetForegroundWindow (foreground_window
);
2168 /* Detach from the foreground and child threads now that
2169 the foreground switching is over. */
2170 if (foreground_thread
)
2171 AttachThreadInput (GetCurrentThreadId (),
2172 foreground_thread
, FALSE
);
2174 AttachThreadInput (GetCurrentThreadId (),
2175 child_thread
, FALSE
);
2178 /* Ctrl-Break is NT equivalent of SIGINT. */
2179 else if (!GenerateConsoleCtrlEvent (CTRL_BREAK_EVENT
, pid
))
2181 DebPrint (("sys_kill.GenerateConsoleCtrlEvent return %d "
2182 "for pid %lu\n", GetLastError (), pid
));
2189 if (NILP (Vw32_start_process_share_console
) && cp
&& cp
->hwnd
)
2192 if (os_subtype
== OS_9X
)
2195 Another possibility is to try terminating the VDM out-right by
2196 calling the Shell VxD (id 0x17) V86 interface, function #4
2197 "SHELL_Destroy_VM", ie.
2203 First need to determine the current VM handle, and then arrange for
2204 the shellapi call to be made from the system vm (by using
2205 Switch_VM_and_callback).
2207 Could try to invoke DestroyVM through CallVxD.
2211 /* On Windows 95, posting WM_QUIT causes the 16-bit subsystem
2212 to hang when cmdproxy is used in conjunction with
2213 command.com for an interactive shell. Posting
2214 WM_CLOSE pops up a dialog that, when Yes is selected,
2215 does the same thing. TerminateProcess is also less
2216 than ideal in that subprocesses tend to stick around
2217 until the machine is shutdown, but at least it
2218 doesn't freeze the 16-bit subsystem. */
2219 PostMessage (cp
->hwnd
, WM_QUIT
, 0xff, 0);
2221 if (!TerminateProcess (proc_hand
, 0xff))
2223 DebPrint (("sys_kill.TerminateProcess returned %d "
2224 "for pid %lu\n", GetLastError (), pid
));
2231 PostMessage (cp
->hwnd
, WM_CLOSE
, 0, 0);
2233 /* Kill the process. On W32 this doesn't kill child processes
2234 so it doesn't work very well for shells which is why it's not
2235 used in every case. */
2236 else if (!TerminateProcess (proc_hand
, 0xff))
2238 DebPrint (("sys_kill.TerminateProcess returned %d "
2239 "for pid %lu\n", GetLastError (), pid
));
2246 CloseHandle (proc_hand
);
2251 /* The following two routines are used to manipulate stdin, stdout, and
2252 stderr of our child processes.
2254 Assuming that in, out, and err are *not* inheritable, we make them
2255 stdin, stdout, and stderr of the child as follows:
2257 - Save the parent's current standard handles.
2258 - Set the std handles to inheritable duplicates of the ones being passed in.
2259 (Note that _get_osfhandle() is an io.h procedure that retrieves the
2260 NT file handle for a crt file descriptor.)
2261 - Spawn the child, which inherits in, out, and err as stdin,
2262 stdout, and stderr. (see Spawnve)
2263 - Close the std handles passed to the child.
2264 - Reset the parent's standard handles to the saved handles.
2265 (see reset_standard_handles)
2266 We assume that the caller closes in, out, and err after calling us. */
2269 prepare_standard_handles (int in
, int out
, int err
, HANDLE handles
[3])
2272 HANDLE newstdin
, newstdout
, newstderr
;
2274 parent
= GetCurrentProcess ();
2276 handles
[0] = GetStdHandle (STD_INPUT_HANDLE
);
2277 handles
[1] = GetStdHandle (STD_OUTPUT_HANDLE
);
2278 handles
[2] = GetStdHandle (STD_ERROR_HANDLE
);
2280 /* make inheritable copies of the new handles */
2281 if (!DuplicateHandle (parent
,
2282 (HANDLE
) _get_osfhandle (in
),
2287 DUPLICATE_SAME_ACCESS
))
2288 report_file_error ("Duplicating input handle for child", Qnil
);
2290 if (!DuplicateHandle (parent
,
2291 (HANDLE
) _get_osfhandle (out
),
2296 DUPLICATE_SAME_ACCESS
))
2297 report_file_error ("Duplicating output handle for child", Qnil
);
2299 if (!DuplicateHandle (parent
,
2300 (HANDLE
) _get_osfhandle (err
),
2305 DUPLICATE_SAME_ACCESS
))
2306 report_file_error ("Duplicating error handle for child", Qnil
);
2308 /* and store them as our std handles */
2309 if (!SetStdHandle (STD_INPUT_HANDLE
, newstdin
))
2310 report_file_error ("Changing stdin handle", Qnil
);
2312 if (!SetStdHandle (STD_OUTPUT_HANDLE
, newstdout
))
2313 report_file_error ("Changing stdout handle", Qnil
);
2315 if (!SetStdHandle (STD_ERROR_HANDLE
, newstderr
))
2316 report_file_error ("Changing stderr handle", Qnil
);
2320 reset_standard_handles (int in
, int out
, int err
, HANDLE handles
[3])
2322 /* close the duplicated handles passed to the child */
2323 CloseHandle (GetStdHandle (STD_INPUT_HANDLE
));
2324 CloseHandle (GetStdHandle (STD_OUTPUT_HANDLE
));
2325 CloseHandle (GetStdHandle (STD_ERROR_HANDLE
));
2327 /* now restore parent's saved std handles */
2328 SetStdHandle (STD_INPUT_HANDLE
, handles
[0]);
2329 SetStdHandle (STD_OUTPUT_HANDLE
, handles
[1]);
2330 SetStdHandle (STD_ERROR_HANDLE
, handles
[2]);
2334 set_process_dir (char * dir
)
2339 /* To avoid problems with winsock implementations that work over dial-up
2340 connections causing or requiring a connection to exist while Emacs is
2341 running, Emacs no longer automatically loads winsock on startup if it
2342 is present. Instead, it will be loaded when open-network-stream is
2345 To allow full control over when winsock is loaded, we provide these
2346 two functions to dynamically load and unload winsock. This allows
2347 dial-up users to only be connected when they actually need to use
2351 extern HANDLE winsock_lib
;
2352 extern BOOL
term_winsock (void);
2353 extern BOOL
init_winsock (int load_now
);
2355 DEFUN ("w32-has-winsock", Fw32_has_winsock
, Sw32_has_winsock
, 0, 1, 0,
2356 doc
: /* Test for presence of the Windows socket library `winsock'.
2357 Returns non-nil if winsock support is present, nil otherwise.
2359 If the optional argument LOAD-NOW is non-nil, the winsock library is
2360 also loaded immediately if not already loaded. If winsock is loaded,
2361 the winsock local hostname is returned (since this may be different from
2362 the value of `system-name' and should supplant it), otherwise t is
2363 returned to indicate winsock support is present. */)
2364 (Lisp_Object load_now
)
2368 have_winsock
= init_winsock (!NILP (load_now
));
2371 if (winsock_lib
!= NULL
)
2373 /* Return new value for system-name. The best way to do this
2374 is to call init_system_name, saving and restoring the
2375 original value to avoid side-effects. */
2376 Lisp_Object orig_hostname
= Vsystem_name
;
2377 Lisp_Object hostname
;
2379 init_system_name ();
2380 hostname
= Vsystem_name
;
2381 Vsystem_name
= orig_hostname
;
2389 DEFUN ("w32-unload-winsock", Fw32_unload_winsock
, Sw32_unload_winsock
,
2391 doc
: /* Unload the Windows socket library `winsock' if loaded.
2392 This is provided to allow dial-up socket connections to be disconnected
2393 when no longer needed. Returns nil without unloading winsock if any
2394 socket connections still exist. */)
2397 return term_winsock () ? Qt
: Qnil
;
2401 /* Some miscellaneous functions that are Windows specific, but not GUI
2402 specific (ie. are applicable in terminal or batch mode as well). */
2404 DEFUN ("w32-short-file-name", Fw32_short_file_name
, Sw32_short_file_name
, 1, 1, 0,
2405 doc
: /* Return the short file name version (8.3) of the full path of FILENAME.
2406 If FILENAME does not exist, return nil.
2407 All path elements in FILENAME are converted to their short names. */)
2408 (Lisp_Object filename
)
2410 char shortname
[MAX_PATH
];
2412 CHECK_STRING (filename
);
2414 /* first expand it. */
2415 filename
= Fexpand_file_name (filename
, Qnil
);
2417 /* luckily, this returns the short version of each element in the path. */
2418 if (GetShortPathName (SDATA (ENCODE_FILE (filename
)), shortname
, MAX_PATH
) == 0)
2421 dostounix_filename (shortname
);
2423 return build_string (shortname
);
2427 DEFUN ("w32-long-file-name", Fw32_long_file_name
, Sw32_long_file_name
,
2429 doc
: /* Return the long file name version of the full path of FILENAME.
2430 If FILENAME does not exist, return nil.
2431 All path elements in FILENAME are converted to their long names. */)
2432 (Lisp_Object filename
)
2434 char longname
[ MAX_PATH
];
2437 CHECK_STRING (filename
);
2439 if (SBYTES (filename
) == 2
2440 && *(SDATA (filename
) + 1) == ':')
2443 /* first expand it. */
2444 filename
= Fexpand_file_name (filename
, Qnil
);
2446 if (!w32_get_long_filename (SDATA (ENCODE_FILE (filename
)), longname
, MAX_PATH
))
2449 dostounix_filename (longname
);
2451 /* If we were passed only a drive, make sure that a slash is not appended
2452 for consistency with directories. Allow for drive mapping via SUBST
2453 in case expand-file-name is ever changed to expand those. */
2454 if (drive_only
&& longname
[1] == ':' && longname
[2] == '/' && !longname
[3])
2457 return DECODE_FILE (build_string (longname
));
2460 DEFUN ("w32-set-process-priority", Fw32_set_process_priority
,
2461 Sw32_set_process_priority
, 2, 2, 0,
2462 doc
: /* Set the priority of PROCESS to PRIORITY.
2463 If PROCESS is nil, the priority of Emacs is changed, otherwise the
2464 priority of the process whose pid is PROCESS is changed.
2465 PRIORITY should be one of the symbols high, normal, or low;
2466 any other symbol will be interpreted as normal.
2468 If successful, the return value is t, otherwise nil. */)
2469 (Lisp_Object process
, Lisp_Object priority
)
2471 HANDLE proc_handle
= GetCurrentProcess ();
2472 DWORD priority_class
= NORMAL_PRIORITY_CLASS
;
2473 Lisp_Object result
= Qnil
;
2475 CHECK_SYMBOL (priority
);
2477 if (!NILP (process
))
2482 CHECK_NUMBER (process
);
2484 /* Allow pid to be an internally generated one, or one obtained
2485 externally. This is necessary because real pids on Windows 95 are
2488 pid
= XINT (process
);
2489 cp
= find_child_pid (pid
);
2491 pid
= cp
->procinfo
.dwProcessId
;
2493 proc_handle
= OpenProcess (PROCESS_SET_INFORMATION
, FALSE
, pid
);
2496 if (EQ (priority
, Qhigh
))
2497 priority_class
= HIGH_PRIORITY_CLASS
;
2498 else if (EQ (priority
, Qlow
))
2499 priority_class
= IDLE_PRIORITY_CLASS
;
2501 if (proc_handle
!= NULL
)
2503 if (SetPriorityClass (proc_handle
, priority_class
))
2505 if (!NILP (process
))
2506 CloseHandle (proc_handle
);
2512 #ifdef HAVE_LANGINFO_CODESET
2513 /* Emulation of nl_langinfo. Used in fns.c:Flocale_info. */
2515 nl_langinfo (nl_item item
)
2517 /* Conversion of Posix item numbers to their Windows equivalents. */
2518 static const LCTYPE w32item
[] = {
2519 LOCALE_IDEFAULTANSICODEPAGE
,
2520 LOCALE_SDAYNAME1
, LOCALE_SDAYNAME2
, LOCALE_SDAYNAME3
,
2521 LOCALE_SDAYNAME4
, LOCALE_SDAYNAME5
, LOCALE_SDAYNAME6
, LOCALE_SDAYNAME7
,
2522 LOCALE_SMONTHNAME1
, LOCALE_SMONTHNAME2
, LOCALE_SMONTHNAME3
,
2523 LOCALE_SMONTHNAME4
, LOCALE_SMONTHNAME5
, LOCALE_SMONTHNAME6
,
2524 LOCALE_SMONTHNAME7
, LOCALE_SMONTHNAME8
, LOCALE_SMONTHNAME9
,
2525 LOCALE_SMONTHNAME10
, LOCALE_SMONTHNAME11
, LOCALE_SMONTHNAME12
2528 static char *nl_langinfo_buf
= NULL
;
2529 static int nl_langinfo_len
= 0;
2531 if (nl_langinfo_len
<= 0)
2532 nl_langinfo_buf
= xmalloc (nl_langinfo_len
= 1);
2534 if (item
< 0 || item
>= _NL_NUM
)
2535 nl_langinfo_buf
[0] = 0;
2538 LCID cloc
= GetThreadLocale ();
2539 int need_len
= GetLocaleInfo (cloc
, w32item
[item
] | LOCALE_USE_CP_ACP
,
2543 nl_langinfo_buf
[0] = 0;
2546 if (item
== CODESET
)
2548 need_len
+= 2; /* for the "cp" prefix */
2549 if (need_len
< 8) /* for the case we call GetACP */
2552 if (nl_langinfo_len
<= need_len
)
2553 nl_langinfo_buf
= xrealloc (nl_langinfo_buf
,
2554 nl_langinfo_len
= need_len
);
2555 if (!GetLocaleInfo (cloc
, w32item
[item
] | LOCALE_USE_CP_ACP
,
2556 nl_langinfo_buf
, nl_langinfo_len
))
2557 nl_langinfo_buf
[0] = 0;
2558 else if (item
== CODESET
)
2560 if (strcmp (nl_langinfo_buf
, "0") == 0 /* CP_ACP */
2561 || strcmp (nl_langinfo_buf
, "1") == 0) /* CP_OEMCP */
2562 sprintf (nl_langinfo_buf
, "cp%u", GetACP ());
2565 memmove (nl_langinfo_buf
+ 2, nl_langinfo_buf
,
2566 strlen (nl_langinfo_buf
) + 1);
2567 nl_langinfo_buf
[0] = 'c';
2568 nl_langinfo_buf
[1] = 'p';
2573 return nl_langinfo_buf
;
2575 #endif /* HAVE_LANGINFO_CODESET */
2577 DEFUN ("w32-get-locale-info", Fw32_get_locale_info
,
2578 Sw32_get_locale_info
, 1, 2, 0,
2579 doc
: /* Return information about the Windows locale LCID.
2580 By default, return a three letter locale code which encodes the default
2581 language as the first two characters, and the country or regional variant
2582 as the third letter. For example, ENU refers to `English (United States)',
2583 while ENC means `English (Canadian)'.
2585 If the optional argument LONGFORM is t, the long form of the locale
2586 name is returned, e.g. `English (United States)' instead; if LONGFORM
2587 is a number, it is interpreted as an LCTYPE constant and the corresponding
2588 locale information is returned.
2590 If LCID (a 16-bit number) is not a valid locale, the result is nil. */)
2591 (Lisp_Object lcid
, Lisp_Object longform
)
2595 char abbrev_name
[32] = { 0 };
2596 char full_name
[256] = { 0 };
2598 CHECK_NUMBER (lcid
);
2600 if (!IsValidLocale (XINT (lcid
), LCID_SUPPORTED
))
2603 if (NILP (longform
))
2605 got_abbrev
= GetLocaleInfo (XINT (lcid
),
2606 LOCALE_SABBREVLANGNAME
| LOCALE_USE_CP_ACP
,
2607 abbrev_name
, sizeof (abbrev_name
));
2609 return build_string (abbrev_name
);
2611 else if (EQ (longform
, Qt
))
2613 got_full
= GetLocaleInfo (XINT (lcid
),
2614 LOCALE_SLANGUAGE
| LOCALE_USE_CP_ACP
,
2615 full_name
, sizeof (full_name
));
2617 return DECODE_SYSTEM (build_string (full_name
));
2619 else if (NUMBERP (longform
))
2621 got_full
= GetLocaleInfo (XINT (lcid
),
2623 full_name
, sizeof (full_name
));
2624 /* GetLocaleInfo's return value includes the terminating null
2625 character, when the returned information is a string, whereas
2626 make_unibyte_string needs the string length without the
2627 terminating null. */
2629 return make_unibyte_string (full_name
, got_full
- 1);
2636 DEFUN ("w32-get-current-locale-id", Fw32_get_current_locale_id
,
2637 Sw32_get_current_locale_id
, 0, 0, 0,
2638 doc
: /* Return Windows locale id for current locale setting.
2639 This is a numerical value; use `w32-get-locale-info' to convert to a
2640 human-readable form. */)
2643 return make_number (GetThreadLocale ());
2647 int_from_hex (char * s
)
2650 static char hex
[] = "0123456789abcdefABCDEF";
2653 while (*s
&& (p
= strchr (hex
, *s
)) != NULL
)
2655 unsigned digit
= p
- hex
;
2658 val
= val
* 16 + digit
;
2664 /* We need to build a global list, since the EnumSystemLocale callback
2665 function isn't given a context pointer. */
2666 Lisp_Object Vw32_valid_locale_ids
;
2668 static BOOL CALLBACK
2669 enum_locale_fn (LPTSTR localeNum
)
2671 DWORD id
= int_from_hex (localeNum
);
2672 Vw32_valid_locale_ids
= Fcons (make_number (id
), Vw32_valid_locale_ids
);
2676 DEFUN ("w32-get-valid-locale-ids", Fw32_get_valid_locale_ids
,
2677 Sw32_get_valid_locale_ids
, 0, 0, 0,
2678 doc
: /* Return list of all valid Windows locale ids.
2679 Each id is a numerical value; use `w32-get-locale-info' to convert to a
2680 human-readable form. */)
2683 Vw32_valid_locale_ids
= Qnil
;
2685 EnumSystemLocales (enum_locale_fn
, LCID_SUPPORTED
);
2687 Vw32_valid_locale_ids
= Fnreverse (Vw32_valid_locale_ids
);
2688 return Vw32_valid_locale_ids
;
2692 DEFUN ("w32-get-default-locale-id", Fw32_get_default_locale_id
, Sw32_get_default_locale_id
, 0, 1, 0,
2693 doc
: /* Return Windows locale id for default locale setting.
2694 By default, the system default locale setting is returned; if the optional
2695 parameter USERP is non-nil, the user default locale setting is returned.
2696 This is a numerical value; use `w32-get-locale-info' to convert to a
2697 human-readable form. */)
2701 return make_number (GetSystemDefaultLCID ());
2702 return make_number (GetUserDefaultLCID ());
2706 DEFUN ("w32-set-current-locale", Fw32_set_current_locale
, Sw32_set_current_locale
, 1, 1, 0,
2707 doc
: /* Make Windows locale LCID be the current locale setting for Emacs.
2708 If successful, the new locale id is returned, otherwise nil. */)
2711 CHECK_NUMBER (lcid
);
2713 if (!IsValidLocale (XINT (lcid
), LCID_SUPPORTED
))
2716 if (!SetThreadLocale (XINT (lcid
)))
2719 /* Need to set input thread locale if present. */
2720 if (dwWindowsThreadId
)
2721 /* Reply is not needed. */
2722 PostThreadMessage (dwWindowsThreadId
, WM_EMACS_SETLOCALE
, XINT (lcid
), 0);
2724 return make_number (GetThreadLocale ());
2728 /* We need to build a global list, since the EnumCodePages callback
2729 function isn't given a context pointer. */
2730 Lisp_Object Vw32_valid_codepages
;
2732 static BOOL CALLBACK
2733 enum_codepage_fn (LPTSTR codepageNum
)
2735 DWORD id
= atoi (codepageNum
);
2736 Vw32_valid_codepages
= Fcons (make_number (id
), Vw32_valid_codepages
);
2740 DEFUN ("w32-get-valid-codepages", Fw32_get_valid_codepages
,
2741 Sw32_get_valid_codepages
, 0, 0, 0,
2742 doc
: /* Return list of all valid Windows codepages. */)
2745 Vw32_valid_codepages
= Qnil
;
2747 EnumSystemCodePages (enum_codepage_fn
, CP_SUPPORTED
);
2749 Vw32_valid_codepages
= Fnreverse (Vw32_valid_codepages
);
2750 return Vw32_valid_codepages
;
2754 DEFUN ("w32-get-console-codepage", Fw32_get_console_codepage
,
2755 Sw32_get_console_codepage
, 0, 0, 0,
2756 doc
: /* Return current Windows codepage for console input. */)
2759 return make_number (GetConsoleCP ());
2763 DEFUN ("w32-set-console-codepage", Fw32_set_console_codepage
,
2764 Sw32_set_console_codepage
, 1, 1, 0,
2765 doc
: /* Make Windows codepage CP be the codepage for Emacs tty keyboard input.
2766 This codepage setting affects keyboard input in tty mode.
2767 If successful, the new CP is returned, otherwise nil. */)
2772 if (!IsValidCodePage (XINT (cp
)))
2775 if (!SetConsoleCP (XINT (cp
)))
2778 return make_number (GetConsoleCP ());
2782 DEFUN ("w32-get-console-output-codepage", Fw32_get_console_output_codepage
,
2783 Sw32_get_console_output_codepage
, 0, 0, 0,
2784 doc
: /* Return current Windows codepage for console output. */)
2787 return make_number (GetConsoleOutputCP ());
2791 DEFUN ("w32-set-console-output-codepage", Fw32_set_console_output_codepage
,
2792 Sw32_set_console_output_codepage
, 1, 1, 0,
2793 doc
: /* Make Windows codepage CP be the codepage for Emacs console output.
2794 This codepage setting affects display in tty mode.
2795 If successful, the new CP is returned, otherwise nil. */)
2800 if (!IsValidCodePage (XINT (cp
)))
2803 if (!SetConsoleOutputCP (XINT (cp
)))
2806 return make_number (GetConsoleOutputCP ());
2810 DEFUN ("w32-get-codepage-charset", Fw32_get_codepage_charset
,
2811 Sw32_get_codepage_charset
, 1, 1, 0,
2812 doc
: /* Return charset ID corresponding to codepage CP.
2813 Returns nil if the codepage is not valid. */)
2820 if (!IsValidCodePage (XINT (cp
)))
2823 if (TranslateCharsetInfo ((DWORD
*) XINT (cp
), &info
, TCI_SRCCODEPAGE
))
2824 return make_number (info
.ciCharset
);
2830 DEFUN ("w32-get-valid-keyboard-layouts", Fw32_get_valid_keyboard_layouts
,
2831 Sw32_get_valid_keyboard_layouts
, 0, 0, 0,
2832 doc
: /* Return list of Windows keyboard languages and layouts.
2833 The return value is a list of pairs of language id and layout id. */)
2836 int num_layouts
= GetKeyboardLayoutList (0, NULL
);
2837 HKL
* layouts
= (HKL
*) alloca (num_layouts
* sizeof (HKL
));
2838 Lisp_Object obj
= Qnil
;
2840 if (GetKeyboardLayoutList (num_layouts
, layouts
) == num_layouts
)
2842 while (--num_layouts
>= 0)
2844 DWORD kl
= (DWORD
) layouts
[num_layouts
];
2846 obj
= Fcons (Fcons (make_number (kl
& 0xffff),
2847 make_number ((kl
>> 16) & 0xffff)),
2856 DEFUN ("w32-get-keyboard-layout", Fw32_get_keyboard_layout
,
2857 Sw32_get_keyboard_layout
, 0, 0, 0,
2858 doc
: /* Return current Windows keyboard language and layout.
2859 The return value is the cons of the language id and the layout id. */)
2862 DWORD kl
= (DWORD
) GetKeyboardLayout (dwWindowsThreadId
);
2864 return Fcons (make_number (kl
& 0xffff),
2865 make_number ((kl
>> 16) & 0xffff));
2869 DEFUN ("w32-set-keyboard-layout", Fw32_set_keyboard_layout
,
2870 Sw32_set_keyboard_layout
, 1, 1, 0,
2871 doc
: /* Make LAYOUT be the current keyboard layout for Emacs.
2872 The keyboard layout setting affects interpretation of keyboard input.
2873 If successful, the new layout id is returned, otherwise nil. */)
2874 (Lisp_Object layout
)
2878 CHECK_CONS (layout
);
2879 CHECK_NUMBER_CAR (layout
);
2880 CHECK_NUMBER_CDR (layout
);
2882 kl
= (XINT (XCAR (layout
)) & 0xffff)
2883 | (XINT (XCDR (layout
)) << 16);
2885 /* Synchronize layout with input thread. */
2886 if (dwWindowsThreadId
)
2888 if (PostThreadMessage (dwWindowsThreadId
, WM_EMACS_SETKEYBOARDLAYOUT
,
2892 GetMessage (&msg
, NULL
, WM_EMACS_DONE
, WM_EMACS_DONE
);
2894 if (msg
.wParam
== 0)
2898 else if (!ActivateKeyboardLayout ((HKL
) kl
, 0))
2901 return Fw32_get_keyboard_layout ();
2906 syms_of_ntproc (void)
2908 DEFSYM (Qhigh
, "high");
2909 DEFSYM (Qlow
, "low");
2911 defsubr (&Sw32_has_winsock
);
2912 defsubr (&Sw32_unload_winsock
);
2914 defsubr (&Sw32_short_file_name
);
2915 defsubr (&Sw32_long_file_name
);
2916 defsubr (&Sw32_set_process_priority
);
2917 defsubr (&Sw32_get_locale_info
);
2918 defsubr (&Sw32_get_current_locale_id
);
2919 defsubr (&Sw32_get_default_locale_id
);
2920 defsubr (&Sw32_get_valid_locale_ids
);
2921 defsubr (&Sw32_set_current_locale
);
2923 defsubr (&Sw32_get_console_codepage
);
2924 defsubr (&Sw32_set_console_codepage
);
2925 defsubr (&Sw32_get_console_output_codepage
);
2926 defsubr (&Sw32_set_console_output_codepage
);
2927 defsubr (&Sw32_get_valid_codepages
);
2928 defsubr (&Sw32_get_codepage_charset
);
2930 defsubr (&Sw32_get_valid_keyboard_layouts
);
2931 defsubr (&Sw32_get_keyboard_layout
);
2932 defsubr (&Sw32_set_keyboard_layout
);
2934 DEFVAR_LISP ("w32-quote-process-args", Vw32_quote_process_args
,
2935 doc
: /* Non-nil enables quoting of process arguments to ensure correct parsing.
2936 Because Windows does not directly pass argv arrays to child processes,
2937 programs have to reconstruct the argv array by parsing the command
2938 line string. For an argument to contain a space, it must be enclosed
2939 in double quotes or it will be parsed as multiple arguments.
2941 If the value is a character, that character will be used to escape any
2942 quote characters that appear, otherwise a suitable escape character
2943 will be chosen based on the type of the program. */);
2944 Vw32_quote_process_args
= Qt
;
2946 DEFVAR_LISP ("w32-start-process-show-window",
2947 Vw32_start_process_show_window
,
2948 doc
: /* When nil, new child processes hide their windows.
2949 When non-nil, they show their window in the method of their choice.
2950 This variable doesn't affect GUI applications, which will never be hidden. */);
2951 Vw32_start_process_show_window
= Qnil
;
2953 DEFVAR_LISP ("w32-start-process-share-console",
2954 Vw32_start_process_share_console
,
2955 doc
: /* When nil, new child processes are given a new console.
2956 When non-nil, they share the Emacs console; this has the limitation of
2957 allowing only one DOS subprocess to run at a time (whether started directly
2958 or indirectly by Emacs), and preventing Emacs from cleanly terminating the
2959 subprocess group, but may allow Emacs to interrupt a subprocess that doesn't
2960 otherwise respond to interrupts from Emacs. */);
2961 Vw32_start_process_share_console
= Qnil
;
2963 DEFVAR_LISP ("w32-start-process-inherit-error-mode",
2964 Vw32_start_process_inherit_error_mode
,
2965 doc
: /* When nil, new child processes revert to the default error mode.
2966 When non-nil, they inherit their error mode setting from Emacs, which stops
2967 them blocking when trying to access unmounted drives etc. */);
2968 Vw32_start_process_inherit_error_mode
= Qt
;
2970 DEFVAR_INT ("w32-pipe-read-delay", w32_pipe_read_delay
,
2971 doc
: /* Forced delay before reading subprocess output.
2972 This is done to improve the buffering of subprocess output, by
2973 avoiding the inefficiency of frequently reading small amounts of data.
2975 If positive, the value is the number of milliseconds to sleep before
2976 reading the subprocess output. If negative, the magnitude is the number
2977 of time slices to wait (effectively boosting the priority of the child
2978 process temporarily). A value of zero disables waiting entirely. */);
2979 w32_pipe_read_delay
= 50;
2981 DEFVAR_LISP ("w32-downcase-file-names", Vw32_downcase_file_names
,
2982 doc
: /* Non-nil means convert all-upper case file names to lower case.
2983 This applies when performing completions and file name expansion.
2984 Note that the value of this setting also affects remote file names,
2985 so you probably don't want to set to non-nil if you use case-sensitive
2986 filesystems via ange-ftp. */);
2987 Vw32_downcase_file_names
= Qnil
;
2990 DEFVAR_LISP ("w32-generate-fake-inodes", Vw32_generate_fake_inodes
,
2991 doc
: /* Non-nil means attempt to fake realistic inode values.
2992 This works by hashing the truename of files, and should detect
2993 aliasing between long and short (8.3 DOS) names, but can have
2994 false positives because of hash collisions. Note that determining
2995 the truename of a file can be slow. */);
2996 Vw32_generate_fake_inodes
= Qnil
;
2999 DEFVAR_LISP ("w32-get-true-file-attributes", Vw32_get_true_file_attributes
,
3000 doc
: /* Non-nil means determine accurate file attributes in `file-attributes'.
3001 This option controls whether to issue additional system calls to determine
3002 accurate link counts, file type, and ownership information. It is more
3003 useful for files on NTFS volumes, where hard links and file security are
3004 supported, than on volumes of the FAT family.
3006 Without these system calls, link count will always be reported as 1 and file
3007 ownership will be attributed to the current user.
3008 The default value `local' means only issue these system calls for files
3009 on local fixed drives. A value of nil means never issue them.
3010 Any other non-nil value means do this even on remote and removable drives
3011 where the performance impact may be noticeable even on modern hardware. */);
3012 Vw32_get_true_file_attributes
= Qlocal
;
3014 staticpro (&Vw32_valid_locale_ids
);
3015 staticpro (&Vw32_valid_codepages
);
3017 /* end of w32proc.c */