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 /* Return a suitable time value, in 1-ms units, for THREAD, a handle
276 to a thread. If THREAD is NULL or an invalid handle, return the
277 current wall-clock time since January 1, 1601 (UTC). Otherwise,
278 return the sum of kernel and user times used by THREAD since it was
279 created, plus its creation time. */
281 w32_get_timer_time (HANDLE thread
)
284 int use_system_time
= 1;
286 if (thread
&& thread
!= INVALID_HANDLE_VALUE
287 && s_pfn_Get_Thread_Times
!= NULL
)
289 FILETIME creation_ftime
, exit_ftime
, kernel_ftime
, user_ftime
;
290 ULARGE_INTEGER temp_creation
, temp_kernel
, temp_user
;
292 if (s_pfn_Get_Thread_Times (thread
, &creation_ftime
, &exit_ftime
,
293 &kernel_ftime
, &user_ftime
))
296 temp_creation
.LowPart
= creation_ftime
.dwLowDateTime
;
297 temp_creation
.HighPart
= creation_ftime
.dwHighDateTime
;
298 temp_kernel
.LowPart
= kernel_ftime
.dwLowDateTime
;
299 temp_kernel
.HighPart
= kernel_ftime
.dwHighDateTime
;
300 temp_user
.LowPart
= user_ftime
.dwLowDateTime
;
301 temp_user
.HighPart
= user_ftime
.dwHighDateTime
;
303 temp_creation
.QuadPart
/ 10000 + temp_kernel
.QuadPart
/ 10000
304 + temp_user
.QuadPart
/ 10000;
307 DebPrint (("GetThreadTimes failed with error code %lu\n",
313 FILETIME current_ftime
;
316 GetSystemTimeAsFileTime (¤t_ftime
);
318 temp
.LowPart
= current_ftime
.dwLowDateTime
;
319 temp
.HighPart
= current_ftime
.dwHighDateTime
;
321 retval
= temp
.QuadPart
/ 10000;
327 #define MAX_SINGLE_SLEEP 30
329 /* Thread function for a timer thread. */
331 timer_loop (LPVOID arg
)
333 struct itimer_data
*itimer
= (struct itimer_data
*)arg
;
334 int which
= itimer
->type
;
335 int sig
= (which
== ITIMER_REAL
) ? SIGALRM
: SIGPROF
;
336 CRITICAL_SECTION
*crit
= (which
== ITIMER_REAL
) ? &crit_real
: &crit_prof
;
337 const DWORD max_sleep
= MAX_SINGLE_SLEEP
* 1000 / CLOCKS_PER_SEC
;
339 HANDLE hth
= (which
== ITIMER_REAL
) ? NULL
: itimer
->caller_thread
;
344 signal_handler handler
;
345 ULONGLONG now
, expire
, reload
;
347 /* Load new values if requested by setitimer. */
348 EnterCriticalSection (crit
);
349 expire
= itimer
->expire
;
350 reload
= itimer
->reload
;
351 LeaveCriticalSection (crit
);
352 if (itimer
->terminate
)
362 if (expire
> (now
= w32_get_timer_time (hth
)))
363 sleep_time
= expire
- now
;
366 /* Don't sleep too long at a time, to be able to see the
367 termination flag without too long a delay. */
368 while (sleep_time
> max_sleep
)
370 if (itimer
->terminate
)
373 EnterCriticalSection (crit
);
374 expire
= itimer
->expire
;
375 LeaveCriticalSection (crit
);
377 (expire
> (now
= w32_get_timer_time (hth
))) ? expire
- now
: 0;
379 if (itimer
->terminate
)
383 Sleep (sleep_time
* 1000 / CLOCKS_PER_SEC
);
384 /* Always sleep past the expiration time, to make sure we
385 never call the handler _before_ the expiration time,
386 always slightly after it. Sleep(5) makes sure we don't
387 hog the CPU by calling 'w32_get_timer_time' with high
388 frequency, and also let other threads work. */
389 while (w32_get_timer_time (hth
) < expire
)
393 EnterCriticalSection (crit
);
394 expire
= itimer
->expire
;
395 LeaveCriticalSection (crit
);
400 handler
= sig_handlers
[sig
];
401 if (!(handler
== SIG_DFL
|| handler
== SIG_IGN
|| handler
== SIG_ERR
)
402 /* FIXME: Don't ignore masked signals. Instead, record that
403 they happened and reissue them when the signal is
405 && !sigismember (&sig_mask
, sig
)
406 /* Simulate masking of SIGALRM and SIGPROF when processing
408 && !fatal_error_in_progress
409 && itimer
->caller_thread
)
411 /* Simulate a signal delivered to the thread which installed
412 the timer, by suspending that thread while the handler
414 DWORD result
= SuspendThread (itimer
->caller_thread
);
416 if (result
== (DWORD
)-1)
420 ResumeThread (itimer
->caller_thread
);
423 /* Update expiration time and loop. */
424 EnterCriticalSection (crit
);
425 expire
= itimer
->expire
;
428 LeaveCriticalSection (crit
);
431 reload
= itimer
->reload
;
434 now
= w32_get_timer_time (hth
);
437 ULONGLONG lag
= now
- expire
;
439 /* If we missed some opportunities (presumably while
440 sleeping or while the signal handler ran), skip
443 expire
= now
- (lag
% reload
);
449 expire
= 0; /* become idle */
450 itimer
->expire
= expire
;
451 LeaveCriticalSection (crit
);
457 stop_timer_thread (int which
)
459 struct itimer_data
*itimer
=
460 (which
== ITIMER_REAL
) ? &real_itimer
: &prof_itimer
;
462 DWORD err
, exit_code
= 255;
465 /* Signal the thread that it should terminate. */
466 itimer
->terminate
= 1;
468 if (itimer
->timer_thread
== NULL
)
471 /* Wait for the timer thread to terminate voluntarily, then kill it
472 if it doesn't. This loop waits twice more than the maximum
473 amount of time a timer thread sleeps, see above. */
474 for (i
= 0; i
< MAX_SINGLE_SLEEP
/ 5; i
++)
476 if (!((status
= GetExitCodeThread (itimer
->timer_thread
, &exit_code
))
477 && exit_code
== STILL_ACTIVE
))
481 if ((status
== FALSE
&& (err
= GetLastError ()) == ERROR_INVALID_HANDLE
)
482 || exit_code
== STILL_ACTIVE
)
484 if (!(status
== FALSE
&& err
== ERROR_INVALID_HANDLE
))
485 TerminateThread (itimer
->timer_thread
, 0);
489 CloseHandle (itimer
->timer_thread
);
490 itimer
->timer_thread
= NULL
;
491 if (itimer
->caller_thread
)
493 CloseHandle (itimer
->caller_thread
);
494 itimer
->caller_thread
= NULL
;
498 /* This is called at shutdown time from term_ntproc. */
502 if (real_itimer
.timer_thread
)
503 stop_timer_thread (ITIMER_REAL
);
504 if (prof_itimer
.timer_thread
)
505 stop_timer_thread (ITIMER_PROF
);
507 /* We are going to delete the critical sections, so timers cannot
511 DeleteCriticalSection (&crit_real
);
512 DeleteCriticalSection (&crit_prof
);
513 DeleteCriticalSection (&crit_sig
);
516 /* This is called at initialization time from init_ntproc. */
520 /* GetThreadTimes is not avaiulable on all versions of Windows, so
521 need to probe for its availability dynamically, and call it
522 through a pointer. */
523 s_pfn_Get_Thread_Times
= NULL
; /* in case dumped Emacs comes with a value */
524 if (os_subtype
!= OS_9X
)
525 s_pfn_Get_Thread_Times
=
526 (GetThreadTimes_Proc
)GetProcAddress (GetModuleHandle ("kernel32.dll"),
529 /* Make sure we start with zeroed out itimer structures, since
530 dumping may have left there traces of threads long dead. */
531 memset (&real_itimer
, 0, sizeof real_itimer
);
532 memset (&prof_itimer
, 0, sizeof prof_itimer
);
534 InitializeCriticalSection (&crit_real
);
535 InitializeCriticalSection (&crit_prof
);
536 InitializeCriticalSection (&crit_sig
);
542 start_timer_thread (int which
)
545 struct itimer_data
*itimer
=
546 (which
== ITIMER_REAL
) ? &real_itimer
: &prof_itimer
;
548 if (itimer
->timer_thread
549 && GetExitCodeThread (itimer
->timer_thread
, &exit_code
)
550 && exit_code
== STILL_ACTIVE
)
553 /* Start a new thread. */
554 itimer
->terminate
= 0;
555 itimer
->type
= which
;
556 /* Request that no more than 64KB of stack be reserved for this
557 thread, to avoid reserving too much memory, which would get in
558 the way of threads we start to wait for subprocesses. See also
560 itimer
->timer_thread
= CreateThread (NULL
, 64 * 1024, timer_loop
,
561 (void *)itimer
, 0x00010000, NULL
);
563 if (!itimer
->timer_thread
)
565 CloseHandle (itimer
->caller_thread
);
566 itimer
->caller_thread
= NULL
;
571 /* This is needed to make sure that the timer thread running for
572 profiling gets CPU as soon as the Sleep call terminates. */
573 if (which
== ITIMER_PROF
)
574 SetThreadPriority (itimer
->caller_thread
, THREAD_PRIORITY_TIME_CRITICAL
);
579 /* Most of the code of getitimer and setitimer (but not of their
580 subroutines) was shamelessly stolen from itimer.c in the DJGPP
581 library, see www.delorie.com/djgpp. */
583 getitimer (int which
, struct itimerval
*value
)
585 volatile ULONGLONG
*t_expire
;
586 volatile ULONGLONG
*t_reload
;
587 ULONGLONG expire
, reload
;
589 CRITICAL_SECTION
*crit
;
590 struct itimer_data
*itimer
;
601 if (which
!= ITIMER_REAL
&& which
!= ITIMER_PROF
)
607 itimer
= (which
== ITIMER_REAL
) ? &real_itimer
: &prof_itimer
;
609 if (!DuplicateHandle (GetCurrentProcess (), GetCurrentThread (),
610 GetCurrentProcess (), &itimer
->caller_thread
, 0,
611 FALSE
, DUPLICATE_SAME_ACCESS
))
617 ticks_now
= w32_get_timer_time ((which
== ITIMER_REAL
)
619 : itimer
->caller_thread
);
621 t_expire
= &itimer
->expire
;
622 t_reload
= &itimer
->reload
;
623 crit
= (which
== ITIMER_REAL
) ? &crit_real
: &crit_prof
;
625 EnterCriticalSection (crit
);
628 LeaveCriticalSection (crit
);
633 value
->it_value
.tv_sec
= expire
/ CLOCKS_PER_SEC
;
634 usecs
= (expire
% CLOCKS_PER_SEC
) * (__int64
)1000000 / CLOCKS_PER_SEC
;
635 value
->it_value
.tv_usec
= usecs
;
636 value
->it_interval
.tv_sec
= reload
/ CLOCKS_PER_SEC
;
637 usecs
= (reload
% CLOCKS_PER_SEC
) * (__int64
)1000000 / CLOCKS_PER_SEC
;
638 value
->it_interval
.tv_usec
= usecs
;
644 setitimer(int which
, struct itimerval
*value
, struct itimerval
*ovalue
)
646 volatile ULONGLONG
*t_expire
, *t_reload
;
647 ULONGLONG expire
, reload
, expire_old
, reload_old
;
649 CRITICAL_SECTION
*crit
;
650 struct itimerval tem
, *ptem
;
655 /* Posix systems expect timer values smaller than the resolution of
656 the system clock be rounded up to the clock resolution. First
657 time we are called, measure the clock tick resolution. */
662 for (t1
= w32_get_timer_time (NULL
);
663 (t2
= w32_get_timer_time (NULL
)) == t1
; )
665 clocks_min
= t2
- t1
;
673 if (getitimer (which
, ptem
)) /* also sets ticks_now */
674 return -1; /* errno already set */
677 (which
== ITIMER_REAL
) ? &real_itimer
.expire
: &prof_itimer
.expire
;
679 (which
== ITIMER_REAL
) ? &real_itimer
.reload
: &prof_itimer
.reload
;
681 crit
= (which
== ITIMER_REAL
) ? &crit_real
: &crit_prof
;
684 || (value
->it_value
.tv_sec
== 0 && value
->it_value
.tv_usec
== 0))
686 EnterCriticalSection (crit
);
687 /* Disable the timer. */
690 LeaveCriticalSection (crit
);
694 reload
= value
->it_interval
.tv_sec
* CLOCKS_PER_SEC
;
696 usecs
= value
->it_interval
.tv_usec
;
697 if (value
->it_interval
.tv_sec
== 0
698 && usecs
&& usecs
* CLOCKS_PER_SEC
< clocks_min
* 1000000)
702 usecs
*= CLOCKS_PER_SEC
;
703 reload
+= usecs
/ 1000000;
706 expire
= value
->it_value
.tv_sec
* CLOCKS_PER_SEC
;
707 usecs
= value
->it_value
.tv_usec
;
708 if (value
->it_value
.tv_sec
== 0
709 && usecs
* CLOCKS_PER_SEC
< clocks_min
* 1000000)
713 usecs
*= CLOCKS_PER_SEC
;
714 expire
+= usecs
/ 1000000;
719 EnterCriticalSection (crit
);
720 expire_old
= *t_expire
;
721 reload_old
= *t_reload
;
722 if (!(expire
== expire_old
&& reload
== reload_old
))
727 LeaveCriticalSection (crit
);
729 return start_timer_thread (which
);
735 #ifdef HAVE_SETITIMER
736 struct itimerval new_values
, old_values
;
738 new_values
.it_value
.tv_sec
= seconds
;
739 new_values
.it_value
.tv_usec
= 0;
740 new_values
.it_interval
.tv_sec
= new_values
.it_interval
.tv_usec
= 0;
742 if (setitimer (ITIMER_REAL
, &new_values
, &old_values
) < 0)
744 return old_values
.it_value
.tv_sec
;
750 /* Defined in <process.h> which conflicts with the local copy */
753 /* Child process management list. */
754 int child_proc_count
= 0;
755 child_process child_procs
[ MAX_CHILDREN
];
756 child_process
*dead_child
= NULL
;
758 static DWORD WINAPI
reader_thread (void *arg
);
760 /* Find an unused process slot. */
767 for (cp
= child_procs
+ (child_proc_count
-1); cp
>= child_procs
; cp
--)
768 if (!CHILD_ACTIVE (cp
))
770 if (child_proc_count
== MAX_CHILDREN
)
772 cp
= &child_procs
[child_proc_count
++];
775 memset (cp
, 0, sizeof (*cp
));
778 cp
->procinfo
.hProcess
= NULL
;
779 cp
->status
= STATUS_READ_ERROR
;
781 /* use manual reset event so that select() will function properly */
782 cp
->char_avail
= CreateEvent (NULL
, TRUE
, FALSE
, NULL
);
785 cp
->char_consumed
= CreateEvent (NULL
, FALSE
, FALSE
, NULL
);
786 if (cp
->char_consumed
)
788 /* The 0x00010000 flag is STACK_SIZE_PARAM_IS_A_RESERVATION.
789 It means that the 64K stack we are requesting in the 2nd
790 argument is how much memory should be reserved for the
791 stack. If we don't use this flag, the memory requested
792 by the 2nd argument is the amount actually _committed_,
793 but Windows reserves 8MB of memory for each thread's
794 stack. (The 8MB figure comes from the -stack
795 command-line argument we pass to the linker when building
796 Emacs, but that's because we need a large stack for
797 Emacs's main thread.) Since we request 2GB of reserved
798 memory at startup (see w32heap.c), which is close to the
799 maximum memory available for a 32-bit process on Windows,
800 the 8MB reservation for each thread causes failures in
801 starting subprocesses, because we create a thread running
802 reader_thread for each subprocess. As 8MB of stack is
803 way too much for reader_thread, forcing Windows to
804 reserve less wins the day. */
805 cp
->thrd
= CreateThread (NULL
, 64 * 1024, reader_thread
, cp
,
816 delete_child (child_process
*cp
)
820 /* Should not be deleting a child that is still needed. */
821 for (i
= 0; i
< MAXDESC
; i
++)
822 if (fd_info
[i
].cp
== cp
)
825 if (!CHILD_ACTIVE (cp
))
828 /* reap thread if necessary */
833 if (GetExitCodeThread (cp
->thrd
, &rc
) && rc
== STILL_ACTIVE
)
835 /* let the thread exit cleanly if possible */
836 cp
->status
= STATUS_READ_ERROR
;
837 SetEvent (cp
->char_consumed
);
839 /* We used to forcibly terminate the thread here, but it
840 is normally unnecessary, and in abnormal cases, the worst that
841 will happen is we have an extra idle thread hanging around
842 waiting for the zombie process. */
843 if (WaitForSingleObject (cp
->thrd
, 1000) != WAIT_OBJECT_0
)
845 DebPrint (("delete_child.WaitForSingleObject (thread) failed "
846 "with %lu for fd %ld\n", GetLastError (), cp
->fd
));
847 TerminateThread (cp
->thrd
, 0);
851 CloseHandle (cp
->thrd
);
856 CloseHandle (cp
->char_avail
);
857 cp
->char_avail
= NULL
;
859 if (cp
->char_consumed
)
861 CloseHandle (cp
->char_consumed
);
862 cp
->char_consumed
= NULL
;
865 /* update child_proc_count (highest numbered slot in use plus one) */
866 if (cp
== child_procs
+ child_proc_count
- 1)
868 for (i
= child_proc_count
-1; i
>= 0; i
--)
869 if (CHILD_ACTIVE (&child_procs
[i
]))
871 child_proc_count
= i
+ 1;
876 child_proc_count
= 0;
879 /* Find a child by pid. */
880 static child_process
*
881 find_child_pid (DWORD pid
)
885 for (cp
= child_procs
+ (child_proc_count
-1); cp
>= child_procs
; cp
--)
886 if (CHILD_ACTIVE (cp
) && pid
== cp
->pid
)
892 /* Thread proc for child process and socket reader threads. Each thread
893 is normally blocked until woken by select() to check for input by
894 reading one char. When the read completes, char_avail is signaled
895 to wake up the select emulator and the thread blocks itself again. */
897 reader_thread (void *arg
)
902 cp
= (child_process
*)arg
;
904 /* We have to wait for the go-ahead before we can start */
906 || WaitForSingleObject (cp
->char_consumed
, INFINITE
) != WAIT_OBJECT_0
914 if (fd_info
[cp
->fd
].flags
& FILE_LISTEN
)
915 rc
= _sys_wait_accept (cp
->fd
);
917 rc
= _sys_read_ahead (cp
->fd
);
919 /* The name char_avail is a misnomer - it really just means the
920 read-ahead has completed, whether successfully or not. */
921 if (!SetEvent (cp
->char_avail
))
923 DebPrint (("reader_thread.SetEvent failed with %lu for fd %ld\n",
924 GetLastError (), cp
->fd
));
928 if (rc
== STATUS_READ_ERROR
)
931 /* If the read died, the child has died so let the thread die */
932 if (rc
== STATUS_READ_FAILED
)
935 /* Wait until our input is acknowledged before reading again */
936 if (WaitForSingleObject (cp
->char_consumed
, INFINITE
) != WAIT_OBJECT_0
)
938 DebPrint (("reader_thread.WaitForSingleObject failed with "
939 "%lu for fd %ld\n", GetLastError (), cp
->fd
));
946 /* To avoid Emacs changing directory, we just record here the directory
947 the new process should start in. This is set just before calling
948 sys_spawnve, and is not generally valid at any other time. */
949 static char * process_dir
;
952 create_child (char *exe
, char *cmdline
, char *env
, int is_gui_app
,
953 int * pPid
, child_process
*cp
)
956 SECURITY_ATTRIBUTES sec_attrs
;
958 SECURITY_DESCRIPTOR sec_desc
;
961 char dir
[ MAXPATHLEN
];
963 if (cp
== NULL
) emacs_abort ();
965 memset (&start
, 0, sizeof (start
));
966 start
.cb
= sizeof (start
);
969 if (NILP (Vw32_start_process_show_window
) && !is_gui_app
)
970 start
.dwFlags
= STARTF_USESTDHANDLES
| STARTF_USESHOWWINDOW
;
972 start
.dwFlags
= STARTF_USESTDHANDLES
;
973 start
.wShowWindow
= SW_HIDE
;
975 start
.hStdInput
= GetStdHandle (STD_INPUT_HANDLE
);
976 start
.hStdOutput
= GetStdHandle (STD_OUTPUT_HANDLE
);
977 start
.hStdError
= GetStdHandle (STD_ERROR_HANDLE
);
978 #endif /* HAVE_NTGUI */
981 /* Explicitly specify no security */
982 if (!InitializeSecurityDescriptor (&sec_desc
, SECURITY_DESCRIPTOR_REVISION
))
984 if (!SetSecurityDescriptorDacl (&sec_desc
, TRUE
, NULL
, FALSE
))
987 sec_attrs
.nLength
= sizeof (sec_attrs
);
988 sec_attrs
.lpSecurityDescriptor
= NULL
/* &sec_desc */;
989 sec_attrs
.bInheritHandle
= FALSE
;
991 strcpy (dir
, process_dir
);
992 unixtodos_filename (dir
);
994 flags
= (!NILP (Vw32_start_process_share_console
)
995 ? CREATE_NEW_PROCESS_GROUP
996 : CREATE_NEW_CONSOLE
);
997 if (NILP (Vw32_start_process_inherit_error_mode
))
998 flags
|= CREATE_DEFAULT_ERROR_MODE
;
999 if (!CreateProcess (exe
, cmdline
, &sec_attrs
, NULL
, TRUE
,
1000 flags
, env
, dir
, &start
, &cp
->procinfo
))
1003 cp
->pid
= (int) cp
->procinfo
.dwProcessId
;
1005 /* Hack for Windows 95, which assigns large (ie negative) pids */
1009 /* pid must fit in a Lisp_Int */
1010 cp
->pid
= cp
->pid
& INTMASK
;
1017 DebPrint (("create_child.CreateProcess failed: %ld\n", GetLastError ()););
1021 /* create_child doesn't know what emacs' file handle will be for waiting
1022 on output from the child, so we need to make this additional call
1023 to register the handle with the process
1024 This way the select emulator knows how to match file handles with
1025 entries in child_procs. */
1027 register_child (int pid
, int fd
)
1031 cp
= find_child_pid (pid
);
1034 DebPrint (("register_child unable to find pid %lu\n", pid
));
1039 DebPrint (("register_child registered fd %d with pid %lu\n", fd
, pid
));
1044 /* thread is initially blocked until select is called; set status so
1045 that select will release thread */
1046 cp
->status
= STATUS_READ_ACKNOWLEDGED
;
1048 /* attach child_process to fd_info */
1049 if (fd_info
[fd
].cp
!= NULL
)
1051 DebPrint (("register_child: fd_info[%d] apparently in use!\n", fd
));
1055 fd_info
[fd
].cp
= cp
;
1058 /* When a process dies its pipe will break so the reader thread will
1059 signal failure to the select emulator.
1060 The select emulator then calls this routine to clean up.
1061 Since the thread signaled failure we can assume it is exiting. */
1063 reap_subprocess (child_process
*cp
)
1065 if (cp
->procinfo
.hProcess
)
1067 /* Reap the process */
1069 /* Process should have already died before we are called. */
1070 if (WaitForSingleObject (cp
->procinfo
.hProcess
, 0) != WAIT_OBJECT_0
)
1071 DebPrint (("reap_subprocess: child fpr fd %d has not died yet!", cp
->fd
));
1073 CloseHandle (cp
->procinfo
.hProcess
);
1074 cp
->procinfo
.hProcess
= NULL
;
1075 CloseHandle (cp
->procinfo
.hThread
);
1076 cp
->procinfo
.hThread
= NULL
;
1079 /* For asynchronous children, the child_proc resources will be freed
1080 when the last pipe read descriptor is closed; for synchronous
1081 children, we must explicitly free the resources now because
1082 register_child has not been called. */
1087 /* Wait for any of our existing child processes to die
1088 When it does, close its handle
1089 Return the pid and fill in the status if non-NULL. */
1092 sys_wait (int *status
)
1094 DWORD active
, retval
;
1097 child_process
*cp
, *cps
[MAX_CHILDREN
];
1098 HANDLE wait_hnd
[MAX_CHILDREN
];
1101 if (dead_child
!= NULL
)
1103 /* We want to wait for a specific child */
1104 wait_hnd
[nh
] = dead_child
->procinfo
.hProcess
;
1105 cps
[nh
] = dead_child
;
1106 if (!wait_hnd
[nh
]) emacs_abort ();
1113 for (cp
= child_procs
+ (child_proc_count
-1); cp
>= child_procs
; cp
--)
1114 /* some child_procs might be sockets; ignore them */
1115 if (CHILD_ACTIVE (cp
) && cp
->procinfo
.hProcess
1116 && (cp
->fd
< 0 || (fd_info
[cp
->fd
].flags
& FILE_AT_EOF
) != 0))
1118 wait_hnd
[nh
] = cp
->procinfo
.hProcess
;
1126 /* Nothing to wait on, so fail */
1133 /* Check for quit about once a second. */
1135 active
= WaitForMultipleObjects (nh
, wait_hnd
, FALSE
, 1000);
1136 } while (active
== WAIT_TIMEOUT
);
1138 if (active
== WAIT_FAILED
)
1143 else if (active
>= WAIT_OBJECT_0
1144 && active
< WAIT_OBJECT_0
+MAXIMUM_WAIT_OBJECTS
)
1146 active
-= WAIT_OBJECT_0
;
1148 else if (active
>= WAIT_ABANDONED_0
1149 && active
< WAIT_ABANDONED_0
+MAXIMUM_WAIT_OBJECTS
)
1151 active
-= WAIT_ABANDONED_0
;
1157 if (!GetExitCodeProcess (wait_hnd
[active
], &retval
))
1159 DebPrint (("Wait.GetExitCodeProcess failed with %lu\n",
1163 if (retval
== STILL_ACTIVE
)
1165 /* Should never happen */
1166 DebPrint (("Wait.WaitForMultipleObjects returned an active process\n"));
1171 /* Massage the exit code from the process to match the format expected
1172 by the WIFSTOPPED et al macros in syswait.h. Only WIFSIGNALED and
1173 WIFEXITED are supported; WIFSTOPPED doesn't make sense under NT. */
1175 if (retval
== STATUS_CONTROL_C_EXIT
)
1183 DebPrint (("Wait signaled with process pid %d\n", cp
->pid
));
1190 else if (synch_process_alive
)
1192 synch_process_alive
= 0;
1194 /* Report the status of the synchronous process. */
1195 if (WIFEXITED (retval
))
1196 synch_process_retcode
= WEXITSTATUS (retval
);
1197 else if (WIFSIGNALED (retval
))
1199 int code
= WTERMSIG (retval
);
1200 const char *signame
;
1202 synchronize_system_messages_locale ();
1203 signame
= strsignal (code
);
1206 signame
= "unknown";
1208 synch_process_death
= signame
;
1211 reap_subprocess (cp
);
1214 reap_subprocess (cp
);
1219 /* Old versions of w32api headers don't have separate 32-bit and
1220 64-bit defines, but the one they have matches the 32-bit variety. */
1221 #ifndef IMAGE_NT_OPTIONAL_HDR32_MAGIC
1222 # define IMAGE_NT_OPTIONAL_HDR32_MAGIC IMAGE_NT_OPTIONAL_HDR_MAGIC
1223 # define IMAGE_OPTIONAL_HEADER32 IMAGE_OPTIONAL_HEADER
1227 w32_executable_type (char * filename
,
1229 int * is_cygnus_app
,
1232 file_data executable
;
1235 /* Default values in case we can't tell for sure. */
1236 *is_dos_app
= FALSE
;
1237 *is_cygnus_app
= FALSE
;
1238 *is_gui_app
= FALSE
;
1240 if (!open_input_file (&executable
, filename
))
1243 p
= strrchr (filename
, '.');
1245 /* We can only identify DOS .com programs from the extension. */
1246 if (p
&& xstrcasecmp (p
, ".com") == 0)
1248 else if (p
&& (xstrcasecmp (p
, ".bat") == 0
1249 || xstrcasecmp (p
, ".cmd") == 0))
1251 /* A DOS shell script - it appears that CreateProcess is happy to
1252 accept this (somewhat surprisingly); presumably it looks at
1253 COMSPEC to determine what executable to actually invoke.
1254 Therefore, we have to do the same here as well. */
1255 /* Actually, I think it uses the program association for that
1256 extension, which is defined in the registry. */
1257 p
= egetenv ("COMSPEC");
1259 w32_executable_type (p
, is_dos_app
, is_cygnus_app
, is_gui_app
);
1263 /* Look for DOS .exe signature - if found, we must also check that
1264 it isn't really a 16- or 32-bit Windows exe, since both formats
1265 start with a DOS program stub. Note that 16-bit Windows
1266 executables use the OS/2 1.x format. */
1268 IMAGE_DOS_HEADER
* dos_header
;
1269 IMAGE_NT_HEADERS
* nt_header
;
1271 dos_header
= (PIMAGE_DOS_HEADER
) executable
.file_base
;
1272 if (dos_header
->e_magic
!= IMAGE_DOS_SIGNATURE
)
1275 nt_header
= (PIMAGE_NT_HEADERS
) ((unsigned char *) dos_header
+ dos_header
->e_lfanew
);
1277 if ((char *) nt_header
> (char *) dos_header
+ executable
.size
)
1279 /* Some dos headers (pkunzip) have bogus e_lfanew fields. */
1282 else if (nt_header
->Signature
!= IMAGE_NT_SIGNATURE
1283 && LOWORD (nt_header
->Signature
) != IMAGE_OS2_SIGNATURE
)
1287 else if (nt_header
->Signature
== IMAGE_NT_SIGNATURE
)
1289 IMAGE_DATA_DIRECTORY
*data_dir
= NULL
;
1290 if (nt_header
->OptionalHeader
.Magic
== IMAGE_NT_OPTIONAL_HDR32_MAGIC
)
1292 /* Ensure we are using the 32 bit structure. */
1293 IMAGE_OPTIONAL_HEADER32
*opt
1294 = (IMAGE_OPTIONAL_HEADER32
*) &(nt_header
->OptionalHeader
);
1295 data_dir
= opt
->DataDirectory
;
1296 *is_gui_app
= (opt
->Subsystem
== IMAGE_SUBSYSTEM_WINDOWS_GUI
);
1298 /* MingW 3.12 has the required 64 bit structs, but in case older
1299 versions don't, only check 64 bit exes if we know how. */
1300 #ifdef IMAGE_NT_OPTIONAL_HDR64_MAGIC
1301 else if (nt_header
->OptionalHeader
.Magic
1302 == IMAGE_NT_OPTIONAL_HDR64_MAGIC
)
1304 IMAGE_OPTIONAL_HEADER64
*opt
1305 = (IMAGE_OPTIONAL_HEADER64
*) &(nt_header
->OptionalHeader
);
1306 data_dir
= opt
->DataDirectory
;
1307 *is_gui_app
= (opt
->Subsystem
== IMAGE_SUBSYSTEM_WINDOWS_GUI
);
1312 /* Look for cygwin.dll in DLL import list. */
1313 IMAGE_DATA_DIRECTORY import_dir
=
1314 data_dir
[IMAGE_DIRECTORY_ENTRY_IMPORT
];
1315 IMAGE_IMPORT_DESCRIPTOR
* imports
;
1316 IMAGE_SECTION_HEADER
* section
;
1318 section
= rva_to_section (import_dir
.VirtualAddress
, nt_header
);
1319 imports
= RVA_TO_PTR (import_dir
.VirtualAddress
, section
,
1322 for ( ; imports
->Name
; imports
++)
1324 char * dllname
= RVA_TO_PTR (imports
->Name
, section
,
1327 /* The exact name of the cygwin dll has changed with
1328 various releases, but hopefully this will be reasonably
1330 if (strncmp (dllname
, "cygwin", 6) == 0)
1332 *is_cygnus_app
= TRUE
;
1341 close_file_data (&executable
);
1345 compare_env (const void *strp1
, const void *strp2
)
1347 const char *str1
= *(const char **)strp1
, *str2
= *(const char **)strp2
;
1349 while (*str1
&& *str2
&& *str1
!= '=' && *str2
!= '=')
1351 /* Sort order in command.com/cmd.exe is based on uppercasing
1352 names, so do the same here. */
1353 if (toupper (*str1
) > toupper (*str2
))
1355 else if (toupper (*str1
) < toupper (*str2
))
1360 if (*str1
== '=' && *str2
== '=')
1362 else if (*str1
== '=')
1369 merge_and_sort_env (char **envp1
, char **envp2
, char **new_envp
)
1371 char **optr
, **nptr
;
1383 num
+= optr
- envp2
;
1385 qsort (new_envp
, num
, sizeof (char *), compare_env
);
1390 /* When a new child process is created we need to register it in our list,
1391 so intercept spawn requests. */
1393 sys_spawnve (int mode
, char *cmdname
, char **argv
, char **envp
)
1395 Lisp_Object program
, full
;
1396 char *cmdline
, *env
, *parg
, **targ
;
1400 int is_dos_app
, is_cygnus_app
, is_gui_app
;
1403 /* We pass our process ID to our children by setting up an environment
1404 variable in their environment. */
1405 char ppid_env_var_buffer
[64];
1406 char *extra_env
[] = {ppid_env_var_buffer
, NULL
};
1407 /* These are the characters that cause an argument to need quoting.
1408 Arguments with whitespace characters need quoting to prevent the
1409 argument being split into two or more. Arguments with wildcards
1410 are also quoted, for consistency with posix platforms, where wildcards
1411 are not expanded if we run the program directly without a shell.
1412 Some extra whitespace characters need quoting in Cygwin programs,
1413 so this list is conditionally modified below. */
1414 char *sepchars
= " \t*?";
1416 /* We don't care about the other modes */
1417 if (mode
!= _P_NOWAIT
)
1423 /* Handle executable names without an executable suffix. */
1424 program
= build_string (cmdname
);
1425 if (NILP (Ffile_executable_p (program
)))
1427 struct gcpro gcpro1
;
1431 openp (Vexec_path
, program
, Vexec_suffixes
, &full
, make_number (X_OK
));
1441 /* make sure argv[0] and cmdname are both in DOS format */
1442 cmdname
= SDATA (program
);
1443 unixtodos_filename (cmdname
);
1446 /* Determine whether program is a 16-bit DOS executable, or a 32-bit Windows
1447 executable that is implicitly linked to the Cygnus dll (implying it
1448 was compiled with the Cygnus GNU toolchain and hence relies on
1449 cygwin.dll to parse the command line - we use this to decide how to
1450 escape quote chars in command line args that must be quoted).
1452 Also determine whether it is a GUI app, so that we don't hide its
1453 initial window unless specifically requested. */
1454 w32_executable_type (cmdname
, &is_dos_app
, &is_cygnus_app
, &is_gui_app
);
1456 /* On Windows 95, if cmdname is a DOS app, we invoke a helper
1457 application to start it by specifying the helper app as cmdname,
1458 while leaving the real app name as argv[0]. */
1461 cmdname
= alloca (MAXPATHLEN
);
1462 if (egetenv ("CMDPROXY"))
1463 strcpy (cmdname
, egetenv ("CMDPROXY"));
1466 strcpy (cmdname
, SDATA (Vinvocation_directory
));
1467 strcat (cmdname
, "cmdproxy.exe");
1469 unixtodos_filename (cmdname
);
1472 /* we have to do some conjuring here to put argv and envp into the
1473 form CreateProcess wants... argv needs to be a space separated/null
1474 terminated list of parameters, and envp is a null
1475 separated/double-null terminated list of parameters.
1477 Additionally, zero-length args and args containing whitespace or
1478 quote chars need to be wrapped in double quotes - for this to work,
1479 embedded quotes need to be escaped as well. The aim is to ensure
1480 the child process reconstructs the argv array we start with
1481 exactly, so we treat quotes at the beginning and end of arguments
1484 The w32 GNU-based library from Cygnus doubles quotes to escape
1485 them, while MSVC uses backslash for escaping. (Actually the MSVC
1486 startup code does attempt to recognize doubled quotes and accept
1487 them, but gets it wrong and ends up requiring three quotes to get a
1488 single embedded quote!) So by default we decide whether to use
1489 quote or backslash as the escape character based on whether the
1490 binary is apparently a Cygnus compiled app.
1492 Note that using backslash to escape embedded quotes requires
1493 additional special handling if an embedded quote is already
1494 preceded by backslash, or if an arg requiring quoting ends with
1495 backslash. In such cases, the run of escape characters needs to be
1496 doubled. For consistency, we apply this special handling as long
1497 as the escape character is not quote.
1499 Since we have no idea how large argv and envp are likely to be we
1500 figure out list lengths on the fly and allocate them. */
1502 if (!NILP (Vw32_quote_process_args
))
1505 /* Override escape char by binding w32-quote-process-args to
1506 desired character, or use t for auto-selection. */
1507 if (INTEGERP (Vw32_quote_process_args
))
1508 escape_char
= XINT (Vw32_quote_process_args
);
1510 escape_char
= is_cygnus_app
? '"' : '\\';
1513 /* Cygwin apps needs quoting a bit more often. */
1514 if (escape_char
== '"')
1515 sepchars
= "\r\n\t\f '";
1523 int need_quotes
= 0;
1524 int escape_char_run
= 0;
1530 if (escape_char
== '"' && *p
== '\\')
1531 /* If it's a Cygwin app, \ needs to be escaped. */
1535 /* allow for embedded quotes to be escaped */
1538 /* handle the case where the embedded quote is already escaped */
1539 if (escape_char_run
> 0)
1541 /* To preserve the arg exactly, we need to double the
1542 preceding escape characters (plus adding one to
1543 escape the quote character itself). */
1544 arglen
+= escape_char_run
;
1547 else if (strchr (sepchars
, *p
) != NULL
)
1552 if (*p
== escape_char
&& escape_char
!= '"')
1555 escape_char_run
= 0;
1560 /* handle the case where the arg ends with an escape char - we
1561 must not let the enclosing quote be escaped. */
1562 if (escape_char_run
> 0)
1563 arglen
+= escape_char_run
;
1565 arglen
+= strlen (*targ
++) + 1;
1567 cmdline
= alloca (arglen
);
1573 int need_quotes
= 0;
1581 if ((strchr (sepchars
, *p
) != NULL
) || *p
== '"')
1586 int escape_char_run
= 0;
1592 last
= p
+ strlen (p
) - 1;
1595 /* This version does not escape quotes if they occur at the
1596 beginning or end of the arg - this could lead to incorrect
1597 behavior when the arg itself represents a command line
1598 containing quoted args. I believe this was originally done
1599 as a hack to make some things work, before
1600 `w32-quote-process-args' was added. */
1603 if (*p
== '"' && p
> first
&& p
< last
)
1604 *parg
++ = escape_char
; /* escape embedded quotes */
1612 /* double preceding escape chars if any */
1613 while (escape_char_run
> 0)
1615 *parg
++ = escape_char
;
1618 /* escape all quote chars, even at beginning or end */
1619 *parg
++ = escape_char
;
1621 else if (escape_char
== '"' && *p
== '\\')
1625 if (*p
== escape_char
&& escape_char
!= '"')
1628 escape_char_run
= 0;
1630 /* double escape chars before enclosing quote */
1631 while (escape_char_run
> 0)
1633 *parg
++ = escape_char
;
1641 strcpy (parg
, *targ
);
1642 parg
+= strlen (*targ
);
1652 numenv
= 1; /* for end null */
1655 arglen
+= strlen (*targ
++) + 1;
1658 /* extra env vars... */
1659 sprintf (ppid_env_var_buffer
, "EM_PARENT_PROCESS_ID=%d",
1660 GetCurrentProcessId ());
1661 arglen
+= strlen (ppid_env_var_buffer
) + 1;
1664 /* merge env passed in and extra env into one, and sort it. */
1665 targ
= (char **) alloca (numenv
* sizeof (char *));
1666 merge_and_sort_env (envp
, extra_env
, targ
);
1668 /* concatenate env entries. */
1669 env
= alloca (arglen
);
1673 strcpy (parg
, *targ
);
1674 parg
+= strlen (*targ
++);
1687 /* Now create the process. */
1688 if (!create_child (cmdname
, cmdline
, env
, is_gui_app
, &pid
, cp
))
1698 /* Emulate the select call
1699 Wait for available input on any of the given rfds, or timeout if
1700 a timeout is given and no input is detected
1701 wfds and efds are not supported and must be NULL.
1703 For simplicity, we detect the death of child processes here and
1704 synchronously call the SIGCHLD handler. Since it is possible for
1705 children to be created without a corresponding pipe handle from which
1706 to read output, we wait separately on the process handles as well as
1707 the char_avail events for each process pipe. We only call
1708 wait/reap_process when the process actually terminates.
1710 To reduce the number of places in which Emacs can be hung such that
1711 C-g is not able to interrupt it, we always wait on interrupt_handle
1712 (which is signaled by the input thread when C-g is detected). If we
1713 detect that we were woken up by C-g, we return -1 with errno set to
1714 EINTR as on Unix. */
1716 /* From w32console.c */
1717 extern HANDLE keyboard_handle
;
1719 /* From w32xfns.c */
1720 extern HANDLE interrupt_handle
;
1722 /* From process.c */
1723 extern int proc_buffered_char
[];
1726 sys_select (int nfds
, SELECT_TYPE
*rfds
, SELECT_TYPE
*wfds
, SELECT_TYPE
*efds
,
1727 EMACS_TIME
*timeout
, void *ignored
)
1730 DWORD timeout_ms
, start_time
;
1733 child_process
*cp
, *cps
[MAX_CHILDREN
];
1734 HANDLE wait_hnd
[MAXDESC
+ MAX_CHILDREN
];
1735 int fdindex
[MAXDESC
]; /* mapping from wait handles back to descriptors */
1738 timeout
? (timeout
->tv_sec
* 1000 + timeout
->tv_nsec
/ 1000000) : INFINITE
;
1740 /* If the descriptor sets are NULL but timeout isn't, then just Sleep. */
1741 if (rfds
== NULL
&& wfds
== NULL
&& efds
== NULL
&& timeout
!= NULL
)
1747 /* Otherwise, we only handle rfds, so fail otherwise. */
1748 if (rfds
== NULL
|| wfds
!= NULL
|| efds
!= NULL
)
1758 /* Always wait on interrupt_handle, to detect C-g (quit). */
1759 wait_hnd
[0] = interrupt_handle
;
1762 /* Build a list of pipe handles to wait on. */
1764 for (i
= 0; i
< nfds
; i
++)
1765 if (FD_ISSET (i
, &orfds
))
1769 if (keyboard_handle
)
1771 /* Handle stdin specially */
1772 wait_hnd
[nh
] = keyboard_handle
;
1777 /* Check for any emacs-generated input in the queue since
1778 it won't be detected in the wait */
1779 if (detect_input_pending ())
1787 /* Child process and socket input */
1791 int current_status
= cp
->status
;
1793 if (current_status
== STATUS_READ_ACKNOWLEDGED
)
1795 /* Tell reader thread which file handle to use. */
1797 /* Wake up the reader thread for this process */
1798 cp
->status
= STATUS_READ_READY
;
1799 if (!SetEvent (cp
->char_consumed
))
1800 DebPrint (("nt_select.SetEvent failed with "
1801 "%lu for fd %ld\n", GetLastError (), i
));
1804 #ifdef CHECK_INTERLOCK
1805 /* slightly crude cross-checking of interlock between threads */
1807 current_status
= cp
->status
;
1808 if (WaitForSingleObject (cp
->char_avail
, 0) == WAIT_OBJECT_0
)
1810 /* char_avail has been signaled, so status (which may
1811 have changed) should indicate read has completed
1812 but has not been acknowledged. */
1813 current_status
= cp
->status
;
1814 if (current_status
!= STATUS_READ_SUCCEEDED
1815 && current_status
!= STATUS_READ_FAILED
)
1816 DebPrint (("char_avail set, but read not completed: status %d\n",
1821 /* char_avail has not been signaled, so status should
1822 indicate that read is in progress; small possibility
1823 that read has completed but event wasn't yet signaled
1824 when we tested it (because a context switch occurred
1825 or if running on separate CPUs). */
1826 if (current_status
!= STATUS_READ_READY
1827 && current_status
!= STATUS_READ_IN_PROGRESS
1828 && current_status
!= STATUS_READ_SUCCEEDED
1829 && current_status
!= STATUS_READ_FAILED
)
1830 DebPrint (("char_avail reset, but read status is bad: %d\n",
1834 wait_hnd
[nh
] = cp
->char_avail
;
1836 if (!wait_hnd
[nh
]) emacs_abort ();
1839 DebPrint (("select waiting on child %d fd %d\n",
1840 cp
-child_procs
, i
));
1845 /* Unable to find something to wait on for this fd, skip */
1847 /* Note that this is not a fatal error, and can in fact
1848 happen in unusual circumstances. Specifically, if
1849 sys_spawnve fails, eg. because the program doesn't
1850 exist, and debug-on-error is t so Fsignal invokes a
1851 nested input loop, then the process output pipe is
1852 still included in input_wait_mask with no child_proc
1853 associated with it. (It is removed when the debugger
1854 exits the nested input loop and the error is thrown.) */
1856 DebPrint (("sys_select: fd %ld is invalid! ignoring\n", i
));
1862 /* Add handles of child processes. */
1864 for (cp
= child_procs
+ (child_proc_count
-1); cp
>= child_procs
; cp
--)
1865 /* Some child_procs might be sockets; ignore them. Also some
1866 children may have died already, but we haven't finished reading
1867 the process output; ignore them too. */
1868 if (CHILD_ACTIVE (cp
) && cp
->procinfo
.hProcess
1870 || (fd_info
[cp
->fd
].flags
& FILE_SEND_SIGCHLD
) == 0
1871 || (fd_info
[cp
->fd
].flags
& FILE_AT_EOF
) != 0)
1874 wait_hnd
[nh
+ nc
] = cp
->procinfo
.hProcess
;
1879 /* Nothing to look for, so we didn't find anything */
1887 start_time
= GetTickCount ();
1889 /* Wait for input or child death to be signaled. If user input is
1890 allowed, then also accept window messages. */
1891 if (FD_ISSET (0, &orfds
))
1892 active
= MsgWaitForMultipleObjects (nh
+ nc
, wait_hnd
, FALSE
, timeout_ms
,
1895 active
= WaitForMultipleObjects (nh
+ nc
, wait_hnd
, FALSE
, timeout_ms
);
1897 if (active
== WAIT_FAILED
)
1899 DebPrint (("select.WaitForMultipleObjects (%d, %lu) failed with %lu\n",
1900 nh
+ nc
, timeout_ms
, GetLastError ()));
1901 /* don't return EBADF - this causes wait_reading_process_output to
1902 abort; WAIT_FAILED is returned when single-stepping under
1903 Windows 95 after switching thread focus in debugger, and
1904 possibly at other times. */
1908 else if (active
== WAIT_TIMEOUT
)
1912 else if (active
>= WAIT_OBJECT_0
1913 && active
< WAIT_OBJECT_0
+MAXIMUM_WAIT_OBJECTS
)
1915 active
-= WAIT_OBJECT_0
;
1917 else if (active
>= WAIT_ABANDONED_0
1918 && active
< WAIT_ABANDONED_0
+MAXIMUM_WAIT_OBJECTS
)
1920 active
-= WAIT_ABANDONED_0
;
1925 /* Loop over all handles after active (now officially documented as
1926 being the first signaled handle in the array). We do this to
1927 ensure fairness, so that all channels with data available will be
1928 processed - otherwise higher numbered channels could be starved. */
1931 if (active
== nh
+ nc
)
1933 /* There are messages in the lisp thread's queue; we must
1934 drain the queue now to ensure they are processed promptly,
1935 because if we don't do so, we will not be woken again until
1936 further messages arrive.
1938 NB. If ever we allow window message procedures to callback
1939 into lisp, we will need to ensure messages are dispatched
1940 at a safe time for lisp code to be run (*), and we may also
1941 want to provide some hooks in the dispatch loop to cater
1942 for modeless dialogs created by lisp (ie. to register
1943 window handles to pass to IsDialogMessage).
1945 (*) Note that MsgWaitForMultipleObjects above is an
1946 internal dispatch point for messages that are sent to
1947 windows created by this thread. */
1948 drain_message_queue ();
1950 else if (active
>= nh
)
1952 cp
= cps
[active
- nh
];
1954 /* We cannot always signal SIGCHLD immediately; if we have not
1955 finished reading the process output, we must delay sending
1956 SIGCHLD until we do. */
1958 if (cp
->fd
>= 0 && (fd_info
[cp
->fd
].flags
& FILE_AT_EOF
) == 0)
1959 fd_info
[cp
->fd
].flags
|= FILE_SEND_SIGCHLD
;
1960 /* SIG_DFL for SIGCHLD is ignore */
1961 else if (sig_handlers
[SIGCHLD
] != SIG_DFL
&&
1962 sig_handlers
[SIGCHLD
] != SIG_IGN
)
1965 DebPrint (("select calling SIGCHLD handler for pid %d\n",
1969 sig_handlers
[SIGCHLD
] (SIGCHLD
);
1973 else if (fdindex
[active
] == -1)
1975 /* Quit (C-g) was detected. */
1979 else if (fdindex
[active
] == 0)
1981 /* Keyboard input available */
1987 /* must be a socket or pipe - read ahead should have
1988 completed, either succeeding or failing. */
1989 FD_SET (fdindex
[active
], rfds
);
1993 /* Even though wait_reading_process_output only reads from at most
1994 one channel, we must process all channels here so that we reap
1995 all children that have died. */
1996 while (++active
< nh
+ nc
)
1997 if (WaitForSingleObject (wait_hnd
[active
], 0) == WAIT_OBJECT_0
)
1999 } while (active
< nh
+ nc
);
2001 /* If no input has arrived and timeout hasn't expired, wait again. */
2004 DWORD elapsed
= GetTickCount () - start_time
;
2006 if (timeout_ms
> elapsed
) /* INFINITE is MAX_UINT */
2008 if (timeout_ms
!= INFINITE
)
2009 timeout_ms
-= elapsed
;
2010 goto count_children
;
2017 /* Substitute for certain kill () operations */
2019 static BOOL CALLBACK
2020 find_child_console (HWND hwnd
, LPARAM arg
)
2022 child_process
* cp
= (child_process
*) arg
;
2026 thread_id
= GetWindowThreadProcessId (hwnd
, &process_id
);
2027 if (process_id
== cp
->procinfo
.dwProcessId
)
2029 char window_class
[32];
2031 GetClassName (hwnd
, window_class
, sizeof (window_class
));
2032 if (strcmp (window_class
,
2033 (os_subtype
== OS_9X
)
2035 : "ConsoleWindowClass") == 0)
2045 /* Emulate 'kill', but only for other processes. */
2047 sys_kill (int pid
, int sig
)
2051 int need_to_free
= 0;
2054 /* Only handle signals that will result in the process dying */
2055 if (sig
!= SIGINT
&& sig
!= SIGKILL
&& sig
!= SIGQUIT
&& sig
!= SIGHUP
)
2061 cp
= find_child_pid (pid
);
2064 /* We were passed a PID of something other than our subprocess.
2065 If that is our own PID, we will send to ourself a message to
2066 close the selected frame, which does not necessarily
2067 terminates Emacs. But then we are not supposed to call
2068 sys_kill with our own PID. */
2069 proc_hand
= OpenProcess (PROCESS_TERMINATE
, 0, pid
);
2070 if (proc_hand
== NULL
)
2079 proc_hand
= cp
->procinfo
.hProcess
;
2080 pid
= cp
->procinfo
.dwProcessId
;
2082 /* Try to locate console window for process. */
2083 EnumWindows (find_child_console
, (LPARAM
) cp
);
2086 if (sig
== SIGINT
|| sig
== SIGQUIT
)
2088 if (NILP (Vw32_start_process_share_console
) && cp
&& cp
->hwnd
)
2090 BYTE control_scan_code
= (BYTE
) MapVirtualKey (VK_CONTROL
, 0);
2091 /* Fake Ctrl-C for SIGINT, and Ctrl-Break for SIGQUIT. */
2092 BYTE vk_break_code
= (sig
== SIGINT
) ? 'C' : VK_CANCEL
;
2093 BYTE break_scan_code
= (BYTE
) MapVirtualKey (vk_break_code
, 0);
2094 HWND foreground_window
;
2096 if (break_scan_code
== 0)
2098 /* Fake Ctrl-C for SIGQUIT if we can't manage Ctrl-Break. */
2099 vk_break_code
= 'C';
2100 break_scan_code
= (BYTE
) MapVirtualKey (vk_break_code
, 0);
2103 foreground_window
= GetForegroundWindow ();
2104 if (foreground_window
)
2106 /* NT 5.0, and apparently also Windows 98, will not allow
2107 a Window to be set to foreground directly without the
2108 user's involvement. The workaround is to attach
2109 ourselves to the thread that owns the foreground
2110 window, since that is the only thread that can set the
2111 foreground window. */
2112 DWORD foreground_thread
, child_thread
;
2114 GetWindowThreadProcessId (foreground_window
, NULL
);
2115 if (foreground_thread
== GetCurrentThreadId ()
2116 || !AttachThreadInput (GetCurrentThreadId (),
2117 foreground_thread
, TRUE
))
2118 foreground_thread
= 0;
2120 child_thread
= GetWindowThreadProcessId (cp
->hwnd
, NULL
);
2121 if (child_thread
== GetCurrentThreadId ()
2122 || !AttachThreadInput (GetCurrentThreadId (),
2123 child_thread
, TRUE
))
2126 /* Set the foreground window to the child. */
2127 if (SetForegroundWindow (cp
->hwnd
))
2129 /* Generate keystrokes as if user had typed Ctrl-Break or
2131 keybd_event (VK_CONTROL
, control_scan_code
, 0, 0);
2132 keybd_event (vk_break_code
, break_scan_code
,
2133 (vk_break_code
== 'C' ? 0 : KEYEVENTF_EXTENDEDKEY
), 0);
2134 keybd_event (vk_break_code
, break_scan_code
,
2135 (vk_break_code
== 'C' ? 0 : KEYEVENTF_EXTENDEDKEY
)
2136 | KEYEVENTF_KEYUP
, 0);
2137 keybd_event (VK_CONTROL
, control_scan_code
,
2138 KEYEVENTF_KEYUP
, 0);
2140 /* Sleep for a bit to give time for Emacs frame to respond
2141 to focus change events (if Emacs was active app). */
2144 SetForegroundWindow (foreground_window
);
2146 /* Detach from the foreground and child threads now that
2147 the foreground switching is over. */
2148 if (foreground_thread
)
2149 AttachThreadInput (GetCurrentThreadId (),
2150 foreground_thread
, FALSE
);
2152 AttachThreadInput (GetCurrentThreadId (),
2153 child_thread
, FALSE
);
2156 /* Ctrl-Break is NT equivalent of SIGINT. */
2157 else if (!GenerateConsoleCtrlEvent (CTRL_BREAK_EVENT
, pid
))
2159 DebPrint (("sys_kill.GenerateConsoleCtrlEvent return %d "
2160 "for pid %lu\n", GetLastError (), pid
));
2167 if (NILP (Vw32_start_process_share_console
) && cp
&& cp
->hwnd
)
2170 if (os_subtype
== OS_9X
)
2173 Another possibility is to try terminating the VDM out-right by
2174 calling the Shell VxD (id 0x17) V86 interface, function #4
2175 "SHELL_Destroy_VM", ie.
2181 First need to determine the current VM handle, and then arrange for
2182 the shellapi call to be made from the system vm (by using
2183 Switch_VM_and_callback).
2185 Could try to invoke DestroyVM through CallVxD.
2189 /* On Windows 95, posting WM_QUIT causes the 16-bit subsystem
2190 to hang when cmdproxy is used in conjunction with
2191 command.com for an interactive shell. Posting
2192 WM_CLOSE pops up a dialog that, when Yes is selected,
2193 does the same thing. TerminateProcess is also less
2194 than ideal in that subprocesses tend to stick around
2195 until the machine is shutdown, but at least it
2196 doesn't freeze the 16-bit subsystem. */
2197 PostMessage (cp
->hwnd
, WM_QUIT
, 0xff, 0);
2199 if (!TerminateProcess (proc_hand
, 0xff))
2201 DebPrint (("sys_kill.TerminateProcess returned %d "
2202 "for pid %lu\n", GetLastError (), pid
));
2209 PostMessage (cp
->hwnd
, WM_CLOSE
, 0, 0);
2211 /* Kill the process. On W32 this doesn't kill child processes
2212 so it doesn't work very well for shells which is why it's not
2213 used in every case. */
2214 else if (!TerminateProcess (proc_hand
, 0xff))
2216 DebPrint (("sys_kill.TerminateProcess returned %d "
2217 "for pid %lu\n", GetLastError (), pid
));
2224 CloseHandle (proc_hand
);
2229 /* The following two routines are used to manipulate stdin, stdout, and
2230 stderr of our child processes.
2232 Assuming that in, out, and err are *not* inheritable, we make them
2233 stdin, stdout, and stderr of the child as follows:
2235 - Save the parent's current standard handles.
2236 - Set the std handles to inheritable duplicates of the ones being passed in.
2237 (Note that _get_osfhandle() is an io.h procedure that retrieves the
2238 NT file handle for a crt file descriptor.)
2239 - Spawn the child, which inherits in, out, and err as stdin,
2240 stdout, and stderr. (see Spawnve)
2241 - Close the std handles passed to the child.
2242 - Reset the parent's standard handles to the saved handles.
2243 (see reset_standard_handles)
2244 We assume that the caller closes in, out, and err after calling us. */
2247 prepare_standard_handles (int in
, int out
, int err
, HANDLE handles
[3])
2250 HANDLE newstdin
, newstdout
, newstderr
;
2252 parent
= GetCurrentProcess ();
2254 handles
[0] = GetStdHandle (STD_INPUT_HANDLE
);
2255 handles
[1] = GetStdHandle (STD_OUTPUT_HANDLE
);
2256 handles
[2] = GetStdHandle (STD_ERROR_HANDLE
);
2258 /* make inheritable copies of the new handles */
2259 if (!DuplicateHandle (parent
,
2260 (HANDLE
) _get_osfhandle (in
),
2265 DUPLICATE_SAME_ACCESS
))
2266 report_file_error ("Duplicating input handle for child", Qnil
);
2268 if (!DuplicateHandle (parent
,
2269 (HANDLE
) _get_osfhandle (out
),
2274 DUPLICATE_SAME_ACCESS
))
2275 report_file_error ("Duplicating output handle for child", Qnil
);
2277 if (!DuplicateHandle (parent
,
2278 (HANDLE
) _get_osfhandle (err
),
2283 DUPLICATE_SAME_ACCESS
))
2284 report_file_error ("Duplicating error handle for child", Qnil
);
2286 /* and store them as our std handles */
2287 if (!SetStdHandle (STD_INPUT_HANDLE
, newstdin
))
2288 report_file_error ("Changing stdin handle", Qnil
);
2290 if (!SetStdHandle (STD_OUTPUT_HANDLE
, newstdout
))
2291 report_file_error ("Changing stdout handle", Qnil
);
2293 if (!SetStdHandle (STD_ERROR_HANDLE
, newstderr
))
2294 report_file_error ("Changing stderr handle", Qnil
);
2298 reset_standard_handles (int in
, int out
, int err
, HANDLE handles
[3])
2300 /* close the duplicated handles passed to the child */
2301 CloseHandle (GetStdHandle (STD_INPUT_HANDLE
));
2302 CloseHandle (GetStdHandle (STD_OUTPUT_HANDLE
));
2303 CloseHandle (GetStdHandle (STD_ERROR_HANDLE
));
2305 /* now restore parent's saved std handles */
2306 SetStdHandle (STD_INPUT_HANDLE
, handles
[0]);
2307 SetStdHandle (STD_OUTPUT_HANDLE
, handles
[1]);
2308 SetStdHandle (STD_ERROR_HANDLE
, handles
[2]);
2312 set_process_dir (char * dir
)
2317 /* To avoid problems with winsock implementations that work over dial-up
2318 connections causing or requiring a connection to exist while Emacs is
2319 running, Emacs no longer automatically loads winsock on startup if it
2320 is present. Instead, it will be loaded when open-network-stream is
2323 To allow full control over when winsock is loaded, we provide these
2324 two functions to dynamically load and unload winsock. This allows
2325 dial-up users to only be connected when they actually need to use
2329 extern HANDLE winsock_lib
;
2330 extern BOOL
term_winsock (void);
2331 extern BOOL
init_winsock (int load_now
);
2333 DEFUN ("w32-has-winsock", Fw32_has_winsock
, Sw32_has_winsock
, 0, 1, 0,
2334 doc
: /* Test for presence of the Windows socket library `winsock'.
2335 Returns non-nil if winsock support is present, nil otherwise.
2337 If the optional argument LOAD-NOW is non-nil, the winsock library is
2338 also loaded immediately if not already loaded. If winsock is loaded,
2339 the winsock local hostname is returned (since this may be different from
2340 the value of `system-name' and should supplant it), otherwise t is
2341 returned to indicate winsock support is present. */)
2342 (Lisp_Object load_now
)
2346 have_winsock
= init_winsock (!NILP (load_now
));
2349 if (winsock_lib
!= NULL
)
2351 /* Return new value for system-name. The best way to do this
2352 is to call init_system_name, saving and restoring the
2353 original value to avoid side-effects. */
2354 Lisp_Object orig_hostname
= Vsystem_name
;
2355 Lisp_Object hostname
;
2357 init_system_name ();
2358 hostname
= Vsystem_name
;
2359 Vsystem_name
= orig_hostname
;
2367 DEFUN ("w32-unload-winsock", Fw32_unload_winsock
, Sw32_unload_winsock
,
2369 doc
: /* Unload the Windows socket library `winsock' if loaded.
2370 This is provided to allow dial-up socket connections to be disconnected
2371 when no longer needed. Returns nil without unloading winsock if any
2372 socket connections still exist. */)
2375 return term_winsock () ? Qt
: Qnil
;
2379 /* Some miscellaneous functions that are Windows specific, but not GUI
2380 specific (ie. are applicable in terminal or batch mode as well). */
2382 DEFUN ("w32-short-file-name", Fw32_short_file_name
, Sw32_short_file_name
, 1, 1, 0,
2383 doc
: /* Return the short file name version (8.3) of the full path of FILENAME.
2384 If FILENAME does not exist, return nil.
2385 All path elements in FILENAME are converted to their short names. */)
2386 (Lisp_Object filename
)
2388 char shortname
[MAX_PATH
];
2390 CHECK_STRING (filename
);
2392 /* first expand it. */
2393 filename
= Fexpand_file_name (filename
, Qnil
);
2395 /* luckily, this returns the short version of each element in the path. */
2396 if (GetShortPathName (SDATA (ENCODE_FILE (filename
)), shortname
, MAX_PATH
) == 0)
2399 dostounix_filename (shortname
);
2401 return build_string (shortname
);
2405 DEFUN ("w32-long-file-name", Fw32_long_file_name
, Sw32_long_file_name
,
2407 doc
: /* Return the long file name version of the full path of FILENAME.
2408 If FILENAME does not exist, return nil.
2409 All path elements in FILENAME are converted to their long names. */)
2410 (Lisp_Object filename
)
2412 char longname
[ MAX_PATH
];
2415 CHECK_STRING (filename
);
2417 if (SBYTES (filename
) == 2
2418 && *(SDATA (filename
) + 1) == ':')
2421 /* first expand it. */
2422 filename
= Fexpand_file_name (filename
, Qnil
);
2424 if (!w32_get_long_filename (SDATA (ENCODE_FILE (filename
)), longname
, MAX_PATH
))
2427 dostounix_filename (longname
);
2429 /* If we were passed only a drive, make sure that a slash is not appended
2430 for consistency with directories. Allow for drive mapping via SUBST
2431 in case expand-file-name is ever changed to expand those. */
2432 if (drive_only
&& longname
[1] == ':' && longname
[2] == '/' && !longname
[3])
2435 return DECODE_FILE (build_string (longname
));
2438 DEFUN ("w32-set-process-priority", Fw32_set_process_priority
,
2439 Sw32_set_process_priority
, 2, 2, 0,
2440 doc
: /* Set the priority of PROCESS to PRIORITY.
2441 If PROCESS is nil, the priority of Emacs is changed, otherwise the
2442 priority of the process whose pid is PROCESS is changed.
2443 PRIORITY should be one of the symbols high, normal, or low;
2444 any other symbol will be interpreted as normal.
2446 If successful, the return value is t, otherwise nil. */)
2447 (Lisp_Object process
, Lisp_Object priority
)
2449 HANDLE proc_handle
= GetCurrentProcess ();
2450 DWORD priority_class
= NORMAL_PRIORITY_CLASS
;
2451 Lisp_Object result
= Qnil
;
2453 CHECK_SYMBOL (priority
);
2455 if (!NILP (process
))
2460 CHECK_NUMBER (process
);
2462 /* Allow pid to be an internally generated one, or one obtained
2463 externally. This is necessary because real pids on Windows 95 are
2466 pid
= XINT (process
);
2467 cp
= find_child_pid (pid
);
2469 pid
= cp
->procinfo
.dwProcessId
;
2471 proc_handle
= OpenProcess (PROCESS_SET_INFORMATION
, FALSE
, pid
);
2474 if (EQ (priority
, Qhigh
))
2475 priority_class
= HIGH_PRIORITY_CLASS
;
2476 else if (EQ (priority
, Qlow
))
2477 priority_class
= IDLE_PRIORITY_CLASS
;
2479 if (proc_handle
!= NULL
)
2481 if (SetPriorityClass (proc_handle
, priority_class
))
2483 if (!NILP (process
))
2484 CloseHandle (proc_handle
);
2490 #ifdef HAVE_LANGINFO_CODESET
2491 /* Emulation of nl_langinfo. Used in fns.c:Flocale_info. */
2493 nl_langinfo (nl_item item
)
2495 /* Conversion of Posix item numbers to their Windows equivalents. */
2496 static const LCTYPE w32item
[] = {
2497 LOCALE_IDEFAULTANSICODEPAGE
,
2498 LOCALE_SDAYNAME1
, LOCALE_SDAYNAME2
, LOCALE_SDAYNAME3
,
2499 LOCALE_SDAYNAME4
, LOCALE_SDAYNAME5
, LOCALE_SDAYNAME6
, LOCALE_SDAYNAME7
,
2500 LOCALE_SMONTHNAME1
, LOCALE_SMONTHNAME2
, LOCALE_SMONTHNAME3
,
2501 LOCALE_SMONTHNAME4
, LOCALE_SMONTHNAME5
, LOCALE_SMONTHNAME6
,
2502 LOCALE_SMONTHNAME7
, LOCALE_SMONTHNAME8
, LOCALE_SMONTHNAME9
,
2503 LOCALE_SMONTHNAME10
, LOCALE_SMONTHNAME11
, LOCALE_SMONTHNAME12
2506 static char *nl_langinfo_buf
= NULL
;
2507 static int nl_langinfo_len
= 0;
2509 if (nl_langinfo_len
<= 0)
2510 nl_langinfo_buf
= xmalloc (nl_langinfo_len
= 1);
2512 if (item
< 0 || item
>= _NL_NUM
)
2513 nl_langinfo_buf
[0] = 0;
2516 LCID cloc
= GetThreadLocale ();
2517 int need_len
= GetLocaleInfo (cloc
, w32item
[item
] | LOCALE_USE_CP_ACP
,
2521 nl_langinfo_buf
[0] = 0;
2524 if (item
== CODESET
)
2526 need_len
+= 2; /* for the "cp" prefix */
2527 if (need_len
< 8) /* for the case we call GetACP */
2530 if (nl_langinfo_len
<= need_len
)
2531 nl_langinfo_buf
= xrealloc (nl_langinfo_buf
,
2532 nl_langinfo_len
= need_len
);
2533 if (!GetLocaleInfo (cloc
, w32item
[item
] | LOCALE_USE_CP_ACP
,
2534 nl_langinfo_buf
, nl_langinfo_len
))
2535 nl_langinfo_buf
[0] = 0;
2536 else if (item
== CODESET
)
2538 if (strcmp (nl_langinfo_buf
, "0") == 0 /* CP_ACP */
2539 || strcmp (nl_langinfo_buf
, "1") == 0) /* CP_OEMCP */
2540 sprintf (nl_langinfo_buf
, "cp%u", GetACP ());
2543 memmove (nl_langinfo_buf
+ 2, nl_langinfo_buf
,
2544 strlen (nl_langinfo_buf
) + 1);
2545 nl_langinfo_buf
[0] = 'c';
2546 nl_langinfo_buf
[1] = 'p';
2551 return nl_langinfo_buf
;
2553 #endif /* HAVE_LANGINFO_CODESET */
2555 DEFUN ("w32-get-locale-info", Fw32_get_locale_info
,
2556 Sw32_get_locale_info
, 1, 2, 0,
2557 doc
: /* Return information about the Windows locale LCID.
2558 By default, return a three letter locale code which encodes the default
2559 language as the first two characters, and the country or regional variant
2560 as the third letter. For example, ENU refers to `English (United States)',
2561 while ENC means `English (Canadian)'.
2563 If the optional argument LONGFORM is t, the long form of the locale
2564 name is returned, e.g. `English (United States)' instead; if LONGFORM
2565 is a number, it is interpreted as an LCTYPE constant and the corresponding
2566 locale information is returned.
2568 If LCID (a 16-bit number) is not a valid locale, the result is nil. */)
2569 (Lisp_Object lcid
, Lisp_Object longform
)
2573 char abbrev_name
[32] = { 0 };
2574 char full_name
[256] = { 0 };
2576 CHECK_NUMBER (lcid
);
2578 if (!IsValidLocale (XINT (lcid
), LCID_SUPPORTED
))
2581 if (NILP (longform
))
2583 got_abbrev
= GetLocaleInfo (XINT (lcid
),
2584 LOCALE_SABBREVLANGNAME
| LOCALE_USE_CP_ACP
,
2585 abbrev_name
, sizeof (abbrev_name
));
2587 return build_string (abbrev_name
);
2589 else if (EQ (longform
, Qt
))
2591 got_full
= GetLocaleInfo (XINT (lcid
),
2592 LOCALE_SLANGUAGE
| LOCALE_USE_CP_ACP
,
2593 full_name
, sizeof (full_name
));
2595 return DECODE_SYSTEM (build_string (full_name
));
2597 else if (NUMBERP (longform
))
2599 got_full
= GetLocaleInfo (XINT (lcid
),
2601 full_name
, sizeof (full_name
));
2602 /* GetLocaleInfo's return value includes the terminating null
2603 character, when the returned information is a string, whereas
2604 make_unibyte_string needs the string length without the
2605 terminating null. */
2607 return make_unibyte_string (full_name
, got_full
- 1);
2614 DEFUN ("w32-get-current-locale-id", Fw32_get_current_locale_id
,
2615 Sw32_get_current_locale_id
, 0, 0, 0,
2616 doc
: /* Return Windows locale id for current locale setting.
2617 This is a numerical value; use `w32-get-locale-info' to convert to a
2618 human-readable form. */)
2621 return make_number (GetThreadLocale ());
2625 int_from_hex (char * s
)
2628 static char hex
[] = "0123456789abcdefABCDEF";
2631 while (*s
&& (p
= strchr (hex
, *s
)) != NULL
)
2633 unsigned digit
= p
- hex
;
2636 val
= val
* 16 + digit
;
2642 /* We need to build a global list, since the EnumSystemLocale callback
2643 function isn't given a context pointer. */
2644 Lisp_Object Vw32_valid_locale_ids
;
2646 static BOOL CALLBACK
2647 enum_locale_fn (LPTSTR localeNum
)
2649 DWORD id
= int_from_hex (localeNum
);
2650 Vw32_valid_locale_ids
= Fcons (make_number (id
), Vw32_valid_locale_ids
);
2654 DEFUN ("w32-get-valid-locale-ids", Fw32_get_valid_locale_ids
,
2655 Sw32_get_valid_locale_ids
, 0, 0, 0,
2656 doc
: /* Return list of all valid Windows locale ids.
2657 Each id is a numerical value; use `w32-get-locale-info' to convert to a
2658 human-readable form. */)
2661 Vw32_valid_locale_ids
= Qnil
;
2663 EnumSystemLocales (enum_locale_fn
, LCID_SUPPORTED
);
2665 Vw32_valid_locale_ids
= Fnreverse (Vw32_valid_locale_ids
);
2666 return Vw32_valid_locale_ids
;
2670 DEFUN ("w32-get-default-locale-id", Fw32_get_default_locale_id
, Sw32_get_default_locale_id
, 0, 1, 0,
2671 doc
: /* Return Windows locale id for default locale setting.
2672 By default, the system default locale setting is returned; if the optional
2673 parameter USERP is non-nil, the user default locale setting is returned.
2674 This is a numerical value; use `w32-get-locale-info' to convert to a
2675 human-readable form. */)
2679 return make_number (GetSystemDefaultLCID ());
2680 return make_number (GetUserDefaultLCID ());
2684 DEFUN ("w32-set-current-locale", Fw32_set_current_locale
, Sw32_set_current_locale
, 1, 1, 0,
2685 doc
: /* Make Windows locale LCID be the current locale setting for Emacs.
2686 If successful, the new locale id is returned, otherwise nil. */)
2689 CHECK_NUMBER (lcid
);
2691 if (!IsValidLocale (XINT (lcid
), LCID_SUPPORTED
))
2694 if (!SetThreadLocale (XINT (lcid
)))
2697 /* Need to set input thread locale if present. */
2698 if (dwWindowsThreadId
)
2699 /* Reply is not needed. */
2700 PostThreadMessage (dwWindowsThreadId
, WM_EMACS_SETLOCALE
, XINT (lcid
), 0);
2702 return make_number (GetThreadLocale ());
2706 /* We need to build a global list, since the EnumCodePages callback
2707 function isn't given a context pointer. */
2708 Lisp_Object Vw32_valid_codepages
;
2710 static BOOL CALLBACK
2711 enum_codepage_fn (LPTSTR codepageNum
)
2713 DWORD id
= atoi (codepageNum
);
2714 Vw32_valid_codepages
= Fcons (make_number (id
), Vw32_valid_codepages
);
2718 DEFUN ("w32-get-valid-codepages", Fw32_get_valid_codepages
,
2719 Sw32_get_valid_codepages
, 0, 0, 0,
2720 doc
: /* Return list of all valid Windows codepages. */)
2723 Vw32_valid_codepages
= Qnil
;
2725 EnumSystemCodePages (enum_codepage_fn
, CP_SUPPORTED
);
2727 Vw32_valid_codepages
= Fnreverse (Vw32_valid_codepages
);
2728 return Vw32_valid_codepages
;
2732 DEFUN ("w32-get-console-codepage", Fw32_get_console_codepage
,
2733 Sw32_get_console_codepage
, 0, 0, 0,
2734 doc
: /* Return current Windows codepage for console input. */)
2737 return make_number (GetConsoleCP ());
2741 DEFUN ("w32-set-console-codepage", Fw32_set_console_codepage
,
2742 Sw32_set_console_codepage
, 1, 1, 0,
2743 doc
: /* Make Windows codepage CP be the codepage for Emacs tty keyboard input.
2744 This codepage setting affects keyboard input in tty mode.
2745 If successful, the new CP is returned, otherwise nil. */)
2750 if (!IsValidCodePage (XINT (cp
)))
2753 if (!SetConsoleCP (XINT (cp
)))
2756 return make_number (GetConsoleCP ());
2760 DEFUN ("w32-get-console-output-codepage", Fw32_get_console_output_codepage
,
2761 Sw32_get_console_output_codepage
, 0, 0, 0,
2762 doc
: /* Return current Windows codepage for console output. */)
2765 return make_number (GetConsoleOutputCP ());
2769 DEFUN ("w32-set-console-output-codepage", Fw32_set_console_output_codepage
,
2770 Sw32_set_console_output_codepage
, 1, 1, 0,
2771 doc
: /* Make Windows codepage CP be the codepage for Emacs console output.
2772 This codepage setting affects display in tty mode.
2773 If successful, the new CP is returned, otherwise nil. */)
2778 if (!IsValidCodePage (XINT (cp
)))
2781 if (!SetConsoleOutputCP (XINT (cp
)))
2784 return make_number (GetConsoleOutputCP ());
2788 DEFUN ("w32-get-codepage-charset", Fw32_get_codepage_charset
,
2789 Sw32_get_codepage_charset
, 1, 1, 0,
2790 doc
: /* Return charset ID corresponding to codepage CP.
2791 Returns nil if the codepage is not valid. */)
2798 if (!IsValidCodePage (XINT (cp
)))
2801 if (TranslateCharsetInfo ((DWORD
*) XINT (cp
), &info
, TCI_SRCCODEPAGE
))
2802 return make_number (info
.ciCharset
);
2808 DEFUN ("w32-get-valid-keyboard-layouts", Fw32_get_valid_keyboard_layouts
,
2809 Sw32_get_valid_keyboard_layouts
, 0, 0, 0,
2810 doc
: /* Return list of Windows keyboard languages and layouts.
2811 The return value is a list of pairs of language id and layout id. */)
2814 int num_layouts
= GetKeyboardLayoutList (0, NULL
);
2815 HKL
* layouts
= (HKL
*) alloca (num_layouts
* sizeof (HKL
));
2816 Lisp_Object obj
= Qnil
;
2818 if (GetKeyboardLayoutList (num_layouts
, layouts
) == num_layouts
)
2820 while (--num_layouts
>= 0)
2822 DWORD kl
= (DWORD
) layouts
[num_layouts
];
2824 obj
= Fcons (Fcons (make_number (kl
& 0xffff),
2825 make_number ((kl
>> 16) & 0xffff)),
2834 DEFUN ("w32-get-keyboard-layout", Fw32_get_keyboard_layout
,
2835 Sw32_get_keyboard_layout
, 0, 0, 0,
2836 doc
: /* Return current Windows keyboard language and layout.
2837 The return value is the cons of the language id and the layout id. */)
2840 DWORD kl
= (DWORD
) GetKeyboardLayout (dwWindowsThreadId
);
2842 return Fcons (make_number (kl
& 0xffff),
2843 make_number ((kl
>> 16) & 0xffff));
2847 DEFUN ("w32-set-keyboard-layout", Fw32_set_keyboard_layout
,
2848 Sw32_set_keyboard_layout
, 1, 1, 0,
2849 doc
: /* Make LAYOUT be the current keyboard layout for Emacs.
2850 The keyboard layout setting affects interpretation of keyboard input.
2851 If successful, the new layout id is returned, otherwise nil. */)
2852 (Lisp_Object layout
)
2856 CHECK_CONS (layout
);
2857 CHECK_NUMBER_CAR (layout
);
2858 CHECK_NUMBER_CDR (layout
);
2860 kl
= (XINT (XCAR (layout
)) & 0xffff)
2861 | (XINT (XCDR (layout
)) << 16);
2863 /* Synchronize layout with input thread. */
2864 if (dwWindowsThreadId
)
2866 if (PostThreadMessage (dwWindowsThreadId
, WM_EMACS_SETKEYBOARDLAYOUT
,
2870 GetMessage (&msg
, NULL
, WM_EMACS_DONE
, WM_EMACS_DONE
);
2872 if (msg
.wParam
== 0)
2876 else if (!ActivateKeyboardLayout ((HKL
) kl
, 0))
2879 return Fw32_get_keyboard_layout ();
2884 syms_of_ntproc (void)
2886 DEFSYM (Qhigh
, "high");
2887 DEFSYM (Qlow
, "low");
2889 defsubr (&Sw32_has_winsock
);
2890 defsubr (&Sw32_unload_winsock
);
2892 defsubr (&Sw32_short_file_name
);
2893 defsubr (&Sw32_long_file_name
);
2894 defsubr (&Sw32_set_process_priority
);
2895 defsubr (&Sw32_get_locale_info
);
2896 defsubr (&Sw32_get_current_locale_id
);
2897 defsubr (&Sw32_get_default_locale_id
);
2898 defsubr (&Sw32_get_valid_locale_ids
);
2899 defsubr (&Sw32_set_current_locale
);
2901 defsubr (&Sw32_get_console_codepage
);
2902 defsubr (&Sw32_set_console_codepage
);
2903 defsubr (&Sw32_get_console_output_codepage
);
2904 defsubr (&Sw32_set_console_output_codepage
);
2905 defsubr (&Sw32_get_valid_codepages
);
2906 defsubr (&Sw32_get_codepage_charset
);
2908 defsubr (&Sw32_get_valid_keyboard_layouts
);
2909 defsubr (&Sw32_get_keyboard_layout
);
2910 defsubr (&Sw32_set_keyboard_layout
);
2912 DEFVAR_LISP ("w32-quote-process-args", Vw32_quote_process_args
,
2913 doc
: /* Non-nil enables quoting of process arguments to ensure correct parsing.
2914 Because Windows does not directly pass argv arrays to child processes,
2915 programs have to reconstruct the argv array by parsing the command
2916 line string. For an argument to contain a space, it must be enclosed
2917 in double quotes or it will be parsed as multiple arguments.
2919 If the value is a character, that character will be used to escape any
2920 quote characters that appear, otherwise a suitable escape character
2921 will be chosen based on the type of the program. */);
2922 Vw32_quote_process_args
= Qt
;
2924 DEFVAR_LISP ("w32-start-process-show-window",
2925 Vw32_start_process_show_window
,
2926 doc
: /* When nil, new child processes hide their windows.
2927 When non-nil, they show their window in the method of their choice.
2928 This variable doesn't affect GUI applications, which will never be hidden. */);
2929 Vw32_start_process_show_window
= Qnil
;
2931 DEFVAR_LISP ("w32-start-process-share-console",
2932 Vw32_start_process_share_console
,
2933 doc
: /* When nil, new child processes are given a new console.
2934 When non-nil, they share the Emacs console; this has the limitation of
2935 allowing only one DOS subprocess to run at a time (whether started directly
2936 or indirectly by Emacs), and preventing Emacs from cleanly terminating the
2937 subprocess group, but may allow Emacs to interrupt a subprocess that doesn't
2938 otherwise respond to interrupts from Emacs. */);
2939 Vw32_start_process_share_console
= Qnil
;
2941 DEFVAR_LISP ("w32-start-process-inherit-error-mode",
2942 Vw32_start_process_inherit_error_mode
,
2943 doc
: /* When nil, new child processes revert to the default error mode.
2944 When non-nil, they inherit their error mode setting from Emacs, which stops
2945 them blocking when trying to access unmounted drives etc. */);
2946 Vw32_start_process_inherit_error_mode
= Qt
;
2948 DEFVAR_INT ("w32-pipe-read-delay", w32_pipe_read_delay
,
2949 doc
: /* Forced delay before reading subprocess output.
2950 This is done to improve the buffering of subprocess output, by
2951 avoiding the inefficiency of frequently reading small amounts of data.
2953 If positive, the value is the number of milliseconds to sleep before
2954 reading the subprocess output. If negative, the magnitude is the number
2955 of time slices to wait (effectively boosting the priority of the child
2956 process temporarily). A value of zero disables waiting entirely. */);
2957 w32_pipe_read_delay
= 50;
2959 DEFVAR_LISP ("w32-downcase-file-names", Vw32_downcase_file_names
,
2960 doc
: /* Non-nil means convert all-upper case file names to lower case.
2961 This applies when performing completions and file name expansion.
2962 Note that the value of this setting also affects remote file names,
2963 so you probably don't want to set to non-nil if you use case-sensitive
2964 filesystems via ange-ftp. */);
2965 Vw32_downcase_file_names
= Qnil
;
2968 DEFVAR_LISP ("w32-generate-fake-inodes", Vw32_generate_fake_inodes
,
2969 doc
: /* Non-nil means attempt to fake realistic inode values.
2970 This works by hashing the truename of files, and should detect
2971 aliasing between long and short (8.3 DOS) names, but can have
2972 false positives because of hash collisions. Note that determining
2973 the truename of a file can be slow. */);
2974 Vw32_generate_fake_inodes
= Qnil
;
2977 DEFVAR_LISP ("w32-get-true-file-attributes", Vw32_get_true_file_attributes
,
2978 doc
: /* Non-nil means determine accurate file attributes in `file-attributes'.
2979 This option controls whether to issue additional system calls to determine
2980 accurate link counts, file type, and ownership information. It is more
2981 useful for files on NTFS volumes, where hard links and file security are
2982 supported, than on volumes of the FAT family.
2984 Without these system calls, link count will always be reported as 1 and file
2985 ownership will be attributed to the current user.
2986 The default value `local' means only issue these system calls for files
2987 on local fixed drives. A value of nil means never issue them.
2988 Any other non-nil value means do this even on remote and removable drives
2989 where the performance impact may be noticeable even on modern hardware. */);
2990 Vw32_get_true_file_attributes
= Qlocal
;
2992 staticpro (&Vw32_valid_locale_ids
);
2993 staticpro (&Vw32_valid_codepages
);
2995 /* end of w32proc.c */