1 /* Process support for GNU Emacs on the Microsoft Windows API.
2 Copyright (C) 1992, 1995, 1999-2013 Free Software Foundation, Inc.
4 This file is part of GNU Emacs.
6 GNU Emacs is free software: you can redistribute it and/or modify
7 it under the terms of the GNU General Public License as published by
8 the Free Software Foundation, either version 3 of the License, or
9 (at your option) any later version.
11 GNU Emacs is distributed in the hope that it will be useful,
12 but WITHOUT ANY WARRANTY; without even the implied warranty of
13 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14 GNU General Public License for more details.
16 You should have received a copy of the GNU General Public License
17 along with GNU Emacs. If not, see <http://www.gnu.org/licenses/>. */
20 Drew Bliss Oct 14, 1993
21 Adapted from alarm.c by Tim Fleehart
33 /* must include CRT headers *before* config.h */
44 /* This definition is missing from mingw32 headers. */
45 extern BOOL WINAPI
IsValidLocale (LCID
, DWORD
);
48 #ifdef HAVE_LANGINFO_CODESET
55 #include "w32common.h"
60 #include "syssignal.h"
62 #include "dispextern.h" /* for xstrcasecmp */
65 #define RVA_TO_PTR(var,section,filedata) \
66 ((void *)((section)->PointerToRawData \
67 + ((DWORD_PTR)(var) - (section)->VirtualAddress) \
68 + (filedata).file_base))
70 Lisp_Object Qhigh
, Qlow
;
72 /* Signal handlers...SIG_DFL == 0 so this is initialized correctly. */
73 static signal_handler sig_handlers
[NSIG
];
75 static sigset_t sig_mask
;
77 static CRITICAL_SECTION crit_sig
;
79 /* Improve on the CRT 'signal' implementation so that we could record
80 the SIGCHLD handler and fake interval timers. */
82 sys_signal (int sig
, signal_handler handler
)
86 /* SIGCHLD is needed for supporting subprocesses, see sys_kill
87 below. SIGALRM and SIGPROF are used by setitimer. All the
88 others are the only ones supported by the MS runtime. */
89 if (!(sig
== SIGCHLD
|| sig
== SIGSEGV
|| sig
== SIGILL
90 || sig
== SIGFPE
|| sig
== SIGABRT
|| sig
== SIGTERM
91 || sig
== SIGALRM
|| sig
== SIGPROF
))
96 old
= sig_handlers
[sig
];
97 /* SIGABRT is treated specially because w32.c installs term_ntproc
98 as its handler, so we don't want to override that afterwards.
99 Aborting Emacs works specially anyway: either by calling
100 emacs_abort directly or through terminate_due_to_signal, which
101 calls emacs_abort through emacs_raise. */
102 if (!(sig
== SIGABRT
&& old
== term_ntproc
))
104 sig_handlers
[sig
] = handler
;
105 if (!(sig
== SIGCHLD
|| sig
== SIGALRM
|| sig
== SIGPROF
))
106 signal (sig
, handler
);
111 /* Emulate sigaction. */
113 sigaction (int sig
, const struct sigaction
*act
, struct sigaction
*oact
)
115 signal_handler old
= SIG_DFL
;
119 old
= sys_signal (sig
, act
->sa_handler
);
121 old
= sig_handlers
[sig
];
130 oact
->sa_handler
= old
;
132 oact
->sa_mask
= empty_mask
;
137 /* Emulate signal sets and blocking of signals used by timers. */
140 sigemptyset (sigset_t
*set
)
147 sigaddset (sigset_t
*set
, int signo
)
154 if (signo
< 0 || signo
>= NSIG
)
160 *set
|= (1U << signo
);
166 sigfillset (sigset_t
*set
)
179 sigprocmask (int how
, const sigset_t
*set
, sigset_t
*oset
)
181 if (!(how
== SIG_BLOCK
|| how
== SIG_UNBLOCK
|| how
== SIG_SETMASK
))
202 /* FIXME: Catch signals that are blocked and reissue them when
203 they are unblocked. Important for SIGALRM and SIGPROF only. */
212 pthread_sigmask (int how
, const sigset_t
*set
, sigset_t
*oset
)
214 if (sigprocmask (how
, set
, oset
) == -1)
220 sigismember (const sigset_t
*set
, int signo
)
222 if (signo
< 0 || signo
>= NSIG
)
227 if (signo
> sizeof (*set
) * BITS_PER_CHAR
)
230 return (*set
& (1U << signo
)) != 0;
246 setpgid (pid_t pid
, pid_t pgid
)
257 /* Emulations of interval timers.
259 Limitations: only ITIMER_REAL and ITIMER_PROF are supported.
261 Implementation: a separate thread is started for each timer type,
262 the thread calls the appropriate signal handler when the timer
263 expires, after stopping the thread which installed the timer. */
266 volatile ULONGLONG expire
;
267 volatile ULONGLONG reload
;
268 volatile int terminate
;
270 HANDLE caller_thread
;
274 static ULONGLONG ticks_now
;
275 static struct itimer_data real_itimer
, prof_itimer
;
276 static ULONGLONG clocks_min
;
277 /* If non-zero, itimers are disabled. Used during shutdown, when we
278 delete the critical sections used by the timer threads. */
279 static int disable_itimers
;
281 static CRITICAL_SECTION crit_real
, crit_prof
;
283 /* GetThreadTimes is not available on Windows 9X and possibly also on 2K. */
284 typedef BOOL (WINAPI
*GetThreadTimes_Proc
) (
286 LPFILETIME lpCreationTime
,
287 LPFILETIME lpExitTime
,
288 LPFILETIME lpKernelTime
,
289 LPFILETIME lpUserTime
);
291 static GetThreadTimes_Proc s_pfn_Get_Thread_Times
;
293 #define MAX_SINGLE_SLEEP 30
294 #define TIMER_TICKS_PER_SEC 1000
296 /* Return a suitable time value, in 1-ms units, for THREAD, a handle
297 to a thread. If THREAD is NULL or an invalid handle, return the
298 current wall-clock time since January 1, 1601 (UTC). Otherwise,
299 return the sum of kernel and user times used by THREAD since it was
300 created, plus its creation time. */
302 w32_get_timer_time (HANDLE thread
)
305 int use_system_time
= 1;
306 /* The functions below return times in 100-ns units. */
307 const int tscale
= 10 * TIMER_TICKS_PER_SEC
;
309 if (thread
&& thread
!= INVALID_HANDLE_VALUE
310 && s_pfn_Get_Thread_Times
!= NULL
)
312 FILETIME creation_ftime
, exit_ftime
, kernel_ftime
, user_ftime
;
313 ULARGE_INTEGER temp_creation
, temp_kernel
, temp_user
;
315 if (s_pfn_Get_Thread_Times (thread
, &creation_ftime
, &exit_ftime
,
316 &kernel_ftime
, &user_ftime
))
319 temp_creation
.LowPart
= creation_ftime
.dwLowDateTime
;
320 temp_creation
.HighPart
= creation_ftime
.dwHighDateTime
;
321 temp_kernel
.LowPart
= kernel_ftime
.dwLowDateTime
;
322 temp_kernel
.HighPart
= kernel_ftime
.dwHighDateTime
;
323 temp_user
.LowPart
= user_ftime
.dwLowDateTime
;
324 temp_user
.HighPart
= user_ftime
.dwHighDateTime
;
326 temp_creation
.QuadPart
/ tscale
+ temp_kernel
.QuadPart
/ tscale
327 + temp_user
.QuadPart
/ tscale
;
330 DebPrint (("GetThreadTimes failed with error code %lu\n",
336 FILETIME current_ftime
;
339 GetSystemTimeAsFileTime (¤t_ftime
);
341 temp
.LowPart
= current_ftime
.dwLowDateTime
;
342 temp
.HighPart
= current_ftime
.dwHighDateTime
;
344 retval
= temp
.QuadPart
/ tscale
;
350 /* Thread function for a timer thread. */
352 timer_loop (LPVOID arg
)
354 struct itimer_data
*itimer
= (struct itimer_data
*)arg
;
355 int which
= itimer
->type
;
356 int sig
= (which
== ITIMER_REAL
) ? SIGALRM
: SIGPROF
;
357 CRITICAL_SECTION
*crit
= (which
== ITIMER_REAL
) ? &crit_real
: &crit_prof
;
358 const DWORD max_sleep
= MAX_SINGLE_SLEEP
* 1000 / TIMER_TICKS_PER_SEC
;
359 HANDLE hth
= (which
== ITIMER_REAL
) ? NULL
: itimer
->caller_thread
;
364 signal_handler handler
;
365 ULONGLONG now
, expire
, reload
;
367 /* Load new values if requested by setitimer. */
368 EnterCriticalSection (crit
);
369 expire
= itimer
->expire
;
370 reload
= itimer
->reload
;
371 LeaveCriticalSection (crit
);
372 if (itimer
->terminate
)
382 if (expire
> (now
= w32_get_timer_time (hth
)))
383 sleep_time
= expire
- now
;
386 /* Don't sleep too long at a time, to be able to see the
387 termination flag without too long a delay. */
388 while (sleep_time
> max_sleep
)
390 if (itimer
->terminate
)
393 EnterCriticalSection (crit
);
394 expire
= itimer
->expire
;
395 LeaveCriticalSection (crit
);
397 (expire
> (now
= w32_get_timer_time (hth
))) ? expire
- now
: 0;
399 if (itimer
->terminate
)
403 Sleep (sleep_time
* 1000 / TIMER_TICKS_PER_SEC
);
404 /* Always sleep past the expiration time, to make sure we
405 never call the handler _before_ the expiration time,
406 always slightly after it. Sleep(5) makes sure we don't
407 hog the CPU by calling 'w32_get_timer_time' with high
408 frequency, and also let other threads work. */
409 while (w32_get_timer_time (hth
) < expire
)
413 EnterCriticalSection (crit
);
414 expire
= itimer
->expire
;
415 LeaveCriticalSection (crit
);
420 handler
= sig_handlers
[sig
];
421 if (!(handler
== SIG_DFL
|| handler
== SIG_IGN
|| handler
== SIG_ERR
)
422 /* FIXME: Don't ignore masked signals. Instead, record that
423 they happened and reissue them when the signal is
425 && !sigismember (&sig_mask
, sig
)
426 /* Simulate masking of SIGALRM and SIGPROF when processing
428 && !fatal_error_in_progress
429 && itimer
->caller_thread
)
431 /* Simulate a signal delivered to the thread which installed
432 the timer, by suspending that thread while the handler
434 HANDLE th
= itimer
->caller_thread
;
435 DWORD result
= SuspendThread (th
);
437 if (result
== (DWORD
)-1)
444 /* Update expiration time and loop. */
445 EnterCriticalSection (crit
);
446 expire
= itimer
->expire
;
449 LeaveCriticalSection (crit
);
452 reload
= itimer
->reload
;
455 now
= w32_get_timer_time (hth
);
458 ULONGLONG lag
= now
- expire
;
460 /* If we missed some opportunities (presumably while
461 sleeping or while the signal handler ran), skip
464 expire
= now
- (lag
% reload
);
470 expire
= 0; /* become idle */
471 itimer
->expire
= expire
;
472 LeaveCriticalSection (crit
);
478 stop_timer_thread (int which
)
480 struct itimer_data
*itimer
=
481 (which
== ITIMER_REAL
) ? &real_itimer
: &prof_itimer
;
483 DWORD err
, exit_code
= 255;
486 /* Signal the thread that it should terminate. */
487 itimer
->terminate
= 1;
489 if (itimer
->timer_thread
== NULL
)
492 /* Wait for the timer thread to terminate voluntarily, then kill it
493 if it doesn't. This loop waits twice more than the maximum
494 amount of time a timer thread sleeps, see above. */
495 for (i
= 0; i
< MAX_SINGLE_SLEEP
/ 5; i
++)
497 if (!((status
= GetExitCodeThread (itimer
->timer_thread
, &exit_code
))
498 && exit_code
== STILL_ACTIVE
))
502 if ((status
== FALSE
&& (err
= GetLastError ()) == ERROR_INVALID_HANDLE
)
503 || exit_code
== STILL_ACTIVE
)
505 if (!(status
== FALSE
&& err
== ERROR_INVALID_HANDLE
))
506 TerminateThread (itimer
->timer_thread
, 0);
510 CloseHandle (itimer
->timer_thread
);
511 itimer
->timer_thread
= NULL
;
512 if (itimer
->caller_thread
)
514 CloseHandle (itimer
->caller_thread
);
515 itimer
->caller_thread
= NULL
;
519 /* This is called at shutdown time from term_ntproc. */
523 if (real_itimer
.timer_thread
)
524 stop_timer_thread (ITIMER_REAL
);
525 if (prof_itimer
.timer_thread
)
526 stop_timer_thread (ITIMER_PROF
);
528 /* We are going to delete the critical sections, so timers cannot
532 DeleteCriticalSection (&crit_real
);
533 DeleteCriticalSection (&crit_prof
);
534 DeleteCriticalSection (&crit_sig
);
537 /* This is called at initialization time from init_ntproc. */
541 /* GetThreadTimes is not available on all versions of Windows, so
542 need to probe for its availability dynamically, and call it
543 through a pointer. */
544 s_pfn_Get_Thread_Times
= NULL
; /* in case dumped Emacs comes with a value */
545 if (os_subtype
!= OS_9X
)
546 s_pfn_Get_Thread_Times
=
547 (GetThreadTimes_Proc
)GetProcAddress (GetModuleHandle ("kernel32.dll"),
550 /* Make sure we start with zeroed out itimer structures, since
551 dumping may have left there traces of threads long dead. */
552 memset (&real_itimer
, 0, sizeof real_itimer
);
553 memset (&prof_itimer
, 0, sizeof prof_itimer
);
555 InitializeCriticalSection (&crit_real
);
556 InitializeCriticalSection (&crit_prof
);
557 InitializeCriticalSection (&crit_sig
);
563 start_timer_thread (int which
)
567 struct itimer_data
*itimer
=
568 (which
== ITIMER_REAL
) ? &real_itimer
: &prof_itimer
;
570 if (itimer
->timer_thread
571 && GetExitCodeThread (itimer
->timer_thread
, &exit_code
)
572 && exit_code
== STILL_ACTIVE
)
575 /* Clean up after possibly exited thread. */
576 if (itimer
->timer_thread
)
578 CloseHandle (itimer
->timer_thread
);
579 itimer
->timer_thread
= NULL
;
581 if (itimer
->caller_thread
)
583 CloseHandle (itimer
->caller_thread
);
584 itimer
->caller_thread
= NULL
;
587 /* Start a new thread. */
588 if (!DuplicateHandle (GetCurrentProcess (), GetCurrentThread (),
589 GetCurrentProcess (), &th
, 0, FALSE
,
590 DUPLICATE_SAME_ACCESS
))
595 itimer
->terminate
= 0;
596 itimer
->type
= which
;
597 itimer
->caller_thread
= th
;
598 /* Request that no more than 64KB of stack be reserved for this
599 thread, to avoid reserving too much memory, which would get in
600 the way of threads we start to wait for subprocesses. See also
602 itimer
->timer_thread
= CreateThread (NULL
, 64 * 1024, timer_loop
,
603 (void *)itimer
, 0x00010000, NULL
);
605 if (!itimer
->timer_thread
)
607 CloseHandle (itimer
->caller_thread
);
608 itimer
->caller_thread
= NULL
;
613 /* This is needed to make sure that the timer thread running for
614 profiling gets CPU as soon as the Sleep call terminates. */
615 if (which
== ITIMER_PROF
)
616 SetThreadPriority (itimer
->timer_thread
, THREAD_PRIORITY_TIME_CRITICAL
);
621 /* Most of the code of getitimer and setitimer (but not of their
622 subroutines) was shamelessly stolen from itimer.c in the DJGPP
623 library, see www.delorie.com/djgpp. */
625 getitimer (int which
, struct itimerval
*value
)
627 volatile ULONGLONG
*t_expire
;
628 volatile ULONGLONG
*t_reload
;
629 ULONGLONG expire
, reload
;
631 CRITICAL_SECTION
*crit
;
632 struct itimer_data
*itimer
;
643 if (which
!= ITIMER_REAL
&& which
!= ITIMER_PROF
)
649 itimer
= (which
== ITIMER_REAL
) ? &real_itimer
: &prof_itimer
;
651 ticks_now
= w32_get_timer_time ((which
== ITIMER_REAL
)
653 : GetCurrentThread ());
655 t_expire
= &itimer
->expire
;
656 t_reload
= &itimer
->reload
;
657 crit
= (which
== ITIMER_REAL
) ? &crit_real
: &crit_prof
;
659 EnterCriticalSection (crit
);
662 LeaveCriticalSection (crit
);
667 value
->it_value
.tv_sec
= expire
/ TIMER_TICKS_PER_SEC
;
669 (expire
% TIMER_TICKS_PER_SEC
) * (__int64
)1000000 / TIMER_TICKS_PER_SEC
;
670 value
->it_value
.tv_usec
= usecs
;
671 value
->it_interval
.tv_sec
= reload
/ TIMER_TICKS_PER_SEC
;
673 (reload
% TIMER_TICKS_PER_SEC
) * (__int64
)1000000 / TIMER_TICKS_PER_SEC
;
674 value
->it_interval
.tv_usec
= usecs
;
680 setitimer(int which
, struct itimerval
*value
, struct itimerval
*ovalue
)
682 volatile ULONGLONG
*t_expire
, *t_reload
;
683 ULONGLONG expire
, reload
, expire_old
, reload_old
;
685 CRITICAL_SECTION
*crit
;
686 struct itimerval tem
, *ptem
;
691 /* Posix systems expect timer values smaller than the resolution of
692 the system clock be rounded up to the clock resolution. First
693 time we are called, measure the clock tick resolution. */
698 for (t1
= w32_get_timer_time (NULL
);
699 (t2
= w32_get_timer_time (NULL
)) == t1
; )
701 clocks_min
= t2
- t1
;
709 if (getitimer (which
, ptem
)) /* also sets ticks_now */
710 return -1; /* errno already set */
713 (which
== ITIMER_REAL
) ? &real_itimer
.expire
: &prof_itimer
.expire
;
715 (which
== ITIMER_REAL
) ? &real_itimer
.reload
: &prof_itimer
.reload
;
717 crit
= (which
== ITIMER_REAL
) ? &crit_real
: &crit_prof
;
720 || (value
->it_value
.tv_sec
== 0 && value
->it_value
.tv_usec
== 0))
722 EnterCriticalSection (crit
);
723 /* Disable the timer. */
726 LeaveCriticalSection (crit
);
730 reload
= value
->it_interval
.tv_sec
* TIMER_TICKS_PER_SEC
;
732 usecs
= value
->it_interval
.tv_usec
;
733 if (value
->it_interval
.tv_sec
== 0
734 && usecs
&& usecs
* TIMER_TICKS_PER_SEC
< clocks_min
* 1000000)
738 usecs
*= TIMER_TICKS_PER_SEC
;
739 reload
+= usecs
/ 1000000;
742 expire
= value
->it_value
.tv_sec
* TIMER_TICKS_PER_SEC
;
743 usecs
= value
->it_value
.tv_usec
;
744 if (value
->it_value
.tv_sec
== 0
745 && usecs
* TIMER_TICKS_PER_SEC
< clocks_min
* 1000000)
749 usecs
*= TIMER_TICKS_PER_SEC
;
750 expire
+= usecs
/ 1000000;
755 EnterCriticalSection (crit
);
756 expire_old
= *t_expire
;
757 reload_old
= *t_reload
;
758 if (!(expire
== expire_old
&& reload
== reload_old
))
763 LeaveCriticalSection (crit
);
765 return start_timer_thread (which
);
771 #ifdef HAVE_SETITIMER
772 struct itimerval new_values
, old_values
;
774 new_values
.it_value
.tv_sec
= seconds
;
775 new_values
.it_value
.tv_usec
= 0;
776 new_values
.it_interval
.tv_sec
= new_values
.it_interval
.tv_usec
= 0;
778 if (setitimer (ITIMER_REAL
, &new_values
, &old_values
) < 0)
780 return old_values
.it_value
.tv_sec
;
786 /* Defined in <process.h> which conflicts with the local copy */
789 /* Child process management list. */
790 int child_proc_count
= 0;
791 child_process child_procs
[ MAX_CHILDREN
];
793 static DWORD WINAPI
reader_thread (void *arg
);
795 /* Find an unused process slot. */
802 for (cp
= child_procs
+ (child_proc_count
-1); cp
>= child_procs
; cp
--)
803 if (!CHILD_ACTIVE (cp
) && cp
->procinfo
.hProcess
== NULL
)
805 if (child_proc_count
== MAX_CHILDREN
)
808 child_process
*dead_cp
= NULL
;
810 DebPrint (("new_child: No vacant slots, looking for dead processes\n"));
811 for (cp
= child_procs
+ (child_proc_count
-1); cp
>= child_procs
; cp
--)
812 if (!CHILD_ACTIVE (cp
) && cp
->procinfo
.hProcess
)
816 if (!GetExitCodeProcess (cp
->procinfo
.hProcess
, &status
))
818 DebPrint (("new_child.GetExitCodeProcess: error %lu for PID %lu\n",
819 GetLastError (), cp
->procinfo
.dwProcessId
));
820 status
= STILL_ACTIVE
;
822 if (status
!= STILL_ACTIVE
823 || WaitForSingleObject (cp
->procinfo
.hProcess
, 0) == WAIT_OBJECT_0
)
825 DebPrint (("new_child: Freeing slot of dead process %d, fd %d\n",
826 cp
->procinfo
.dwProcessId
, cp
->fd
));
827 CloseHandle (cp
->procinfo
.hProcess
);
828 cp
->procinfo
.hProcess
= NULL
;
829 CloseHandle (cp
->procinfo
.hThread
);
830 cp
->procinfo
.hThread
= NULL
;
831 /* Free up to 2 dead slots at a time, so that if we
832 have a lot of them, they will eventually all be
833 freed when the tornado ends. */
847 if (child_proc_count
== MAX_CHILDREN
)
849 cp
= &child_procs
[child_proc_count
++];
852 /* Last opportunity to avoid leaking handles before we forget them
854 if (cp
->procinfo
.hProcess
)
855 CloseHandle (cp
->procinfo
.hProcess
);
856 if (cp
->procinfo
.hThread
)
857 CloseHandle (cp
->procinfo
.hThread
);
858 memset (cp
, 0, sizeof (*cp
));
861 cp
->procinfo
.hProcess
= NULL
;
862 cp
->status
= STATUS_READ_ERROR
;
863 cp
->input_file
= NULL
;
864 cp
->pending_deletion
= 0;
866 /* use manual reset event so that select() will function properly */
867 cp
->char_avail
= CreateEvent (NULL
, TRUE
, FALSE
, NULL
);
870 cp
->char_consumed
= CreateEvent (NULL
, FALSE
, FALSE
, NULL
);
871 if (cp
->char_consumed
)
873 /* The 0x00010000 flag is STACK_SIZE_PARAM_IS_A_RESERVATION.
874 It means that the 64K stack we are requesting in the 2nd
875 argument is how much memory should be reserved for the
876 stack. If we don't use this flag, the memory requested
877 by the 2nd argument is the amount actually _committed_,
878 but Windows reserves 8MB of memory for each thread's
879 stack. (The 8MB figure comes from the -stack
880 command-line argument we pass to the linker when building
881 Emacs, but that's because we need a large stack for
882 Emacs's main thread.) Since we request 2GB of reserved
883 memory at startup (see w32heap.c), which is close to the
884 maximum memory available for a 32-bit process on Windows,
885 the 8MB reservation for each thread causes failures in
886 starting subprocesses, because we create a thread running
887 reader_thread for each subprocess. As 8MB of stack is
888 way too much for reader_thread, forcing Windows to
889 reserve less wins the day. */
890 cp
->thrd
= CreateThread (NULL
, 64 * 1024, reader_thread
, cp
,
901 delete_child (child_process
*cp
)
905 /* Should not be deleting a child that is still needed. */
906 for (i
= 0; i
< MAXDESC
; i
++)
907 if (fd_info
[i
].cp
== cp
)
910 if (!CHILD_ACTIVE (cp
) && cp
->procinfo
.hProcess
== NULL
)
913 /* Delete the child's temporary input file, if any, that is pending
917 if (cp
->pending_deletion
)
919 if (unlink (cp
->input_file
))
920 DebPrint (("delete_child.unlink (%s) failed, errno: %d\n",
921 cp
->input_file
, errno
));
922 cp
->pending_deletion
= 0;
924 xfree (cp
->input_file
);
925 cp
->input_file
= NULL
;
928 /* reap thread if necessary */
933 if (GetExitCodeThread (cp
->thrd
, &rc
) && rc
== STILL_ACTIVE
)
935 /* let the thread exit cleanly if possible */
936 cp
->status
= STATUS_READ_ERROR
;
937 SetEvent (cp
->char_consumed
);
939 /* We used to forcibly terminate the thread here, but it
940 is normally unnecessary, and in abnormal cases, the worst that
941 will happen is we have an extra idle thread hanging around
942 waiting for the zombie process. */
943 if (WaitForSingleObject (cp
->thrd
, 1000) != WAIT_OBJECT_0
)
945 DebPrint (("delete_child.WaitForSingleObject (thread) failed "
946 "with %lu for fd %ld\n", GetLastError (), cp
->fd
));
947 TerminateThread (cp
->thrd
, 0);
951 CloseHandle (cp
->thrd
);
956 CloseHandle (cp
->char_avail
);
957 cp
->char_avail
= NULL
;
959 if (cp
->char_consumed
)
961 CloseHandle (cp
->char_consumed
);
962 cp
->char_consumed
= NULL
;
965 /* update child_proc_count (highest numbered slot in use plus one) */
966 if (cp
== child_procs
+ child_proc_count
- 1)
968 for (i
= child_proc_count
-1; i
>= 0; i
--)
969 if (CHILD_ACTIVE (&child_procs
[i
])
970 || child_procs
[i
].procinfo
.hProcess
!= NULL
)
972 child_proc_count
= i
+ 1;
977 child_proc_count
= 0;
980 /* Find a child by pid. */
981 static child_process
*
982 find_child_pid (DWORD pid
)
986 for (cp
= child_procs
+ (child_proc_count
-1); cp
>= child_procs
; cp
--)
987 if ((CHILD_ACTIVE (cp
) || cp
->procinfo
.hProcess
!= NULL
)
994 /* Thread proc for child process and socket reader threads. Each thread
995 is normally blocked until woken by select() to check for input by
996 reading one char. When the read completes, char_avail is signaled
997 to wake up the select emulator and the thread blocks itself again. */
999 reader_thread (void *arg
)
1004 cp
= (child_process
*)arg
;
1006 /* We have to wait for the go-ahead before we can start */
1008 || WaitForSingleObject (cp
->char_consumed
, INFINITE
) != WAIT_OBJECT_0
1016 if (cp
->fd
>= 0 && fd_info
[cp
->fd
].flags
& FILE_LISTEN
)
1017 rc
= _sys_wait_accept (cp
->fd
);
1019 rc
= _sys_read_ahead (cp
->fd
);
1021 /* Don't bother waiting for the event if we already have been
1022 told to exit by delete_child. */
1023 if (cp
->status
== STATUS_READ_ERROR
|| !cp
->char_avail
)
1026 /* The name char_avail is a misnomer - it really just means the
1027 read-ahead has completed, whether successfully or not. */
1028 if (!SetEvent (cp
->char_avail
))
1030 DebPrint (("reader_thread.SetEvent(0x%x) failed with %lu for fd %ld (PID %d)\n",
1031 (DWORD_PTR
)cp
->char_avail
, GetLastError (),
1036 if (rc
== STATUS_READ_ERROR
)
1039 /* If the read died, the child has died so let the thread die */
1040 if (rc
== STATUS_READ_FAILED
)
1043 /* Don't bother waiting for the acknowledge if we already have
1044 been told to exit by delete_child. */
1045 if (cp
->status
== STATUS_READ_ERROR
|| !cp
->char_consumed
)
1048 /* Wait until our input is acknowledged before reading again */
1049 if (WaitForSingleObject (cp
->char_consumed
, INFINITE
) != WAIT_OBJECT_0
)
1051 DebPrint (("reader_thread.WaitForSingleObject failed with "
1052 "%lu for fd %ld\n", GetLastError (), cp
->fd
));
1055 /* delete_child sets status to STATUS_READ_ERROR when it wants
1057 if (cp
->status
== STATUS_READ_ERROR
)
1063 /* To avoid Emacs changing directory, we just record here the directory
1064 the new process should start in. This is set just before calling
1065 sys_spawnve, and is not generally valid at any other time. */
1066 static char * process_dir
;
1069 create_child (char *exe
, char *cmdline
, char *env
, int is_gui_app
,
1070 int * pPid
, child_process
*cp
)
1073 SECURITY_ATTRIBUTES sec_attrs
;
1075 SECURITY_DESCRIPTOR sec_desc
;
1078 char dir
[ MAXPATHLEN
];
1080 if (cp
== NULL
) emacs_abort ();
1082 memset (&start
, 0, sizeof (start
));
1083 start
.cb
= sizeof (start
);
1086 if (NILP (Vw32_start_process_show_window
) && !is_gui_app
)
1087 start
.dwFlags
= STARTF_USESTDHANDLES
| STARTF_USESHOWWINDOW
;
1089 start
.dwFlags
= STARTF_USESTDHANDLES
;
1090 start
.wShowWindow
= SW_HIDE
;
1092 start
.hStdInput
= GetStdHandle (STD_INPUT_HANDLE
);
1093 start
.hStdOutput
= GetStdHandle (STD_OUTPUT_HANDLE
);
1094 start
.hStdError
= GetStdHandle (STD_ERROR_HANDLE
);
1095 #endif /* HAVE_NTGUI */
1098 /* Explicitly specify no security */
1099 if (!InitializeSecurityDescriptor (&sec_desc
, SECURITY_DESCRIPTOR_REVISION
))
1101 if (!SetSecurityDescriptorDacl (&sec_desc
, TRUE
, NULL
, FALSE
))
1104 sec_attrs
.nLength
= sizeof (sec_attrs
);
1105 sec_attrs
.lpSecurityDescriptor
= NULL
/* &sec_desc */;
1106 sec_attrs
.bInheritHandle
= FALSE
;
1108 strcpy (dir
, process_dir
);
1109 unixtodos_filename (dir
);
1111 flags
= (!NILP (Vw32_start_process_share_console
)
1112 ? CREATE_NEW_PROCESS_GROUP
1113 : CREATE_NEW_CONSOLE
);
1114 if (NILP (Vw32_start_process_inherit_error_mode
))
1115 flags
|= CREATE_DEFAULT_ERROR_MODE
;
1116 if (!CreateProcess (exe
, cmdline
, &sec_attrs
, NULL
, TRUE
,
1117 flags
, env
, dir
, &start
, &cp
->procinfo
))
1120 cp
->pid
= (int) cp
->procinfo
.dwProcessId
;
1122 /* Hack for Windows 95, which assigns large (ie negative) pids */
1131 DebPrint (("create_child.CreateProcess failed: %ld\n", GetLastError ()););
1135 /* create_child doesn't know what emacs' file handle will be for waiting
1136 on output from the child, so we need to make this additional call
1137 to register the handle with the process
1138 This way the select emulator knows how to match file handles with
1139 entries in child_procs. */
1141 register_child (pid_t pid
, int fd
)
1145 cp
= find_child_pid ((DWORD
)pid
);
1148 DebPrint (("register_child unable to find pid %lu\n", pid
));
1153 DebPrint (("register_child registered fd %d with pid %lu\n", fd
, pid
));
1158 /* thread is initially blocked until select is called; set status so
1159 that select will release thread */
1160 cp
->status
= STATUS_READ_ACKNOWLEDGED
;
1162 /* attach child_process to fd_info */
1163 if (fd_info
[fd
].cp
!= NULL
)
1165 DebPrint (("register_child: fd_info[%d] apparently in use!\n", fd
));
1169 fd_info
[fd
].cp
= cp
;
1172 /* Record INFILE as an input file for process PID. */
1174 record_infile (pid_t pid
, char *infile
)
1178 /* INFILE should never be NULL, since xstrdup would have signaled
1179 memory full condition in that case, see callproc.c where this
1180 function is called. */
1183 cp
= find_child_pid ((DWORD
)pid
);
1186 DebPrint (("record_infile is unable to find pid %lu\n", pid
));
1190 cp
->input_file
= infile
;
1193 /* Mark the input file INFILE of the corresponding subprocess as
1194 temporary, to be deleted when the subprocess exits. */
1196 record_pending_deletion (char *infile
)
1202 for (cp
= child_procs
+ (child_proc_count
-1); cp
>= child_procs
; cp
--)
1203 if (CHILD_ACTIVE (cp
)
1204 && cp
->input_file
&& xstrcasecmp (cp
->input_file
, infile
) == 0)
1206 cp
->pending_deletion
= 1;
1211 /* Called from waitpid when a process exits. */
1213 reap_subprocess (child_process
*cp
)
1215 if (cp
->procinfo
.hProcess
)
1217 /* Reap the process */
1219 /* Process should have already died before we are called. */
1220 if (WaitForSingleObject (cp
->procinfo
.hProcess
, 0) != WAIT_OBJECT_0
)
1221 DebPrint (("reap_subprocess: child for fd %d has not died yet!", cp
->fd
));
1223 CloseHandle (cp
->procinfo
.hProcess
);
1224 cp
->procinfo
.hProcess
= NULL
;
1225 CloseHandle (cp
->procinfo
.hThread
);
1226 cp
->procinfo
.hThread
= NULL
;
1229 /* If cp->fd was not closed yet, we might be still reading the
1230 process output, so don't free its resources just yet. The call
1231 to delete_child on behalf of this subprocess will be made by
1232 sys_read when the subprocess output is fully read. */
1237 /* Wait for a child process specified by PID, or for any of our
1238 existing child processes (if PID is nonpositive) to die. When it
1239 does, close its handle. Return the pid of the process that died
1240 and fill in STATUS if non-NULL. */
1243 waitpid (pid_t pid
, int *status
, int options
)
1245 DWORD active
, retval
;
1247 child_process
*cp
, *cps
[MAX_CHILDREN
];
1248 HANDLE wait_hnd
[MAX_CHILDREN
];
1250 int dont_wait
= (options
& WNOHANG
) != 0;
1253 /* According to Posix:
1255 PID = -1 means status is requested for any child process.
1257 PID > 0 means status is requested for a single child process
1260 PID = 0 means status is requested for any child process whose
1261 process group ID is equal to that of the calling process. But
1262 since Windows has only a limited support for process groups (only
1263 for console processes and only for the purposes of passing
1264 Ctrl-BREAK signal to them), and since we have no documented way
1265 of determining whether a given process belongs to our group, we
1268 PID < -1 means status is requested for any child process whose
1269 process group ID is equal to the absolute value of PID. Again,
1270 since we don't support process groups, we treat that as -1. */
1275 /* We are requested to wait for a specific child. */
1276 for (cp
= child_procs
+ (child_proc_count
-1); cp
>= child_procs
; cp
--)
1278 /* Some child_procs might be sockets; ignore them. Also
1279 ignore subprocesses whose output is not yet completely
1281 if (CHILD_ACTIVE (cp
)
1282 && cp
->procinfo
.hProcess
1291 if (cp
->fd
< 0 || (fd_info
[cp
->fd
].flags
& FILE_AT_EOF
) != 0)
1293 wait_hnd
[nh
] = cp
->procinfo
.hProcess
;
1299 /* PID specifies our subprocess, but its status is not
1306 /* No such child process, or nothing to wait for, so fail. */
1313 for (cp
= child_procs
+ (child_proc_count
-1); cp
>= child_procs
; cp
--)
1315 if (CHILD_ACTIVE (cp
)
1316 && cp
->procinfo
.hProcess
1317 && (cp
->fd
< 0 || (fd_info
[cp
->fd
].flags
& FILE_AT_EOF
) != 0))
1319 wait_hnd
[nh
] = cp
->procinfo
.hProcess
;
1326 /* Nothing to wait on, so fail. */
1335 timeout_ms
= 1000; /* check for quit about once a second. */
1340 active
= WaitForMultipleObjects (nh
, wait_hnd
, FALSE
, timeout_ms
);
1341 } while (active
== WAIT_TIMEOUT
&& !dont_wait
);
1343 if (active
== WAIT_FAILED
)
1348 else if (active
== WAIT_TIMEOUT
&& dont_wait
)
1350 /* PID specifies our subprocess, but it didn't exit yet, so its
1351 status is not yet available. */
1353 DebPrint (("Wait: PID %d not reap yet\n", cp
->pid
));
1357 else if (active
>= WAIT_OBJECT_0
1358 && active
< WAIT_OBJECT_0
+MAXIMUM_WAIT_OBJECTS
)
1360 active
-= WAIT_OBJECT_0
;
1362 else if (active
>= WAIT_ABANDONED_0
1363 && active
< WAIT_ABANDONED_0
+MAXIMUM_WAIT_OBJECTS
)
1365 active
-= WAIT_ABANDONED_0
;
1370 if (!GetExitCodeProcess (wait_hnd
[active
], &retval
))
1372 DebPrint (("Wait.GetExitCodeProcess failed with %lu\n",
1376 if (retval
== STILL_ACTIVE
)
1378 /* Should never happen. */
1379 DebPrint (("Wait.WaitForMultipleObjects returned an active process\n"));
1380 if (pid
> 0 && dont_wait
)
1386 /* Massage the exit code from the process to match the format expected
1387 by the WIFSTOPPED et al macros in syswait.h. Only WIFSIGNALED and
1388 WIFEXITED are supported; WIFSTOPPED doesn't make sense under NT. */
1390 if (retval
== STATUS_CONTROL_C_EXIT
)
1395 if (pid
> 0 && active
!= 0)
1400 DebPrint (("Wait signaled with process pid %d\n", cp
->pid
));
1405 reap_subprocess (cp
);
1410 /* Old versions of w32api headers don't have separate 32-bit and
1411 64-bit defines, but the one they have matches the 32-bit variety. */
1412 #ifndef IMAGE_NT_OPTIONAL_HDR32_MAGIC
1413 # define IMAGE_NT_OPTIONAL_HDR32_MAGIC IMAGE_NT_OPTIONAL_HDR_MAGIC
1414 # define IMAGE_OPTIONAL_HEADER32 IMAGE_OPTIONAL_HEADER
1418 w32_executable_type (char * filename
,
1420 int * is_cygnus_app
,
1423 file_data executable
;
1426 /* Default values in case we can't tell for sure. */
1427 *is_dos_app
= FALSE
;
1428 *is_cygnus_app
= FALSE
;
1429 *is_gui_app
= FALSE
;
1431 if (!open_input_file (&executable
, filename
))
1434 p
= strrchr (filename
, '.');
1436 /* We can only identify DOS .com programs from the extension. */
1437 if (p
&& xstrcasecmp (p
, ".com") == 0)
1439 else if (p
&& (xstrcasecmp (p
, ".bat") == 0
1440 || xstrcasecmp (p
, ".cmd") == 0))
1442 /* A DOS shell script - it appears that CreateProcess is happy to
1443 accept this (somewhat surprisingly); presumably it looks at
1444 COMSPEC to determine what executable to actually invoke.
1445 Therefore, we have to do the same here as well. */
1446 /* Actually, I think it uses the program association for that
1447 extension, which is defined in the registry. */
1448 p
= egetenv ("COMSPEC");
1450 w32_executable_type (p
, is_dos_app
, is_cygnus_app
, is_gui_app
);
1454 /* Look for DOS .exe signature - if found, we must also check that
1455 it isn't really a 16- or 32-bit Windows exe, since both formats
1456 start with a DOS program stub. Note that 16-bit Windows
1457 executables use the OS/2 1.x format. */
1459 IMAGE_DOS_HEADER
* dos_header
;
1460 IMAGE_NT_HEADERS
* nt_header
;
1462 dos_header
= (PIMAGE_DOS_HEADER
) executable
.file_base
;
1463 if (dos_header
->e_magic
!= IMAGE_DOS_SIGNATURE
)
1466 nt_header
= (PIMAGE_NT_HEADERS
) ((unsigned char *) dos_header
+ dos_header
->e_lfanew
);
1468 if ((char *) nt_header
> (char *) dos_header
+ executable
.size
)
1470 /* Some dos headers (pkunzip) have bogus e_lfanew fields. */
1473 else if (nt_header
->Signature
!= IMAGE_NT_SIGNATURE
1474 && LOWORD (nt_header
->Signature
) != IMAGE_OS2_SIGNATURE
)
1478 else if (nt_header
->Signature
== IMAGE_NT_SIGNATURE
)
1480 IMAGE_DATA_DIRECTORY
*data_dir
= NULL
;
1481 if (nt_header
->OptionalHeader
.Magic
== IMAGE_NT_OPTIONAL_HDR32_MAGIC
)
1483 /* Ensure we are using the 32 bit structure. */
1484 IMAGE_OPTIONAL_HEADER32
*opt
1485 = (IMAGE_OPTIONAL_HEADER32
*) &(nt_header
->OptionalHeader
);
1486 data_dir
= opt
->DataDirectory
;
1487 *is_gui_app
= (opt
->Subsystem
== IMAGE_SUBSYSTEM_WINDOWS_GUI
);
1489 /* MingW 3.12 has the required 64 bit structs, but in case older
1490 versions don't, only check 64 bit exes if we know how. */
1491 #ifdef IMAGE_NT_OPTIONAL_HDR64_MAGIC
1492 else if (nt_header
->OptionalHeader
.Magic
1493 == IMAGE_NT_OPTIONAL_HDR64_MAGIC
)
1495 IMAGE_OPTIONAL_HEADER64
*opt
1496 = (IMAGE_OPTIONAL_HEADER64
*) &(nt_header
->OptionalHeader
);
1497 data_dir
= opt
->DataDirectory
;
1498 *is_gui_app
= (opt
->Subsystem
== IMAGE_SUBSYSTEM_WINDOWS_GUI
);
1503 /* Look for cygwin.dll in DLL import list. */
1504 IMAGE_DATA_DIRECTORY import_dir
=
1505 data_dir
[IMAGE_DIRECTORY_ENTRY_IMPORT
];
1506 IMAGE_IMPORT_DESCRIPTOR
* imports
;
1507 IMAGE_SECTION_HEADER
* section
;
1509 section
= rva_to_section (import_dir
.VirtualAddress
, nt_header
);
1510 imports
= RVA_TO_PTR (import_dir
.VirtualAddress
, section
,
1513 for ( ; imports
->Name
; imports
++)
1515 char * dllname
= RVA_TO_PTR (imports
->Name
, section
,
1518 /* The exact name of the cygwin dll has changed with
1519 various releases, but hopefully this will be reasonably
1521 if (strncmp (dllname
, "cygwin", 6) == 0)
1523 *is_cygnus_app
= TRUE
;
1532 close_file_data (&executable
);
1536 compare_env (const void *strp1
, const void *strp2
)
1538 const char *str1
= *(const char **)strp1
, *str2
= *(const char **)strp2
;
1540 while (*str1
&& *str2
&& *str1
!= '=' && *str2
!= '=')
1542 /* Sort order in command.com/cmd.exe is based on uppercasing
1543 names, so do the same here. */
1544 if (toupper (*str1
) > toupper (*str2
))
1546 else if (toupper (*str1
) < toupper (*str2
))
1551 if (*str1
== '=' && *str2
== '=')
1553 else if (*str1
== '=')
1560 merge_and_sort_env (char **envp1
, char **envp2
, char **new_envp
)
1562 char **optr
, **nptr
;
1574 num
+= optr
- envp2
;
1576 qsort (new_envp
, num
, sizeof (char *), compare_env
);
1581 /* When a new child process is created we need to register it in our list,
1582 so intercept spawn requests. */
1584 sys_spawnve (int mode
, char *cmdname
, char **argv
, char **envp
)
1586 Lisp_Object program
, full
;
1587 char *cmdline
, *env
, *parg
, **targ
;
1591 int is_dos_app
, is_cygnus_app
, is_gui_app
;
1593 /* We pass our process ID to our children by setting up an environment
1594 variable in their environment. */
1595 char ppid_env_var_buffer
[64];
1596 char *extra_env
[] = {ppid_env_var_buffer
, NULL
};
1597 /* These are the characters that cause an argument to need quoting.
1598 Arguments with whitespace characters need quoting to prevent the
1599 argument being split into two or more. Arguments with wildcards
1600 are also quoted, for consistency with posix platforms, where wildcards
1601 are not expanded if we run the program directly without a shell.
1602 Some extra whitespace characters need quoting in Cygwin programs,
1603 so this list is conditionally modified below. */
1604 char *sepchars
= " \t*?";
1605 /* This is for native w32 apps; modified below for Cygwin apps. */
1606 char escape_char
= '\\';
1608 /* We don't care about the other modes */
1609 if (mode
!= _P_NOWAIT
)
1615 /* Handle executable names without an executable suffix. */
1616 program
= build_string (cmdname
);
1617 if (NILP (Ffile_executable_p (program
)))
1619 struct gcpro gcpro1
;
1623 openp (Vexec_path
, program
, Vexec_suffixes
, &full
, make_number (X_OK
));
1633 /* make sure argv[0] and cmdname are both in DOS format */
1634 cmdname
= SDATA (program
);
1635 unixtodos_filename (cmdname
);
1638 /* Determine whether program is a 16-bit DOS executable, or a 32-bit Windows
1639 executable that is implicitly linked to the Cygnus dll (implying it
1640 was compiled with the Cygnus GNU toolchain and hence relies on
1641 cygwin.dll to parse the command line - we use this to decide how to
1642 escape quote chars in command line args that must be quoted).
1644 Also determine whether it is a GUI app, so that we don't hide its
1645 initial window unless specifically requested. */
1646 w32_executable_type (cmdname
, &is_dos_app
, &is_cygnus_app
, &is_gui_app
);
1648 /* On Windows 95, if cmdname is a DOS app, we invoke a helper
1649 application to start it by specifying the helper app as cmdname,
1650 while leaving the real app name as argv[0]. */
1653 cmdname
= alloca (MAXPATHLEN
);
1654 if (egetenv ("CMDPROXY"))
1655 strcpy (cmdname
, egetenv ("CMDPROXY"));
1658 strcpy (cmdname
, SDATA (Vinvocation_directory
));
1659 strcat (cmdname
, "cmdproxy.exe");
1661 unixtodos_filename (cmdname
);
1664 /* we have to do some conjuring here to put argv and envp into the
1665 form CreateProcess wants... argv needs to be a space separated/null
1666 terminated list of parameters, and envp is a null
1667 separated/double-null terminated list of parameters.
1669 Additionally, zero-length args and args containing whitespace or
1670 quote chars need to be wrapped in double quotes - for this to work,
1671 embedded quotes need to be escaped as well. The aim is to ensure
1672 the child process reconstructs the argv array we start with
1673 exactly, so we treat quotes at the beginning and end of arguments
1676 The w32 GNU-based library from Cygnus doubles quotes to escape
1677 them, while MSVC uses backslash for escaping. (Actually the MSVC
1678 startup code does attempt to recognize doubled quotes and accept
1679 them, but gets it wrong and ends up requiring three quotes to get a
1680 single embedded quote!) So by default we decide whether to use
1681 quote or backslash as the escape character based on whether the
1682 binary is apparently a Cygnus compiled app.
1684 Note that using backslash to escape embedded quotes requires
1685 additional special handling if an embedded quote is already
1686 preceded by backslash, or if an arg requiring quoting ends with
1687 backslash. In such cases, the run of escape characters needs to be
1688 doubled. For consistency, we apply this special handling as long
1689 as the escape character is not quote.
1691 Since we have no idea how large argv and envp are likely to be we
1692 figure out list lengths on the fly and allocate them. */
1694 if (!NILP (Vw32_quote_process_args
))
1697 /* Override escape char by binding w32-quote-process-args to
1698 desired character, or use t for auto-selection. */
1699 if (INTEGERP (Vw32_quote_process_args
))
1700 escape_char
= XINT (Vw32_quote_process_args
);
1702 escape_char
= is_cygnus_app
? '"' : '\\';
1705 /* Cygwin apps needs quoting a bit more often. */
1706 if (escape_char
== '"')
1707 sepchars
= "\r\n\t\f '";
1715 int need_quotes
= 0;
1716 int escape_char_run
= 0;
1722 if (escape_char
== '"' && *p
== '\\')
1723 /* If it's a Cygwin app, \ needs to be escaped. */
1727 /* allow for embedded quotes to be escaped */
1730 /* handle the case where the embedded quote is already escaped */
1731 if (escape_char_run
> 0)
1733 /* To preserve the arg exactly, we need to double the
1734 preceding escape characters (plus adding one to
1735 escape the quote character itself). */
1736 arglen
+= escape_char_run
;
1739 else if (strchr (sepchars
, *p
) != NULL
)
1744 if (*p
== escape_char
&& escape_char
!= '"')
1747 escape_char_run
= 0;
1752 /* handle the case where the arg ends with an escape char - we
1753 must not let the enclosing quote be escaped. */
1754 if (escape_char_run
> 0)
1755 arglen
+= escape_char_run
;
1757 arglen
+= strlen (*targ
++) + 1;
1759 cmdline
= alloca (arglen
);
1765 int need_quotes
= 0;
1773 if ((strchr (sepchars
, *p
) != NULL
) || *p
== '"')
1778 int escape_char_run
= 0;
1784 last
= p
+ strlen (p
) - 1;
1787 /* This version does not escape quotes if they occur at the
1788 beginning or end of the arg - this could lead to incorrect
1789 behavior when the arg itself represents a command line
1790 containing quoted args. I believe this was originally done
1791 as a hack to make some things work, before
1792 `w32-quote-process-args' was added. */
1795 if (*p
== '"' && p
> first
&& p
< last
)
1796 *parg
++ = escape_char
; /* escape embedded quotes */
1804 /* double preceding escape chars if any */
1805 while (escape_char_run
> 0)
1807 *parg
++ = escape_char
;
1810 /* escape all quote chars, even at beginning or end */
1811 *parg
++ = escape_char
;
1813 else if (escape_char
== '"' && *p
== '\\')
1817 if (*p
== escape_char
&& escape_char
!= '"')
1820 escape_char_run
= 0;
1822 /* double escape chars before enclosing quote */
1823 while (escape_char_run
> 0)
1825 *parg
++ = escape_char
;
1833 strcpy (parg
, *targ
);
1834 parg
+= strlen (*targ
);
1844 numenv
= 1; /* for end null */
1847 arglen
+= strlen (*targ
++) + 1;
1850 /* extra env vars... */
1851 sprintf (ppid_env_var_buffer
, "EM_PARENT_PROCESS_ID=%lu",
1852 GetCurrentProcessId ());
1853 arglen
+= strlen (ppid_env_var_buffer
) + 1;
1856 /* merge env passed in and extra env into one, and sort it. */
1857 targ
= (char **) alloca (numenv
* sizeof (char *));
1858 merge_and_sort_env (envp
, extra_env
, targ
);
1860 /* concatenate env entries. */
1861 env
= alloca (arglen
);
1865 strcpy (parg
, *targ
);
1866 parg
+= strlen (*targ
++);
1879 /* Now create the process. */
1880 if (!create_child (cmdname
, cmdline
, env
, is_gui_app
, &pid
, cp
))
1890 /* Emulate the select call
1891 Wait for available input on any of the given rfds, or timeout if
1892 a timeout is given and no input is detected
1893 wfds and efds are not supported and must be NULL.
1895 For simplicity, we detect the death of child processes here and
1896 synchronously call the SIGCHLD handler. Since it is possible for
1897 children to be created without a corresponding pipe handle from which
1898 to read output, we wait separately on the process handles as well as
1899 the char_avail events for each process pipe. We only call
1900 wait/reap_process when the process actually terminates.
1902 To reduce the number of places in which Emacs can be hung such that
1903 C-g is not able to interrupt it, we always wait on interrupt_handle
1904 (which is signaled by the input thread when C-g is detected). If we
1905 detect that we were woken up by C-g, we return -1 with errno set to
1906 EINTR as on Unix. */
1908 /* From w32console.c */
1909 extern HANDLE keyboard_handle
;
1911 /* From w32xfns.c */
1912 extern HANDLE interrupt_handle
;
1914 /* From process.c */
1915 extern int proc_buffered_char
[];
1918 sys_select (int nfds
, SELECT_TYPE
*rfds
, SELECT_TYPE
*wfds
, SELECT_TYPE
*efds
,
1919 EMACS_TIME
*timeout
, void *ignored
)
1922 DWORD timeout_ms
, start_time
;
1925 child_process
*cp
, *cps
[MAX_CHILDREN
];
1926 HANDLE wait_hnd
[MAXDESC
+ MAX_CHILDREN
];
1927 int fdindex
[MAXDESC
]; /* mapping from wait handles back to descriptors */
1930 timeout
? (timeout
->tv_sec
* 1000 + timeout
->tv_nsec
/ 1000000) : INFINITE
;
1932 /* If the descriptor sets are NULL but timeout isn't, then just Sleep. */
1933 if (rfds
== NULL
&& wfds
== NULL
&& efds
== NULL
&& timeout
!= NULL
)
1939 /* Otherwise, we only handle rfds, so fail otherwise. */
1940 if (rfds
== NULL
|| wfds
!= NULL
|| efds
!= NULL
)
1950 /* Always wait on interrupt_handle, to detect C-g (quit). */
1951 wait_hnd
[0] = interrupt_handle
;
1954 /* Build a list of pipe handles to wait on. */
1956 for (i
= 0; i
< nfds
; i
++)
1957 if (FD_ISSET (i
, &orfds
))
1961 if (keyboard_handle
)
1963 /* Handle stdin specially */
1964 wait_hnd
[nh
] = keyboard_handle
;
1969 /* Check for any emacs-generated input in the queue since
1970 it won't be detected in the wait */
1971 if (detect_input_pending ())
1979 /* Child process and socket/comm port input. */
1983 int current_status
= cp
->status
;
1985 if (current_status
== STATUS_READ_ACKNOWLEDGED
)
1987 /* Tell reader thread which file handle to use. */
1989 /* Wake up the reader thread for this process */
1990 cp
->status
= STATUS_READ_READY
;
1991 if (!SetEvent (cp
->char_consumed
))
1992 DebPrint (("sys_select.SetEvent failed with "
1993 "%lu for fd %ld\n", GetLastError (), i
));
1996 #ifdef CHECK_INTERLOCK
1997 /* slightly crude cross-checking of interlock between threads */
1999 current_status
= cp
->status
;
2000 if (WaitForSingleObject (cp
->char_avail
, 0) == WAIT_OBJECT_0
)
2002 /* char_avail has been signaled, so status (which may
2003 have changed) should indicate read has completed
2004 but has not been acknowledged. */
2005 current_status
= cp
->status
;
2006 if (current_status
!= STATUS_READ_SUCCEEDED
2007 && current_status
!= STATUS_READ_FAILED
)
2008 DebPrint (("char_avail set, but read not completed: status %d\n",
2013 /* char_avail has not been signaled, so status should
2014 indicate that read is in progress; small possibility
2015 that read has completed but event wasn't yet signaled
2016 when we tested it (because a context switch occurred
2017 or if running on separate CPUs). */
2018 if (current_status
!= STATUS_READ_READY
2019 && current_status
!= STATUS_READ_IN_PROGRESS
2020 && current_status
!= STATUS_READ_SUCCEEDED
2021 && current_status
!= STATUS_READ_FAILED
)
2022 DebPrint (("char_avail reset, but read status is bad: %d\n",
2026 wait_hnd
[nh
] = cp
->char_avail
;
2028 if (!wait_hnd
[nh
]) emacs_abort ();
2031 DebPrint (("select waiting on child %d fd %d\n",
2032 cp
-child_procs
, i
));
2037 /* Unable to find something to wait on for this fd, skip */
2039 /* Note that this is not a fatal error, and can in fact
2040 happen in unusual circumstances. Specifically, if
2041 sys_spawnve fails, eg. because the program doesn't
2042 exist, and debug-on-error is t so Fsignal invokes a
2043 nested input loop, then the process output pipe is
2044 still included in input_wait_mask with no child_proc
2045 associated with it. (It is removed when the debugger
2046 exits the nested input loop and the error is thrown.) */
2048 DebPrint (("sys_select: fd %ld is invalid! ignoring\n", i
));
2054 /* Add handles of child processes. */
2056 for (cp
= child_procs
+ (child_proc_count
-1); cp
>= child_procs
; cp
--)
2057 /* Some child_procs might be sockets; ignore them. Also some
2058 children may have died already, but we haven't finished reading
2059 the process output; ignore them too. */
2060 if ((CHILD_ACTIVE (cp
) && cp
->procinfo
.hProcess
)
2062 || (fd_info
[cp
->fd
].flags
& FILE_SEND_SIGCHLD
) == 0
2063 || (fd_info
[cp
->fd
].flags
& FILE_AT_EOF
) != 0)
2066 wait_hnd
[nh
+ nc
] = cp
->procinfo
.hProcess
;
2071 /* Nothing to look for, so we didn't find anything */
2079 start_time
= GetTickCount ();
2081 /* Wait for input or child death to be signaled. If user input is
2082 allowed, then also accept window messages. */
2083 if (FD_ISSET (0, &orfds
))
2084 active
= MsgWaitForMultipleObjects (nh
+ nc
, wait_hnd
, FALSE
, timeout_ms
,
2087 active
= WaitForMultipleObjects (nh
+ nc
, wait_hnd
, FALSE
, timeout_ms
);
2089 if (active
== WAIT_FAILED
)
2091 DebPrint (("select.WaitForMultipleObjects (%d, %lu) failed with %lu\n",
2092 nh
+ nc
, timeout_ms
, GetLastError ()));
2093 /* don't return EBADF - this causes wait_reading_process_output to
2094 abort; WAIT_FAILED is returned when single-stepping under
2095 Windows 95 after switching thread focus in debugger, and
2096 possibly at other times. */
2100 else if (active
== WAIT_TIMEOUT
)
2104 else if (active
>= WAIT_OBJECT_0
2105 && active
< WAIT_OBJECT_0
+MAXIMUM_WAIT_OBJECTS
)
2107 active
-= WAIT_OBJECT_0
;
2109 else if (active
>= WAIT_ABANDONED_0
2110 && active
< WAIT_ABANDONED_0
+MAXIMUM_WAIT_OBJECTS
)
2112 active
-= WAIT_ABANDONED_0
;
2117 /* Loop over all handles after active (now officially documented as
2118 being the first signaled handle in the array). We do this to
2119 ensure fairness, so that all channels with data available will be
2120 processed - otherwise higher numbered channels could be starved. */
2123 if (active
== nh
+ nc
)
2125 /* There are messages in the lisp thread's queue; we must
2126 drain the queue now to ensure they are processed promptly,
2127 because if we don't do so, we will not be woken again until
2128 further messages arrive.
2130 NB. If ever we allow window message procedures to callback
2131 into lisp, we will need to ensure messages are dispatched
2132 at a safe time for lisp code to be run (*), and we may also
2133 want to provide some hooks in the dispatch loop to cater
2134 for modeless dialogs created by lisp (ie. to register
2135 window handles to pass to IsDialogMessage).
2137 (*) Note that MsgWaitForMultipleObjects above is an
2138 internal dispatch point for messages that are sent to
2139 windows created by this thread. */
2140 if (drain_message_queue ()
2141 /* If drain_message_queue returns non-zero, that means
2142 we received a WM_EMACS_FILENOTIFY message. If this
2143 is a TTY frame, we must signal the caller that keyboard
2144 input is available, so that w32_console_read_socket
2145 will be called to pick up the notifications. If we
2146 don't do that, file notifications will only work when
2147 the Emacs TTY frame has focus. */
2148 && FRAME_TERMCAP_P (SELECTED_FRAME ())
2149 /* they asked for stdin reads */
2150 && FD_ISSET (0, &orfds
)
2151 /* the stdin handle is valid */
2159 else if (active
>= nh
)
2161 cp
= cps
[active
- nh
];
2163 /* We cannot always signal SIGCHLD immediately; if we have not
2164 finished reading the process output, we must delay sending
2165 SIGCHLD until we do. */
2167 if (cp
->fd
>= 0 && (fd_info
[cp
->fd
].flags
& FILE_AT_EOF
) == 0)
2168 fd_info
[cp
->fd
].flags
|= FILE_SEND_SIGCHLD
;
2169 /* SIG_DFL for SIGCHLD is ignore */
2170 else if (sig_handlers
[SIGCHLD
] != SIG_DFL
&&
2171 sig_handlers
[SIGCHLD
] != SIG_IGN
)
2174 DebPrint (("select calling SIGCHLD handler for pid %d\n",
2177 sig_handlers
[SIGCHLD
] (SIGCHLD
);
2180 else if (fdindex
[active
] == -1)
2182 /* Quit (C-g) was detected. */
2186 else if (fdindex
[active
] == 0)
2188 /* Keyboard input available */
2194 /* must be a socket or pipe - read ahead should have
2195 completed, either succeeding or failing. */
2196 FD_SET (fdindex
[active
], rfds
);
2200 /* Even though wait_reading_process_output only reads from at most
2201 one channel, we must process all channels here so that we reap
2202 all children that have died. */
2203 while (++active
< nh
+ nc
)
2204 if (WaitForSingleObject (wait_hnd
[active
], 0) == WAIT_OBJECT_0
)
2206 } while (active
< nh
+ nc
);
2208 /* If no input has arrived and timeout hasn't expired, wait again. */
2211 DWORD elapsed
= GetTickCount () - start_time
;
2213 if (timeout_ms
> elapsed
) /* INFINITE is MAX_UINT */
2215 if (timeout_ms
!= INFINITE
)
2216 timeout_ms
-= elapsed
;
2217 goto count_children
;
2224 /* Substitute for certain kill () operations */
2226 static BOOL CALLBACK
2227 find_child_console (HWND hwnd
, LPARAM arg
)
2229 child_process
* cp
= (child_process
*) arg
;
2233 thread_id
= GetWindowThreadProcessId (hwnd
, &process_id
);
2234 if (process_id
== cp
->procinfo
.dwProcessId
)
2236 char window_class
[32];
2238 GetClassName (hwnd
, window_class
, sizeof (window_class
));
2239 if (strcmp (window_class
,
2240 (os_subtype
== OS_9X
)
2242 : "ConsoleWindowClass") == 0)
2252 /* Emulate 'kill', but only for other processes. */
2254 sys_kill (pid_t pid
, int sig
)
2258 int need_to_free
= 0;
2261 /* Each process is in its own process group. */
2265 /* Only handle signals that will result in the process dying */
2266 if (sig
!= SIGINT
&& sig
!= SIGKILL
&& sig
!= SIGQUIT
&& sig
!= SIGHUP
)
2272 cp
= find_child_pid (pid
);
2275 /* We were passed a PID of something other than our subprocess.
2276 If that is our own PID, we will send to ourself a message to
2277 close the selected frame, which does not necessarily
2278 terminates Emacs. But then we are not supposed to call
2279 sys_kill with our own PID. */
2280 proc_hand
= OpenProcess (PROCESS_TERMINATE
, 0, pid
);
2281 if (proc_hand
== NULL
)
2290 proc_hand
= cp
->procinfo
.hProcess
;
2291 pid
= cp
->procinfo
.dwProcessId
;
2293 /* Try to locate console window for process. */
2294 EnumWindows (find_child_console
, (LPARAM
) cp
);
2297 if (sig
== SIGINT
|| sig
== SIGQUIT
)
2299 if (NILP (Vw32_start_process_share_console
) && cp
&& cp
->hwnd
)
2301 BYTE control_scan_code
= (BYTE
) MapVirtualKey (VK_CONTROL
, 0);
2302 /* Fake Ctrl-C for SIGINT, and Ctrl-Break for SIGQUIT. */
2303 BYTE vk_break_code
= (sig
== SIGINT
) ? 'C' : VK_CANCEL
;
2304 BYTE break_scan_code
= (BYTE
) MapVirtualKey (vk_break_code
, 0);
2305 HWND foreground_window
;
2307 if (break_scan_code
== 0)
2309 /* Fake Ctrl-C for SIGQUIT if we can't manage Ctrl-Break. */
2310 vk_break_code
= 'C';
2311 break_scan_code
= (BYTE
) MapVirtualKey (vk_break_code
, 0);
2314 foreground_window
= GetForegroundWindow ();
2315 if (foreground_window
)
2317 /* NT 5.0, and apparently also Windows 98, will not allow
2318 a Window to be set to foreground directly without the
2319 user's involvement. The workaround is to attach
2320 ourselves to the thread that owns the foreground
2321 window, since that is the only thread that can set the
2322 foreground window. */
2323 DWORD foreground_thread
, child_thread
;
2325 GetWindowThreadProcessId (foreground_window
, NULL
);
2326 if (foreground_thread
== GetCurrentThreadId ()
2327 || !AttachThreadInput (GetCurrentThreadId (),
2328 foreground_thread
, TRUE
))
2329 foreground_thread
= 0;
2331 child_thread
= GetWindowThreadProcessId (cp
->hwnd
, NULL
);
2332 if (child_thread
== GetCurrentThreadId ()
2333 || !AttachThreadInput (GetCurrentThreadId (),
2334 child_thread
, TRUE
))
2337 /* Set the foreground window to the child. */
2338 if (SetForegroundWindow (cp
->hwnd
))
2340 /* Generate keystrokes as if user had typed Ctrl-Break or
2342 keybd_event (VK_CONTROL
, control_scan_code
, 0, 0);
2343 keybd_event (vk_break_code
, break_scan_code
,
2344 (vk_break_code
== 'C' ? 0 : KEYEVENTF_EXTENDEDKEY
), 0);
2345 keybd_event (vk_break_code
, break_scan_code
,
2346 (vk_break_code
== 'C' ? 0 : KEYEVENTF_EXTENDEDKEY
)
2347 | KEYEVENTF_KEYUP
, 0);
2348 keybd_event (VK_CONTROL
, control_scan_code
,
2349 KEYEVENTF_KEYUP
, 0);
2351 /* Sleep for a bit to give time for Emacs frame to respond
2352 to focus change events (if Emacs was active app). */
2355 SetForegroundWindow (foreground_window
);
2357 /* Detach from the foreground and child threads now that
2358 the foreground switching is over. */
2359 if (foreground_thread
)
2360 AttachThreadInput (GetCurrentThreadId (),
2361 foreground_thread
, FALSE
);
2363 AttachThreadInput (GetCurrentThreadId (),
2364 child_thread
, FALSE
);
2367 /* Ctrl-Break is NT equivalent of SIGINT. */
2368 else if (!GenerateConsoleCtrlEvent (CTRL_BREAK_EVENT
, pid
))
2370 DebPrint (("sys_kill.GenerateConsoleCtrlEvent return %d "
2371 "for pid %lu\n", GetLastError (), pid
));
2378 if (NILP (Vw32_start_process_share_console
) && cp
&& cp
->hwnd
)
2381 if (os_subtype
== OS_9X
)
2384 Another possibility is to try terminating the VDM out-right by
2385 calling the Shell VxD (id 0x17) V86 interface, function #4
2386 "SHELL_Destroy_VM", ie.
2392 First need to determine the current VM handle, and then arrange for
2393 the shellapi call to be made from the system vm (by using
2394 Switch_VM_and_callback).
2396 Could try to invoke DestroyVM through CallVxD.
2400 /* On Windows 95, posting WM_QUIT causes the 16-bit subsystem
2401 to hang when cmdproxy is used in conjunction with
2402 command.com for an interactive shell. Posting
2403 WM_CLOSE pops up a dialog that, when Yes is selected,
2404 does the same thing. TerminateProcess is also less
2405 than ideal in that subprocesses tend to stick around
2406 until the machine is shutdown, but at least it
2407 doesn't freeze the 16-bit subsystem. */
2408 PostMessage (cp
->hwnd
, WM_QUIT
, 0xff, 0);
2410 if (!TerminateProcess (proc_hand
, 0xff))
2412 DebPrint (("sys_kill.TerminateProcess returned %d "
2413 "for pid %lu\n", GetLastError (), pid
));
2420 PostMessage (cp
->hwnd
, WM_CLOSE
, 0, 0);
2422 /* Kill the process. On W32 this doesn't kill child processes
2423 so it doesn't work very well for shells which is why it's not
2424 used in every case. */
2425 else if (!TerminateProcess (proc_hand
, 0xff))
2427 DebPrint (("sys_kill.TerminateProcess returned %d "
2428 "for pid %lu\n", GetLastError (), pid
));
2435 CloseHandle (proc_hand
);
2440 /* The following two routines are used to manipulate stdin, stdout, and
2441 stderr of our child processes.
2443 Assuming that in, out, and err are *not* inheritable, we make them
2444 stdin, stdout, and stderr of the child as follows:
2446 - Save the parent's current standard handles.
2447 - Set the std handles to inheritable duplicates of the ones being passed in.
2448 (Note that _get_osfhandle() is an io.h procedure that retrieves the
2449 NT file handle for a crt file descriptor.)
2450 - Spawn the child, which inherits in, out, and err as stdin,
2451 stdout, and stderr. (see Spawnve)
2452 - Close the std handles passed to the child.
2453 - Reset the parent's standard handles to the saved handles.
2454 (see reset_standard_handles)
2455 We assume that the caller closes in, out, and err after calling us. */
2458 prepare_standard_handles (int in
, int out
, int err
, HANDLE handles
[3])
2461 HANDLE newstdin
, newstdout
, newstderr
;
2463 parent
= GetCurrentProcess ();
2465 handles
[0] = GetStdHandle (STD_INPUT_HANDLE
);
2466 handles
[1] = GetStdHandle (STD_OUTPUT_HANDLE
);
2467 handles
[2] = GetStdHandle (STD_ERROR_HANDLE
);
2469 /* make inheritable copies of the new handles */
2470 if (!DuplicateHandle (parent
,
2471 (HANDLE
) _get_osfhandle (in
),
2476 DUPLICATE_SAME_ACCESS
))
2477 report_file_error ("Duplicating input handle for child", Qnil
);
2479 if (!DuplicateHandle (parent
,
2480 (HANDLE
) _get_osfhandle (out
),
2485 DUPLICATE_SAME_ACCESS
))
2486 report_file_error ("Duplicating output handle for child", Qnil
);
2488 if (!DuplicateHandle (parent
,
2489 (HANDLE
) _get_osfhandle (err
),
2494 DUPLICATE_SAME_ACCESS
))
2495 report_file_error ("Duplicating error handle for child", Qnil
);
2497 /* and store them as our std handles */
2498 if (!SetStdHandle (STD_INPUT_HANDLE
, newstdin
))
2499 report_file_error ("Changing stdin handle", Qnil
);
2501 if (!SetStdHandle (STD_OUTPUT_HANDLE
, newstdout
))
2502 report_file_error ("Changing stdout handle", Qnil
);
2504 if (!SetStdHandle (STD_ERROR_HANDLE
, newstderr
))
2505 report_file_error ("Changing stderr handle", Qnil
);
2509 reset_standard_handles (int in
, int out
, int err
, HANDLE handles
[3])
2511 /* close the duplicated handles passed to the child */
2512 CloseHandle (GetStdHandle (STD_INPUT_HANDLE
));
2513 CloseHandle (GetStdHandle (STD_OUTPUT_HANDLE
));
2514 CloseHandle (GetStdHandle (STD_ERROR_HANDLE
));
2516 /* now restore parent's saved std handles */
2517 SetStdHandle (STD_INPUT_HANDLE
, handles
[0]);
2518 SetStdHandle (STD_OUTPUT_HANDLE
, handles
[1]);
2519 SetStdHandle (STD_ERROR_HANDLE
, handles
[2]);
2523 set_process_dir (char * dir
)
2528 /* To avoid problems with winsock implementations that work over dial-up
2529 connections causing or requiring a connection to exist while Emacs is
2530 running, Emacs no longer automatically loads winsock on startup if it
2531 is present. Instead, it will be loaded when open-network-stream is
2534 To allow full control over when winsock is loaded, we provide these
2535 two functions to dynamically load and unload winsock. This allows
2536 dial-up users to only be connected when they actually need to use
2540 extern HANDLE winsock_lib
;
2541 extern BOOL
term_winsock (void);
2542 extern BOOL
init_winsock (int load_now
);
2544 DEFUN ("w32-has-winsock", Fw32_has_winsock
, Sw32_has_winsock
, 0, 1, 0,
2545 doc
: /* Test for presence of the Windows socket library `winsock'.
2546 Returns non-nil if winsock support is present, nil otherwise.
2548 If the optional argument LOAD-NOW is non-nil, the winsock library is
2549 also loaded immediately if not already loaded. If winsock is loaded,
2550 the winsock local hostname is returned (since this may be different from
2551 the value of `system-name' and should supplant it), otherwise t is
2552 returned to indicate winsock support is present. */)
2553 (Lisp_Object load_now
)
2557 have_winsock
= init_winsock (!NILP (load_now
));
2560 if (winsock_lib
!= NULL
)
2562 /* Return new value for system-name. The best way to do this
2563 is to call init_system_name, saving and restoring the
2564 original value to avoid side-effects. */
2565 Lisp_Object orig_hostname
= Vsystem_name
;
2566 Lisp_Object hostname
;
2568 init_system_name ();
2569 hostname
= Vsystem_name
;
2570 Vsystem_name
= orig_hostname
;
2578 DEFUN ("w32-unload-winsock", Fw32_unload_winsock
, Sw32_unload_winsock
,
2580 doc
: /* Unload the Windows socket library `winsock' if loaded.
2581 This is provided to allow dial-up socket connections to be disconnected
2582 when no longer needed. Returns nil without unloading winsock if any
2583 socket connections still exist. */)
2586 return term_winsock () ? Qt
: Qnil
;
2590 /* Some miscellaneous functions that are Windows specific, but not GUI
2591 specific (ie. are applicable in terminal or batch mode as well). */
2593 DEFUN ("w32-short-file-name", Fw32_short_file_name
, Sw32_short_file_name
, 1, 1, 0,
2594 doc
: /* Return the short file name version (8.3) of the full path of FILENAME.
2595 If FILENAME does not exist, return nil.
2596 All path elements in FILENAME are converted to their short names. */)
2597 (Lisp_Object filename
)
2599 char shortname
[MAX_PATH
];
2601 CHECK_STRING (filename
);
2603 /* first expand it. */
2604 filename
= Fexpand_file_name (filename
, Qnil
);
2606 /* luckily, this returns the short version of each element in the path. */
2607 if (GetShortPathName (SDATA (ENCODE_FILE (filename
)), shortname
, MAX_PATH
) == 0)
2610 dostounix_filename (shortname
, 0);
2612 /* No need to DECODE_FILE, because 8.3 names are pure ASCII. */
2613 return build_string (shortname
);
2617 DEFUN ("w32-long-file-name", Fw32_long_file_name
, Sw32_long_file_name
,
2619 doc
: /* Return the long file name version of the full path of FILENAME.
2620 If FILENAME does not exist, return nil.
2621 All path elements in FILENAME are converted to their long names. */)
2622 (Lisp_Object filename
)
2624 char longname
[ MAX_PATH
];
2627 CHECK_STRING (filename
);
2629 if (SBYTES (filename
) == 2
2630 && *(SDATA (filename
) + 1) == ':')
2633 /* first expand it. */
2634 filename
= Fexpand_file_name (filename
, Qnil
);
2636 if (!w32_get_long_filename (SDATA (ENCODE_FILE (filename
)), longname
, MAX_PATH
))
2639 dostounix_filename (longname
, 0);
2641 /* If we were passed only a drive, make sure that a slash is not appended
2642 for consistency with directories. Allow for drive mapping via SUBST
2643 in case expand-file-name is ever changed to expand those. */
2644 if (drive_only
&& longname
[1] == ':' && longname
[2] == '/' && !longname
[3])
2647 return DECODE_FILE (build_string (longname
));
2650 DEFUN ("w32-set-process-priority", Fw32_set_process_priority
,
2651 Sw32_set_process_priority
, 2, 2, 0,
2652 doc
: /* Set the priority of PROCESS to PRIORITY.
2653 If PROCESS is nil, the priority of Emacs is changed, otherwise the
2654 priority of the process whose pid is PROCESS is changed.
2655 PRIORITY should be one of the symbols high, normal, or low;
2656 any other symbol will be interpreted as normal.
2658 If successful, the return value is t, otherwise nil. */)
2659 (Lisp_Object process
, Lisp_Object priority
)
2661 HANDLE proc_handle
= GetCurrentProcess ();
2662 DWORD priority_class
= NORMAL_PRIORITY_CLASS
;
2663 Lisp_Object result
= Qnil
;
2665 CHECK_SYMBOL (priority
);
2667 if (!NILP (process
))
2672 CHECK_NUMBER (process
);
2674 /* Allow pid to be an internally generated one, or one obtained
2675 externally. This is necessary because real pids on Windows 95 are
2678 pid
= XINT (process
);
2679 cp
= find_child_pid (pid
);
2681 pid
= cp
->procinfo
.dwProcessId
;
2683 proc_handle
= OpenProcess (PROCESS_SET_INFORMATION
, FALSE
, pid
);
2686 if (EQ (priority
, Qhigh
))
2687 priority_class
= HIGH_PRIORITY_CLASS
;
2688 else if (EQ (priority
, Qlow
))
2689 priority_class
= IDLE_PRIORITY_CLASS
;
2691 if (proc_handle
!= NULL
)
2693 if (SetPriorityClass (proc_handle
, priority_class
))
2695 if (!NILP (process
))
2696 CloseHandle (proc_handle
);
2702 #ifdef HAVE_LANGINFO_CODESET
2703 /* Emulation of nl_langinfo. Used in fns.c:Flocale_info. */
2705 nl_langinfo (nl_item item
)
2707 /* Conversion of Posix item numbers to their Windows equivalents. */
2708 static const LCTYPE w32item
[] = {
2709 LOCALE_IDEFAULTANSICODEPAGE
,
2710 LOCALE_SDAYNAME1
, LOCALE_SDAYNAME2
, LOCALE_SDAYNAME3
,
2711 LOCALE_SDAYNAME4
, LOCALE_SDAYNAME5
, LOCALE_SDAYNAME6
, LOCALE_SDAYNAME7
,
2712 LOCALE_SMONTHNAME1
, LOCALE_SMONTHNAME2
, LOCALE_SMONTHNAME3
,
2713 LOCALE_SMONTHNAME4
, LOCALE_SMONTHNAME5
, LOCALE_SMONTHNAME6
,
2714 LOCALE_SMONTHNAME7
, LOCALE_SMONTHNAME8
, LOCALE_SMONTHNAME9
,
2715 LOCALE_SMONTHNAME10
, LOCALE_SMONTHNAME11
, LOCALE_SMONTHNAME12
2718 static char *nl_langinfo_buf
= NULL
;
2719 static int nl_langinfo_len
= 0;
2721 if (nl_langinfo_len
<= 0)
2722 nl_langinfo_buf
= xmalloc (nl_langinfo_len
= 1);
2724 if (item
< 0 || item
>= _NL_NUM
)
2725 nl_langinfo_buf
[0] = 0;
2728 LCID cloc
= GetThreadLocale ();
2729 int need_len
= GetLocaleInfo (cloc
, w32item
[item
] | LOCALE_USE_CP_ACP
,
2733 nl_langinfo_buf
[0] = 0;
2736 if (item
== CODESET
)
2738 need_len
+= 2; /* for the "cp" prefix */
2739 if (need_len
< 8) /* for the case we call GetACP */
2742 if (nl_langinfo_len
<= need_len
)
2743 nl_langinfo_buf
= xrealloc (nl_langinfo_buf
,
2744 nl_langinfo_len
= need_len
);
2745 if (!GetLocaleInfo (cloc
, w32item
[item
] | LOCALE_USE_CP_ACP
,
2746 nl_langinfo_buf
, nl_langinfo_len
))
2747 nl_langinfo_buf
[0] = 0;
2748 else if (item
== CODESET
)
2750 if (strcmp (nl_langinfo_buf
, "0") == 0 /* CP_ACP */
2751 || strcmp (nl_langinfo_buf
, "1") == 0) /* CP_OEMCP */
2752 sprintf (nl_langinfo_buf
, "cp%u", GetACP ());
2755 memmove (nl_langinfo_buf
+ 2, nl_langinfo_buf
,
2756 strlen (nl_langinfo_buf
) + 1);
2757 nl_langinfo_buf
[0] = 'c';
2758 nl_langinfo_buf
[1] = 'p';
2763 return nl_langinfo_buf
;
2765 #endif /* HAVE_LANGINFO_CODESET */
2767 DEFUN ("w32-get-locale-info", Fw32_get_locale_info
,
2768 Sw32_get_locale_info
, 1, 2, 0,
2769 doc
: /* Return information about the Windows locale LCID.
2770 By default, return a three letter locale code which encodes the default
2771 language as the first two characters, and the country or regional variant
2772 as the third letter. For example, ENU refers to `English (United States)',
2773 while ENC means `English (Canadian)'.
2775 If the optional argument LONGFORM is t, the long form of the locale
2776 name is returned, e.g. `English (United States)' instead; if LONGFORM
2777 is a number, it is interpreted as an LCTYPE constant and the corresponding
2778 locale information is returned.
2780 If LCID (a 16-bit number) is not a valid locale, the result is nil. */)
2781 (Lisp_Object lcid
, Lisp_Object longform
)
2785 char abbrev_name
[32] = { 0 };
2786 char full_name
[256] = { 0 };
2788 CHECK_NUMBER (lcid
);
2790 if (!IsValidLocale (XINT (lcid
), LCID_SUPPORTED
))
2793 if (NILP (longform
))
2795 got_abbrev
= GetLocaleInfo (XINT (lcid
),
2796 LOCALE_SABBREVLANGNAME
| LOCALE_USE_CP_ACP
,
2797 abbrev_name
, sizeof (abbrev_name
));
2799 return build_string (abbrev_name
);
2801 else if (EQ (longform
, Qt
))
2803 got_full
= GetLocaleInfo (XINT (lcid
),
2804 LOCALE_SLANGUAGE
| LOCALE_USE_CP_ACP
,
2805 full_name
, sizeof (full_name
));
2807 return DECODE_SYSTEM (build_string (full_name
));
2809 else if (NUMBERP (longform
))
2811 got_full
= GetLocaleInfo (XINT (lcid
),
2813 full_name
, sizeof (full_name
));
2814 /* GetLocaleInfo's return value includes the terminating null
2815 character, when the returned information is a string, whereas
2816 make_unibyte_string needs the string length without the
2817 terminating null. */
2819 return make_unibyte_string (full_name
, got_full
- 1);
2826 DEFUN ("w32-get-current-locale-id", Fw32_get_current_locale_id
,
2827 Sw32_get_current_locale_id
, 0, 0, 0,
2828 doc
: /* Return Windows locale id for current locale setting.
2829 This is a numerical value; use `w32-get-locale-info' to convert to a
2830 human-readable form. */)
2833 return make_number (GetThreadLocale ());
2837 int_from_hex (char * s
)
2840 static char hex
[] = "0123456789abcdefABCDEF";
2843 while (*s
&& (p
= strchr (hex
, *s
)) != NULL
)
2845 unsigned digit
= p
- hex
;
2848 val
= val
* 16 + digit
;
2854 /* We need to build a global list, since the EnumSystemLocale callback
2855 function isn't given a context pointer. */
2856 Lisp_Object Vw32_valid_locale_ids
;
2858 static BOOL CALLBACK
2859 enum_locale_fn (LPTSTR localeNum
)
2861 DWORD id
= int_from_hex (localeNum
);
2862 Vw32_valid_locale_ids
= Fcons (make_number (id
), Vw32_valid_locale_ids
);
2866 DEFUN ("w32-get-valid-locale-ids", Fw32_get_valid_locale_ids
,
2867 Sw32_get_valid_locale_ids
, 0, 0, 0,
2868 doc
: /* Return list of all valid Windows locale ids.
2869 Each id is a numerical value; use `w32-get-locale-info' to convert to a
2870 human-readable form. */)
2873 Vw32_valid_locale_ids
= Qnil
;
2875 EnumSystemLocales (enum_locale_fn
, LCID_SUPPORTED
);
2877 Vw32_valid_locale_ids
= Fnreverse (Vw32_valid_locale_ids
);
2878 return Vw32_valid_locale_ids
;
2882 DEFUN ("w32-get-default-locale-id", Fw32_get_default_locale_id
, Sw32_get_default_locale_id
, 0, 1, 0,
2883 doc
: /* Return Windows locale id for default locale setting.
2884 By default, the system default locale setting is returned; if the optional
2885 parameter USERP is non-nil, the user default locale setting is returned.
2886 This is a numerical value; use `w32-get-locale-info' to convert to a
2887 human-readable form. */)
2891 return make_number (GetSystemDefaultLCID ());
2892 return make_number (GetUserDefaultLCID ());
2896 DEFUN ("w32-set-current-locale", Fw32_set_current_locale
, Sw32_set_current_locale
, 1, 1, 0,
2897 doc
: /* Make Windows locale LCID be the current locale setting for Emacs.
2898 If successful, the new locale id is returned, otherwise nil. */)
2901 CHECK_NUMBER (lcid
);
2903 if (!IsValidLocale (XINT (lcid
), LCID_SUPPORTED
))
2906 if (!SetThreadLocale (XINT (lcid
)))
2909 /* Need to set input thread locale if present. */
2910 if (dwWindowsThreadId
)
2911 /* Reply is not needed. */
2912 PostThreadMessage (dwWindowsThreadId
, WM_EMACS_SETLOCALE
, XINT (lcid
), 0);
2914 return make_number (GetThreadLocale ());
2918 /* We need to build a global list, since the EnumCodePages callback
2919 function isn't given a context pointer. */
2920 Lisp_Object Vw32_valid_codepages
;
2922 static BOOL CALLBACK
2923 enum_codepage_fn (LPTSTR codepageNum
)
2925 DWORD id
= atoi (codepageNum
);
2926 Vw32_valid_codepages
= Fcons (make_number (id
), Vw32_valid_codepages
);
2930 DEFUN ("w32-get-valid-codepages", Fw32_get_valid_codepages
,
2931 Sw32_get_valid_codepages
, 0, 0, 0,
2932 doc
: /* Return list of all valid Windows codepages. */)
2935 Vw32_valid_codepages
= Qnil
;
2937 EnumSystemCodePages (enum_codepage_fn
, CP_SUPPORTED
);
2939 Vw32_valid_codepages
= Fnreverse (Vw32_valid_codepages
);
2940 return Vw32_valid_codepages
;
2944 DEFUN ("w32-get-console-codepage", Fw32_get_console_codepage
,
2945 Sw32_get_console_codepage
, 0, 0, 0,
2946 doc
: /* Return current Windows codepage for console input. */)
2949 return make_number (GetConsoleCP ());
2953 DEFUN ("w32-set-console-codepage", Fw32_set_console_codepage
,
2954 Sw32_set_console_codepage
, 1, 1, 0,
2955 doc
: /* Make Windows codepage CP be the codepage for Emacs tty keyboard input.
2956 This codepage setting affects keyboard input in tty mode.
2957 If successful, the new CP is returned, otherwise nil. */)
2962 if (!IsValidCodePage (XINT (cp
)))
2965 if (!SetConsoleCP (XINT (cp
)))
2968 return make_number (GetConsoleCP ());
2972 DEFUN ("w32-get-console-output-codepage", Fw32_get_console_output_codepage
,
2973 Sw32_get_console_output_codepage
, 0, 0, 0,
2974 doc
: /* Return current Windows codepage for console output. */)
2977 return make_number (GetConsoleOutputCP ());
2981 DEFUN ("w32-set-console-output-codepage", Fw32_set_console_output_codepage
,
2982 Sw32_set_console_output_codepage
, 1, 1, 0,
2983 doc
: /* Make Windows codepage CP be the codepage for Emacs console output.
2984 This codepage setting affects display in tty mode.
2985 If successful, the new CP is returned, otherwise nil. */)
2990 if (!IsValidCodePage (XINT (cp
)))
2993 if (!SetConsoleOutputCP (XINT (cp
)))
2996 return make_number (GetConsoleOutputCP ());
3000 DEFUN ("w32-get-codepage-charset", Fw32_get_codepage_charset
,
3001 Sw32_get_codepage_charset
, 1, 1, 0,
3002 doc
: /* Return charset ID corresponding to codepage CP.
3003 Returns nil if the codepage is not valid. */)
3010 if (!IsValidCodePage (XINT (cp
)))
3013 if (TranslateCharsetInfo ((DWORD
*) XINT (cp
), &info
, TCI_SRCCODEPAGE
))
3014 return make_number (info
.ciCharset
);
3020 DEFUN ("w32-get-valid-keyboard-layouts", Fw32_get_valid_keyboard_layouts
,
3021 Sw32_get_valid_keyboard_layouts
, 0, 0, 0,
3022 doc
: /* Return list of Windows keyboard languages and layouts.
3023 The return value is a list of pairs of language id and layout id. */)
3026 int num_layouts
= GetKeyboardLayoutList (0, NULL
);
3027 HKL
* layouts
= (HKL
*) alloca (num_layouts
* sizeof (HKL
));
3028 Lisp_Object obj
= Qnil
;
3030 if (GetKeyboardLayoutList (num_layouts
, layouts
) == num_layouts
)
3032 while (--num_layouts
>= 0)
3034 DWORD kl
= (DWORD
) layouts
[num_layouts
];
3036 obj
= Fcons (Fcons (make_number (kl
& 0xffff),
3037 make_number ((kl
>> 16) & 0xffff)),
3046 DEFUN ("w32-get-keyboard-layout", Fw32_get_keyboard_layout
,
3047 Sw32_get_keyboard_layout
, 0, 0, 0,
3048 doc
: /* Return current Windows keyboard language and layout.
3049 The return value is the cons of the language id and the layout id. */)
3052 DWORD kl
= (DWORD
) GetKeyboardLayout (dwWindowsThreadId
);
3054 return Fcons (make_number (kl
& 0xffff),
3055 make_number ((kl
>> 16) & 0xffff));
3059 DEFUN ("w32-set-keyboard-layout", Fw32_set_keyboard_layout
,
3060 Sw32_set_keyboard_layout
, 1, 1, 0,
3061 doc
: /* Make LAYOUT be the current keyboard layout for Emacs.
3062 The keyboard layout setting affects interpretation of keyboard input.
3063 If successful, the new layout id is returned, otherwise nil. */)
3064 (Lisp_Object layout
)
3068 CHECK_CONS (layout
);
3069 CHECK_NUMBER_CAR (layout
);
3070 CHECK_NUMBER_CDR (layout
);
3072 kl
= (XINT (XCAR (layout
)) & 0xffff)
3073 | (XINT (XCDR (layout
)) << 16);
3075 /* Synchronize layout with input thread. */
3076 if (dwWindowsThreadId
)
3078 if (PostThreadMessage (dwWindowsThreadId
, WM_EMACS_SETKEYBOARDLAYOUT
,
3082 GetMessage (&msg
, NULL
, WM_EMACS_DONE
, WM_EMACS_DONE
);
3084 if (msg
.wParam
== 0)
3088 else if (!ActivateKeyboardLayout ((HKL
) kl
, 0))
3091 return Fw32_get_keyboard_layout ();
3096 syms_of_ntproc (void)
3098 DEFSYM (Qhigh
, "high");
3099 DEFSYM (Qlow
, "low");
3101 defsubr (&Sw32_has_winsock
);
3102 defsubr (&Sw32_unload_winsock
);
3104 defsubr (&Sw32_short_file_name
);
3105 defsubr (&Sw32_long_file_name
);
3106 defsubr (&Sw32_set_process_priority
);
3107 defsubr (&Sw32_get_locale_info
);
3108 defsubr (&Sw32_get_current_locale_id
);
3109 defsubr (&Sw32_get_default_locale_id
);
3110 defsubr (&Sw32_get_valid_locale_ids
);
3111 defsubr (&Sw32_set_current_locale
);
3113 defsubr (&Sw32_get_console_codepage
);
3114 defsubr (&Sw32_set_console_codepage
);
3115 defsubr (&Sw32_get_console_output_codepage
);
3116 defsubr (&Sw32_set_console_output_codepage
);
3117 defsubr (&Sw32_get_valid_codepages
);
3118 defsubr (&Sw32_get_codepage_charset
);
3120 defsubr (&Sw32_get_valid_keyboard_layouts
);
3121 defsubr (&Sw32_get_keyboard_layout
);
3122 defsubr (&Sw32_set_keyboard_layout
);
3124 DEFVAR_LISP ("w32-quote-process-args", Vw32_quote_process_args
,
3125 doc
: /* Non-nil enables quoting of process arguments to ensure correct parsing.
3126 Because Windows does not directly pass argv arrays to child processes,
3127 programs have to reconstruct the argv array by parsing the command
3128 line string. For an argument to contain a space, it must be enclosed
3129 in double quotes or it will be parsed as multiple arguments.
3131 If the value is a character, that character will be used to escape any
3132 quote characters that appear, otherwise a suitable escape character
3133 will be chosen based on the type of the program. */);
3134 Vw32_quote_process_args
= Qt
;
3136 DEFVAR_LISP ("w32-start-process-show-window",
3137 Vw32_start_process_show_window
,
3138 doc
: /* When nil, new child processes hide their windows.
3139 When non-nil, they show their window in the method of their choice.
3140 This variable doesn't affect GUI applications, which will never be hidden. */);
3141 Vw32_start_process_show_window
= Qnil
;
3143 DEFVAR_LISP ("w32-start-process-share-console",
3144 Vw32_start_process_share_console
,
3145 doc
: /* When nil, new child processes are given a new console.
3146 When non-nil, they share the Emacs console; this has the limitation of
3147 allowing only one DOS subprocess to run at a time (whether started directly
3148 or indirectly by Emacs), and preventing Emacs from cleanly terminating the
3149 subprocess group, but may allow Emacs to interrupt a subprocess that doesn't
3150 otherwise respond to interrupts from Emacs. */);
3151 Vw32_start_process_share_console
= Qnil
;
3153 DEFVAR_LISP ("w32-start-process-inherit-error-mode",
3154 Vw32_start_process_inherit_error_mode
,
3155 doc
: /* When nil, new child processes revert to the default error mode.
3156 When non-nil, they inherit their error mode setting from Emacs, which stops
3157 them blocking when trying to access unmounted drives etc. */);
3158 Vw32_start_process_inherit_error_mode
= Qt
;
3160 DEFVAR_INT ("w32-pipe-read-delay", w32_pipe_read_delay
,
3161 doc
: /* Forced delay before reading subprocess output.
3162 This is done to improve the buffering of subprocess output, by
3163 avoiding the inefficiency of frequently reading small amounts of data.
3165 If positive, the value is the number of milliseconds to sleep before
3166 reading the subprocess output. If negative, the magnitude is the number
3167 of time slices to wait (effectively boosting the priority of the child
3168 process temporarily). A value of zero disables waiting entirely. */);
3169 w32_pipe_read_delay
= 50;
3171 DEFVAR_LISP ("w32-downcase-file-names", Vw32_downcase_file_names
,
3172 doc
: /* Non-nil means convert all-upper case file names to lower case.
3173 This applies when performing completions and file name expansion.
3174 Note that the value of this setting also affects remote file names,
3175 so you probably don't want to set to non-nil if you use case-sensitive
3176 filesystems via ange-ftp. */);
3177 Vw32_downcase_file_names
= Qnil
;
3180 DEFVAR_LISP ("w32-generate-fake-inodes", Vw32_generate_fake_inodes
,
3181 doc
: /* Non-nil means attempt to fake realistic inode values.
3182 This works by hashing the truename of files, and should detect
3183 aliasing between long and short (8.3 DOS) names, but can have
3184 false positives because of hash collisions. Note that determining
3185 the truename of a file can be slow. */);
3186 Vw32_generate_fake_inodes
= Qnil
;
3189 DEFVAR_LISP ("w32-get-true-file-attributes", Vw32_get_true_file_attributes
,
3190 doc
: /* Non-nil means determine accurate file attributes in `file-attributes'.
3191 This option controls whether to issue additional system calls to determine
3192 accurate link counts, file type, and ownership information. It is more
3193 useful for files on NTFS volumes, where hard links and file security are
3194 supported, than on volumes of the FAT family.
3196 Without these system calls, link count will always be reported as 1 and file
3197 ownership will be attributed to the current user.
3198 The default value `local' means only issue these system calls for files
3199 on local fixed drives. A value of nil means never issue them.
3200 Any other non-nil value means do this even on remote and removable drives
3201 where the performance impact may be noticeable even on modern hardware. */);
3202 Vw32_get_true_file_attributes
= Qlocal
;
3204 staticpro (&Vw32_valid_locale_ids
);
3205 staticpro (&Vw32_valid_codepages
);
3207 /* end of w32proc.c */