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
24 #include <mingw_time.h>
34 /* must include CRT headers *before* config.h */
45 /* This definition is missing from mingw32 headers. */
46 extern BOOL WINAPI
IsValidLocale (LCID
, DWORD
);
49 #ifdef HAVE_LANGINFO_CODESET
56 #include "w32common.h"
61 #include "syssignal.h"
63 #include "dispextern.h" /* for xstrcasecmp */
66 #define RVA_TO_PTR(var,section,filedata) \
67 ((void *)((section)->PointerToRawData \
68 + ((DWORD_PTR)(var) - (section)->VirtualAddress) \
69 + (filedata).file_base))
71 Lisp_Object Qhigh
, Qlow
;
73 /* Signal handlers...SIG_DFL == 0 so this is initialized correctly. */
74 static signal_handler sig_handlers
[NSIG
];
76 static sigset_t sig_mask
;
78 static CRITICAL_SECTION crit_sig
;
80 /* Improve on the CRT 'signal' implementation so that we could record
81 the SIGCHLD handler and fake interval timers. */
83 sys_signal (int sig
, signal_handler handler
)
87 /* SIGCHLD is needed for supporting subprocesses, see sys_kill
88 below. SIGALRM and SIGPROF are used by setitimer. All the
89 others are the only ones supported by the MS runtime. */
90 if (!(sig
== SIGCHLD
|| sig
== SIGSEGV
|| sig
== SIGILL
91 || sig
== SIGFPE
|| sig
== SIGABRT
|| sig
== SIGTERM
92 || sig
== SIGALRM
|| sig
== SIGPROF
))
97 old
= sig_handlers
[sig
];
98 /* SIGABRT is treated specially because w32.c installs term_ntproc
99 as its handler, so we don't want to override that afterwards.
100 Aborting Emacs works specially anyway: either by calling
101 emacs_abort directly or through terminate_due_to_signal, which
102 calls emacs_abort through emacs_raise. */
103 if (!(sig
== SIGABRT
&& old
== term_ntproc
))
105 sig_handlers
[sig
] = handler
;
106 if (!(sig
== SIGCHLD
|| sig
== SIGALRM
|| sig
== SIGPROF
))
107 signal (sig
, handler
);
112 /* Emulate sigaction. */
114 sigaction (int sig
, const struct sigaction
*act
, struct sigaction
*oact
)
116 signal_handler old
= SIG_DFL
;
120 old
= sys_signal (sig
, act
->sa_handler
);
122 old
= sig_handlers
[sig
];
131 oact
->sa_handler
= old
;
133 oact
->sa_mask
= empty_mask
;
138 /* Emulate signal sets and blocking of signals used by timers. */
141 sigemptyset (sigset_t
*set
)
148 sigaddset (sigset_t
*set
, int signo
)
155 if (signo
< 0 || signo
>= NSIG
)
161 *set
|= (1U << signo
);
167 sigfillset (sigset_t
*set
)
180 sigprocmask (int how
, const sigset_t
*set
, sigset_t
*oset
)
182 if (!(how
== SIG_BLOCK
|| how
== SIG_UNBLOCK
|| how
== SIG_SETMASK
))
203 /* FIXME: Catch signals that are blocked and reissue them when
204 they are unblocked. Important for SIGALRM and SIGPROF only. */
213 pthread_sigmask (int how
, const sigset_t
*set
, sigset_t
*oset
)
215 if (sigprocmask (how
, set
, oset
) == -1)
221 sigismember (const sigset_t
*set
, int signo
)
223 if (signo
< 0 || signo
>= NSIG
)
228 if (signo
> sizeof (*set
) * BITS_PER_CHAR
)
231 return (*set
& (1U << signo
)) != 0;
247 setpgid (pid_t pid
, pid_t pgid
)
258 /* Emulations of interval timers.
260 Limitations: only ITIMER_REAL and ITIMER_PROF are supported.
262 Implementation: a separate thread is started for each timer type,
263 the thread calls the appropriate signal handler when the timer
264 expires, after stopping the thread which installed the timer. */
267 volatile ULONGLONG expire
;
268 volatile ULONGLONG reload
;
269 volatile int terminate
;
271 HANDLE caller_thread
;
275 static ULONGLONG ticks_now
;
276 static struct itimer_data real_itimer
, prof_itimer
;
277 static ULONGLONG clocks_min
;
278 /* If non-zero, itimers are disabled. Used during shutdown, when we
279 delete the critical sections used by the timer threads. */
280 static int disable_itimers
;
282 static CRITICAL_SECTION crit_real
, crit_prof
;
284 /* GetThreadTimes is not available on Windows 9X and possibly also on 2K. */
285 typedef BOOL (WINAPI
*GetThreadTimes_Proc
) (
287 LPFILETIME lpCreationTime
,
288 LPFILETIME lpExitTime
,
289 LPFILETIME lpKernelTime
,
290 LPFILETIME lpUserTime
);
292 static GetThreadTimes_Proc s_pfn_Get_Thread_Times
;
294 #define MAX_SINGLE_SLEEP 30
295 #define TIMER_TICKS_PER_SEC 1000
297 /* Return a suitable time value, in 1-ms units, for THREAD, a handle
298 to a thread. If THREAD is NULL or an invalid handle, return the
299 current wall-clock time since January 1, 1601 (UTC). Otherwise,
300 return the sum of kernel and user times used by THREAD since it was
301 created, plus its creation time. */
303 w32_get_timer_time (HANDLE thread
)
306 int use_system_time
= 1;
307 /* The functions below return times in 100-ns units. */
308 const int tscale
= 10 * TIMER_TICKS_PER_SEC
;
310 if (thread
&& thread
!= INVALID_HANDLE_VALUE
311 && s_pfn_Get_Thread_Times
!= NULL
)
313 FILETIME creation_ftime
, exit_ftime
, kernel_ftime
, user_ftime
;
314 ULARGE_INTEGER temp_creation
, temp_kernel
, temp_user
;
316 if (s_pfn_Get_Thread_Times (thread
, &creation_ftime
, &exit_ftime
,
317 &kernel_ftime
, &user_ftime
))
320 temp_creation
.LowPart
= creation_ftime
.dwLowDateTime
;
321 temp_creation
.HighPart
= creation_ftime
.dwHighDateTime
;
322 temp_kernel
.LowPart
= kernel_ftime
.dwLowDateTime
;
323 temp_kernel
.HighPart
= kernel_ftime
.dwHighDateTime
;
324 temp_user
.LowPart
= user_ftime
.dwLowDateTime
;
325 temp_user
.HighPart
= user_ftime
.dwHighDateTime
;
327 temp_creation
.QuadPart
/ tscale
+ temp_kernel
.QuadPart
/ tscale
328 + temp_user
.QuadPart
/ tscale
;
331 DebPrint (("GetThreadTimes failed with error code %lu\n",
337 FILETIME current_ftime
;
340 GetSystemTimeAsFileTime (¤t_ftime
);
342 temp
.LowPart
= current_ftime
.dwLowDateTime
;
343 temp
.HighPart
= current_ftime
.dwHighDateTime
;
345 retval
= temp
.QuadPart
/ tscale
;
351 /* Thread function for a timer thread. */
353 timer_loop (LPVOID arg
)
355 struct itimer_data
*itimer
= (struct itimer_data
*)arg
;
356 int which
= itimer
->type
;
357 int sig
= (which
== ITIMER_REAL
) ? SIGALRM
: SIGPROF
;
358 CRITICAL_SECTION
*crit
= (which
== ITIMER_REAL
) ? &crit_real
: &crit_prof
;
359 const DWORD max_sleep
= MAX_SINGLE_SLEEP
* 1000 / TIMER_TICKS_PER_SEC
;
360 HANDLE hth
= (which
== ITIMER_REAL
) ? NULL
: itimer
->caller_thread
;
365 signal_handler handler
;
366 ULONGLONG now
, expire
, reload
;
368 /* Load new values if requested by setitimer. */
369 EnterCriticalSection (crit
);
370 expire
= itimer
->expire
;
371 reload
= itimer
->reload
;
372 LeaveCriticalSection (crit
);
373 if (itimer
->terminate
)
383 if (expire
> (now
= w32_get_timer_time (hth
)))
384 sleep_time
= expire
- now
;
387 /* Don't sleep too long at a time, to be able to see the
388 termination flag without too long a delay. */
389 while (sleep_time
> max_sleep
)
391 if (itimer
->terminate
)
394 EnterCriticalSection (crit
);
395 expire
= itimer
->expire
;
396 LeaveCriticalSection (crit
);
398 (expire
> (now
= w32_get_timer_time (hth
))) ? expire
- now
: 0;
400 if (itimer
->terminate
)
404 Sleep (sleep_time
* 1000 / TIMER_TICKS_PER_SEC
);
405 /* Always sleep past the expiration time, to make sure we
406 never call the handler _before_ the expiration time,
407 always slightly after it. Sleep(5) makes sure we don't
408 hog the CPU by calling 'w32_get_timer_time' with high
409 frequency, and also let other threads work. */
410 while (w32_get_timer_time (hth
) < expire
)
414 EnterCriticalSection (crit
);
415 expire
= itimer
->expire
;
416 LeaveCriticalSection (crit
);
421 handler
= sig_handlers
[sig
];
422 if (!(handler
== SIG_DFL
|| handler
== SIG_IGN
|| handler
== SIG_ERR
)
423 /* FIXME: Don't ignore masked signals. Instead, record that
424 they happened and reissue them when the signal is
426 && !sigismember (&sig_mask
, sig
)
427 /* Simulate masking of SIGALRM and SIGPROF when processing
429 && !fatal_error_in_progress
430 && itimer
->caller_thread
)
432 /* Simulate a signal delivered to the thread which installed
433 the timer, by suspending that thread while the handler
435 HANDLE th
= itimer
->caller_thread
;
436 DWORD result
= SuspendThread (th
);
438 if (result
== (DWORD
)-1)
445 /* Update expiration time and loop. */
446 EnterCriticalSection (crit
);
447 expire
= itimer
->expire
;
450 LeaveCriticalSection (crit
);
453 reload
= itimer
->reload
;
456 now
= w32_get_timer_time (hth
);
459 ULONGLONG lag
= now
- expire
;
461 /* If we missed some opportunities (presumably while
462 sleeping or while the signal handler ran), skip
465 expire
= now
- (lag
% reload
);
471 expire
= 0; /* become idle */
472 itimer
->expire
= expire
;
473 LeaveCriticalSection (crit
);
479 stop_timer_thread (int which
)
481 struct itimer_data
*itimer
=
482 (which
== ITIMER_REAL
) ? &real_itimer
: &prof_itimer
;
484 DWORD err
, exit_code
= 255;
487 /* Signal the thread that it should terminate. */
488 itimer
->terminate
= 1;
490 if (itimer
->timer_thread
== NULL
)
493 /* Wait for the timer thread to terminate voluntarily, then kill it
494 if it doesn't. This loop waits twice more than the maximum
495 amount of time a timer thread sleeps, see above. */
496 for (i
= 0; i
< MAX_SINGLE_SLEEP
/ 5; i
++)
498 if (!((status
= GetExitCodeThread (itimer
->timer_thread
, &exit_code
))
499 && exit_code
== STILL_ACTIVE
))
503 if ((status
== FALSE
&& (err
= GetLastError ()) == ERROR_INVALID_HANDLE
)
504 || exit_code
== STILL_ACTIVE
)
506 if (!(status
== FALSE
&& err
== ERROR_INVALID_HANDLE
))
507 TerminateThread (itimer
->timer_thread
, 0);
511 CloseHandle (itimer
->timer_thread
);
512 itimer
->timer_thread
= NULL
;
513 if (itimer
->caller_thread
)
515 CloseHandle (itimer
->caller_thread
);
516 itimer
->caller_thread
= NULL
;
520 /* This is called at shutdown time from term_ntproc. */
524 if (real_itimer
.timer_thread
)
525 stop_timer_thread (ITIMER_REAL
);
526 if (prof_itimer
.timer_thread
)
527 stop_timer_thread (ITIMER_PROF
);
529 /* We are going to delete the critical sections, so timers cannot
533 DeleteCriticalSection (&crit_real
);
534 DeleteCriticalSection (&crit_prof
);
535 DeleteCriticalSection (&crit_sig
);
538 /* This is called at initialization time from init_ntproc. */
542 /* GetThreadTimes is not available on all versions of Windows, so
543 need to probe for its availability dynamically, and call it
544 through a pointer. */
545 s_pfn_Get_Thread_Times
= NULL
; /* in case dumped Emacs comes with a value */
546 if (os_subtype
!= OS_9X
)
547 s_pfn_Get_Thread_Times
=
548 (GetThreadTimes_Proc
)GetProcAddress (GetModuleHandle ("kernel32.dll"),
551 /* Make sure we start with zeroed out itimer structures, since
552 dumping may have left there traces of threads long dead. */
553 memset (&real_itimer
, 0, sizeof real_itimer
);
554 memset (&prof_itimer
, 0, sizeof prof_itimer
);
556 InitializeCriticalSection (&crit_real
);
557 InitializeCriticalSection (&crit_prof
);
558 InitializeCriticalSection (&crit_sig
);
564 start_timer_thread (int which
)
568 struct itimer_data
*itimer
=
569 (which
== ITIMER_REAL
) ? &real_itimer
: &prof_itimer
;
571 if (itimer
->timer_thread
572 && GetExitCodeThread (itimer
->timer_thread
, &exit_code
)
573 && exit_code
== STILL_ACTIVE
)
576 /* Clean up after possibly exited thread. */
577 if (itimer
->timer_thread
)
579 CloseHandle (itimer
->timer_thread
);
580 itimer
->timer_thread
= NULL
;
582 if (itimer
->caller_thread
)
584 CloseHandle (itimer
->caller_thread
);
585 itimer
->caller_thread
= NULL
;
588 /* Start a new thread. */
589 if (!DuplicateHandle (GetCurrentProcess (), GetCurrentThread (),
590 GetCurrentProcess (), &th
, 0, FALSE
,
591 DUPLICATE_SAME_ACCESS
))
596 itimer
->terminate
= 0;
597 itimer
->type
= which
;
598 itimer
->caller_thread
= th
;
599 /* Request that no more than 64KB of stack be reserved for this
600 thread, to avoid reserving too much memory, which would get in
601 the way of threads we start to wait for subprocesses. See also
603 itimer
->timer_thread
= CreateThread (NULL
, 64 * 1024, timer_loop
,
604 (void *)itimer
, 0x00010000, NULL
);
606 if (!itimer
->timer_thread
)
608 CloseHandle (itimer
->caller_thread
);
609 itimer
->caller_thread
= NULL
;
614 /* This is needed to make sure that the timer thread running for
615 profiling gets CPU as soon as the Sleep call terminates. */
616 if (which
== ITIMER_PROF
)
617 SetThreadPriority (itimer
->timer_thread
, THREAD_PRIORITY_TIME_CRITICAL
);
622 /* Most of the code of getitimer and setitimer (but not of their
623 subroutines) was shamelessly stolen from itimer.c in the DJGPP
624 library, see www.delorie.com/djgpp. */
626 getitimer (int which
, struct itimerval
*value
)
628 volatile ULONGLONG
*t_expire
;
629 volatile ULONGLONG
*t_reload
;
630 ULONGLONG expire
, reload
;
632 CRITICAL_SECTION
*crit
;
633 struct itimer_data
*itimer
;
644 if (which
!= ITIMER_REAL
&& which
!= ITIMER_PROF
)
650 itimer
= (which
== ITIMER_REAL
) ? &real_itimer
: &prof_itimer
;
652 ticks_now
= w32_get_timer_time ((which
== ITIMER_REAL
)
654 : GetCurrentThread ());
656 t_expire
= &itimer
->expire
;
657 t_reload
= &itimer
->reload
;
658 crit
= (which
== ITIMER_REAL
) ? &crit_real
: &crit_prof
;
660 EnterCriticalSection (crit
);
663 LeaveCriticalSection (crit
);
668 value
->it_value
.tv_sec
= expire
/ TIMER_TICKS_PER_SEC
;
670 (expire
% TIMER_TICKS_PER_SEC
) * (__int64
)1000000 / TIMER_TICKS_PER_SEC
;
671 value
->it_value
.tv_usec
= usecs
;
672 value
->it_interval
.tv_sec
= reload
/ TIMER_TICKS_PER_SEC
;
674 (reload
% TIMER_TICKS_PER_SEC
) * (__int64
)1000000 / TIMER_TICKS_PER_SEC
;
675 value
->it_interval
.tv_usec
= usecs
;
681 setitimer(int which
, struct itimerval
*value
, struct itimerval
*ovalue
)
683 volatile ULONGLONG
*t_expire
, *t_reload
;
684 ULONGLONG expire
, reload
, expire_old
, reload_old
;
686 CRITICAL_SECTION
*crit
;
687 struct itimerval tem
, *ptem
;
692 /* Posix systems expect timer values smaller than the resolution of
693 the system clock be rounded up to the clock resolution. First
694 time we are called, measure the clock tick resolution. */
699 for (t1
= w32_get_timer_time (NULL
);
700 (t2
= w32_get_timer_time (NULL
)) == t1
; )
702 clocks_min
= t2
- t1
;
710 if (getitimer (which
, ptem
)) /* also sets ticks_now */
711 return -1; /* errno already set */
714 (which
== ITIMER_REAL
) ? &real_itimer
.expire
: &prof_itimer
.expire
;
716 (which
== ITIMER_REAL
) ? &real_itimer
.reload
: &prof_itimer
.reload
;
718 crit
= (which
== ITIMER_REAL
) ? &crit_real
: &crit_prof
;
721 || (value
->it_value
.tv_sec
== 0 && value
->it_value
.tv_usec
== 0))
723 EnterCriticalSection (crit
);
724 /* Disable the timer. */
727 LeaveCriticalSection (crit
);
731 reload
= value
->it_interval
.tv_sec
* TIMER_TICKS_PER_SEC
;
733 usecs
= value
->it_interval
.tv_usec
;
734 if (value
->it_interval
.tv_sec
== 0
735 && usecs
&& usecs
* TIMER_TICKS_PER_SEC
< clocks_min
* 1000000)
739 usecs
*= TIMER_TICKS_PER_SEC
;
740 reload
+= usecs
/ 1000000;
743 expire
= value
->it_value
.tv_sec
* TIMER_TICKS_PER_SEC
;
744 usecs
= value
->it_value
.tv_usec
;
745 if (value
->it_value
.tv_sec
== 0
746 && usecs
* TIMER_TICKS_PER_SEC
< clocks_min
* 1000000)
750 usecs
*= TIMER_TICKS_PER_SEC
;
751 expire
+= usecs
/ 1000000;
756 EnterCriticalSection (crit
);
757 expire_old
= *t_expire
;
758 reload_old
= *t_reload
;
759 if (!(expire
== expire_old
&& reload
== reload_old
))
764 LeaveCriticalSection (crit
);
766 return start_timer_thread (which
);
772 #ifdef HAVE_SETITIMER
773 struct itimerval new_values
, old_values
;
775 new_values
.it_value
.tv_sec
= seconds
;
776 new_values
.it_value
.tv_usec
= 0;
777 new_values
.it_interval
.tv_sec
= new_values
.it_interval
.tv_usec
= 0;
779 if (setitimer (ITIMER_REAL
, &new_values
, &old_values
) < 0)
781 return old_values
.it_value
.tv_sec
;
787 /* Defined in <process.h> which conflicts with the local copy */
790 /* Child process management list. */
791 int child_proc_count
= 0;
792 child_process child_procs
[ MAX_CHILDREN
];
794 static DWORD WINAPI
reader_thread (void *arg
);
796 /* Find an unused process slot. */
803 for (cp
= child_procs
+ (child_proc_count
-1); cp
>= child_procs
; cp
--)
804 if (!CHILD_ACTIVE (cp
) && cp
->procinfo
.hProcess
== NULL
)
806 if (child_proc_count
== MAX_CHILDREN
)
809 child_process
*dead_cp
= NULL
;
811 DebPrint (("new_child: No vacant slots, looking for dead processes\n"));
812 for (cp
= child_procs
+ (child_proc_count
-1); cp
>= child_procs
; cp
--)
813 if (!CHILD_ACTIVE (cp
) && cp
->procinfo
.hProcess
)
817 if (!GetExitCodeProcess (cp
->procinfo
.hProcess
, &status
))
819 DebPrint (("new_child.GetExitCodeProcess: error %lu for PID %lu\n",
820 GetLastError (), cp
->procinfo
.dwProcessId
));
821 status
= STILL_ACTIVE
;
823 if (status
!= STILL_ACTIVE
824 || WaitForSingleObject (cp
->procinfo
.hProcess
, 0) == WAIT_OBJECT_0
)
826 DebPrint (("new_child: Freeing slot of dead process %d, fd %d\n",
827 cp
->procinfo
.dwProcessId
, cp
->fd
));
828 CloseHandle (cp
->procinfo
.hProcess
);
829 cp
->procinfo
.hProcess
= NULL
;
830 CloseHandle (cp
->procinfo
.hThread
);
831 cp
->procinfo
.hThread
= NULL
;
832 /* Free up to 2 dead slots at a time, so that if we
833 have a lot of them, they will eventually all be
834 freed when the tornado ends. */
848 if (child_proc_count
== MAX_CHILDREN
)
850 cp
= &child_procs
[child_proc_count
++];
853 /* Last opportunity to avoid leaking handles before we forget them
855 if (cp
->procinfo
.hProcess
)
856 CloseHandle (cp
->procinfo
.hProcess
);
857 if (cp
->procinfo
.hThread
)
858 CloseHandle (cp
->procinfo
.hThread
);
859 memset (cp
, 0, sizeof (*cp
));
862 cp
->procinfo
.hProcess
= NULL
;
863 cp
->status
= STATUS_READ_ERROR
;
865 /* use manual reset event so that select() will function properly */
866 cp
->char_avail
= CreateEvent (NULL
, TRUE
, FALSE
, NULL
);
869 cp
->char_consumed
= CreateEvent (NULL
, FALSE
, FALSE
, NULL
);
870 if (cp
->char_consumed
)
872 /* The 0x00010000 flag is STACK_SIZE_PARAM_IS_A_RESERVATION.
873 It means that the 64K stack we are requesting in the 2nd
874 argument is how much memory should be reserved for the
875 stack. If we don't use this flag, the memory requested
876 by the 2nd argument is the amount actually _committed_,
877 but Windows reserves 8MB of memory for each thread's
878 stack. (The 8MB figure comes from the -stack
879 command-line argument we pass to the linker when building
880 Emacs, but that's because we need a large stack for
881 Emacs's main thread.) Since we request 2GB of reserved
882 memory at startup (see w32heap.c), which is close to the
883 maximum memory available for a 32-bit process on Windows,
884 the 8MB reservation for each thread causes failures in
885 starting subprocesses, because we create a thread running
886 reader_thread for each subprocess. As 8MB of stack is
887 way too much for reader_thread, forcing Windows to
888 reserve less wins the day. */
889 cp
->thrd
= CreateThread (NULL
, 64 * 1024, reader_thread
, cp
,
900 delete_child (child_process
*cp
)
904 /* Should not be deleting a child that is still needed. */
905 for (i
= 0; i
< MAXDESC
; i
++)
906 if (fd_info
[i
].cp
== cp
)
909 if (!CHILD_ACTIVE (cp
) && cp
->procinfo
.hProcess
== NULL
)
912 /* reap thread if necessary */
917 if (GetExitCodeThread (cp
->thrd
, &rc
) && rc
== STILL_ACTIVE
)
919 /* let the thread exit cleanly if possible */
920 cp
->status
= STATUS_READ_ERROR
;
921 SetEvent (cp
->char_consumed
);
923 /* We used to forcibly terminate the thread here, but it
924 is normally unnecessary, and in abnormal cases, the worst that
925 will happen is we have an extra idle thread hanging around
926 waiting for the zombie process. */
927 if (WaitForSingleObject (cp
->thrd
, 1000) != WAIT_OBJECT_0
)
929 DebPrint (("delete_child.WaitForSingleObject (thread) failed "
930 "with %lu for fd %ld\n", GetLastError (), cp
->fd
));
931 TerminateThread (cp
->thrd
, 0);
935 CloseHandle (cp
->thrd
);
940 CloseHandle (cp
->char_avail
);
941 cp
->char_avail
= NULL
;
943 if (cp
->char_consumed
)
945 CloseHandle (cp
->char_consumed
);
946 cp
->char_consumed
= NULL
;
949 /* update child_proc_count (highest numbered slot in use plus one) */
950 if (cp
== child_procs
+ child_proc_count
- 1)
952 for (i
= child_proc_count
-1; i
>= 0; i
--)
953 if (CHILD_ACTIVE (&child_procs
[i
])
954 || child_procs
[i
].procinfo
.hProcess
!= NULL
)
956 child_proc_count
= i
+ 1;
961 child_proc_count
= 0;
964 /* Find a child by pid. */
965 static child_process
*
966 find_child_pid (DWORD pid
)
970 for (cp
= child_procs
+ (child_proc_count
-1); cp
>= child_procs
; cp
--)
971 if ((CHILD_ACTIVE (cp
) || cp
->procinfo
.hProcess
!= NULL
)
978 release_listen_threads (void)
982 for (i
= child_proc_count
- 1; i
>= 0; i
--)
984 if (CHILD_ACTIVE (&child_procs
[i
])
985 && (fd_info
[child_procs
[i
].fd
].flags
& FILE_LISTEN
))
986 child_procs
[i
].status
= STATUS_READ_ERROR
;
990 /* Thread proc for child process and socket reader threads. Each thread
991 is normally blocked until woken by select() to check for input by
992 reading one char. When the read completes, char_avail is signaled
993 to wake up the select emulator and the thread blocks itself again. */
995 reader_thread (void *arg
)
1000 cp
= (child_process
*)arg
;
1002 /* We have to wait for the go-ahead before we can start */
1004 || WaitForSingleObject (cp
->char_consumed
, INFINITE
) != WAIT_OBJECT_0
1012 if (cp
->fd
>= 0 && fd_info
[cp
->fd
].flags
& FILE_LISTEN
)
1013 rc
= _sys_wait_accept (cp
->fd
);
1015 rc
= _sys_read_ahead (cp
->fd
);
1017 /* Don't bother waiting for the event if we already have been
1018 told to exit by delete_child. */
1019 if (cp
->status
== STATUS_READ_ERROR
|| !cp
->char_avail
)
1022 /* The name char_avail is a misnomer - it really just means the
1023 read-ahead has completed, whether successfully or not. */
1024 if (!SetEvent (cp
->char_avail
))
1026 DebPrint (("reader_thread.SetEvent(0x%x) failed with %lu for fd %ld (PID %d)\n",
1027 (DWORD_PTR
)cp
->char_avail
, GetLastError (),
1032 if (rc
== STATUS_READ_ERROR
)
1035 /* If the read died, the child has died so let the thread die */
1036 if (rc
== STATUS_READ_FAILED
)
1039 /* Don't bother waiting for the acknowledge if we already have
1040 been told to exit by delete_child. */
1041 if (cp
->status
== STATUS_READ_ERROR
|| !cp
->char_consumed
)
1044 /* Wait until our input is acknowledged before reading again */
1045 if (WaitForSingleObject (cp
->char_consumed
, INFINITE
) != WAIT_OBJECT_0
)
1047 DebPrint (("reader_thread.WaitForSingleObject failed with "
1048 "%lu for fd %ld\n", GetLastError (), cp
->fd
));
1051 /* delete_child sets status to STATUS_READ_ERROR when it wants
1053 if (cp
->status
== STATUS_READ_ERROR
)
1059 /* To avoid Emacs changing directory, we just record here the directory
1060 the new process should start in. This is set just before calling
1061 sys_spawnve, and is not generally valid at any other time. */
1062 static char * process_dir
;
1065 create_child (char *exe
, char *cmdline
, char *env
, int is_gui_app
,
1066 int * pPid
, child_process
*cp
)
1069 SECURITY_ATTRIBUTES sec_attrs
;
1071 SECURITY_DESCRIPTOR sec_desc
;
1074 char dir
[ MAXPATHLEN
];
1076 if (cp
== NULL
) emacs_abort ();
1078 memset (&start
, 0, sizeof (start
));
1079 start
.cb
= sizeof (start
);
1082 if (NILP (Vw32_start_process_show_window
) && !is_gui_app
)
1083 start
.dwFlags
= STARTF_USESTDHANDLES
| STARTF_USESHOWWINDOW
;
1085 start
.dwFlags
= STARTF_USESTDHANDLES
;
1086 start
.wShowWindow
= SW_HIDE
;
1088 start
.hStdInput
= GetStdHandle (STD_INPUT_HANDLE
);
1089 start
.hStdOutput
= GetStdHandle (STD_OUTPUT_HANDLE
);
1090 start
.hStdError
= GetStdHandle (STD_ERROR_HANDLE
);
1091 #endif /* HAVE_NTGUI */
1094 /* Explicitly specify no security */
1095 if (!InitializeSecurityDescriptor (&sec_desc
, SECURITY_DESCRIPTOR_REVISION
))
1097 if (!SetSecurityDescriptorDacl (&sec_desc
, TRUE
, NULL
, FALSE
))
1100 sec_attrs
.nLength
= sizeof (sec_attrs
);
1101 sec_attrs
.lpSecurityDescriptor
= NULL
/* &sec_desc */;
1102 sec_attrs
.bInheritHandle
= FALSE
;
1104 strcpy (dir
, process_dir
);
1105 unixtodos_filename (dir
);
1107 flags
= (!NILP (Vw32_start_process_share_console
)
1108 ? CREATE_NEW_PROCESS_GROUP
1109 : CREATE_NEW_CONSOLE
);
1110 if (NILP (Vw32_start_process_inherit_error_mode
))
1111 flags
|= CREATE_DEFAULT_ERROR_MODE
;
1112 if (!CreateProcess (exe
, cmdline
, &sec_attrs
, NULL
, TRUE
,
1113 flags
, env
, dir
, &start
, &cp
->procinfo
))
1116 cp
->pid
= (int) cp
->procinfo
.dwProcessId
;
1118 /* Hack for Windows 95, which assigns large (ie negative) pids */
1127 DebPrint (("create_child.CreateProcess failed: %ld\n", GetLastError ()););
1131 /* create_child doesn't know what emacs's file handle will be for waiting
1132 on output from the child, so we need to make this additional call
1133 to register the handle with the process
1134 This way the select emulator knows how to match file handles with
1135 entries in child_procs. */
1137 register_child (pid_t pid
, int fd
)
1141 cp
= find_child_pid ((DWORD
)pid
);
1144 DebPrint (("register_child unable to find pid %lu\n", pid
));
1149 DebPrint (("register_child registered fd %d with pid %lu\n", fd
, pid
));
1154 /* thread is initially blocked until select is called; set status so
1155 that select will release thread */
1156 cp
->status
= STATUS_READ_ACKNOWLEDGED
;
1158 /* attach child_process to fd_info */
1159 if (fd_info
[fd
].cp
!= NULL
)
1161 DebPrint (("register_child: fd_info[%d] apparently in use!\n", fd
));
1165 fd_info
[fd
].cp
= cp
;
1168 /* Called from waitpid when a process exits. */
1170 reap_subprocess (child_process
*cp
)
1172 if (cp
->procinfo
.hProcess
)
1174 /* Reap the process */
1176 /* Process should have already died before we are called. */
1177 if (WaitForSingleObject (cp
->procinfo
.hProcess
, 0) != WAIT_OBJECT_0
)
1178 DebPrint (("reap_subprocess: child for fd %d has not died yet!", cp
->fd
));
1180 CloseHandle (cp
->procinfo
.hProcess
);
1181 cp
->procinfo
.hProcess
= NULL
;
1182 CloseHandle (cp
->procinfo
.hThread
);
1183 cp
->procinfo
.hThread
= NULL
;
1186 /* If cp->fd was not closed yet, we might be still reading the
1187 process output, so don't free its resources just yet. The call
1188 to delete_child on behalf of this subprocess will be made by
1189 sys_read when the subprocess output is fully read. */
1194 /* Wait for a child process specified by PID, or for any of our
1195 existing child processes (if PID is nonpositive) to die. When it
1196 does, close its handle. Return the pid of the process that died
1197 and fill in STATUS if non-NULL. */
1200 waitpid (pid_t pid
, int *status
, int options
)
1202 DWORD active
, retval
;
1204 child_process
*cp
, *cps
[MAX_CHILDREN
];
1205 HANDLE wait_hnd
[MAX_CHILDREN
];
1207 int dont_wait
= (options
& WNOHANG
) != 0;
1210 /* According to Posix:
1212 PID = -1 means status is requested for any child process.
1214 PID > 0 means status is requested for a single child process
1217 PID = 0 means status is requested for any child process whose
1218 process group ID is equal to that of the calling process. But
1219 since Windows has only a limited support for process groups (only
1220 for console processes and only for the purposes of passing
1221 Ctrl-BREAK signal to them), and since we have no documented way
1222 of determining whether a given process belongs to our group, we
1225 PID < -1 means status is requested for any child process whose
1226 process group ID is equal to the absolute value of PID. Again,
1227 since we don't support process groups, we treat that as -1. */
1232 /* We are requested to wait for a specific child. */
1233 for (cp
= child_procs
+ (child_proc_count
-1); cp
>= child_procs
; cp
--)
1235 /* Some child_procs might be sockets; ignore them. Also
1236 ignore subprocesses whose output is not yet completely
1238 if (CHILD_ACTIVE (cp
)
1239 && cp
->procinfo
.hProcess
1248 if (cp
->fd
< 0 || (fd_info
[cp
->fd
].flags
& FILE_AT_EOF
) != 0)
1250 wait_hnd
[nh
] = cp
->procinfo
.hProcess
;
1256 /* PID specifies our subprocess, but its status is not
1263 /* No such child process, or nothing to wait for, so fail. */
1270 for (cp
= child_procs
+ (child_proc_count
-1); cp
>= child_procs
; cp
--)
1272 if (CHILD_ACTIVE (cp
)
1273 && cp
->procinfo
.hProcess
1274 && (cp
->fd
< 0 || (fd_info
[cp
->fd
].flags
& FILE_AT_EOF
) != 0))
1276 wait_hnd
[nh
] = cp
->procinfo
.hProcess
;
1283 /* Nothing to wait on, so fail. */
1292 timeout_ms
= 1000; /* check for quit about once a second. */
1297 active
= WaitForMultipleObjects (nh
, wait_hnd
, FALSE
, timeout_ms
);
1298 } while (active
== WAIT_TIMEOUT
&& !dont_wait
);
1300 if (active
== WAIT_FAILED
)
1305 else if (active
== WAIT_TIMEOUT
&& dont_wait
)
1307 /* PID specifies our subprocess, but it didn't exit yet, so its
1308 status is not yet available. */
1310 DebPrint (("Wait: PID %d not reap yet\n", cp
->pid
));
1314 else if (active
>= WAIT_OBJECT_0
1315 && active
< WAIT_OBJECT_0
+MAXIMUM_WAIT_OBJECTS
)
1317 active
-= WAIT_OBJECT_0
;
1319 else if (active
>= WAIT_ABANDONED_0
1320 && active
< WAIT_ABANDONED_0
+MAXIMUM_WAIT_OBJECTS
)
1322 active
-= WAIT_ABANDONED_0
;
1327 if (!GetExitCodeProcess (wait_hnd
[active
], &retval
))
1329 DebPrint (("Wait.GetExitCodeProcess failed with %lu\n",
1333 if (retval
== STILL_ACTIVE
)
1335 /* Should never happen. */
1336 DebPrint (("Wait.WaitForMultipleObjects returned an active process\n"));
1337 if (pid
> 0 && dont_wait
)
1343 /* Massage the exit code from the process to match the format expected
1344 by the WIFSTOPPED et al macros in syswait.h. Only WIFSIGNALED and
1345 WIFEXITED are supported; WIFSTOPPED doesn't make sense under NT. */
1347 if (retval
== STATUS_CONTROL_C_EXIT
)
1352 if (pid
> 0 && active
!= 0)
1357 DebPrint (("Wait signaled with process pid %d\n", cp
->pid
));
1362 reap_subprocess (cp
);
1367 /* Old versions of w32api headers don't have separate 32-bit and
1368 64-bit defines, but the one they have matches the 32-bit variety. */
1369 #ifndef IMAGE_NT_OPTIONAL_HDR32_MAGIC
1370 # define IMAGE_NT_OPTIONAL_HDR32_MAGIC IMAGE_NT_OPTIONAL_HDR_MAGIC
1371 # define IMAGE_OPTIONAL_HEADER32 IMAGE_OPTIONAL_HEADER
1375 w32_executable_type (char * filename
,
1377 int * is_cygnus_app
,
1380 file_data executable
;
1383 /* Default values in case we can't tell for sure. */
1384 *is_dos_app
= FALSE
;
1385 *is_cygnus_app
= FALSE
;
1386 *is_gui_app
= FALSE
;
1388 if (!open_input_file (&executable
, filename
))
1391 p
= strrchr (filename
, '.');
1393 /* We can only identify DOS .com programs from the extension. */
1394 if (p
&& xstrcasecmp (p
, ".com") == 0)
1396 else if (p
&& (xstrcasecmp (p
, ".bat") == 0
1397 || xstrcasecmp (p
, ".cmd") == 0))
1399 /* A DOS shell script - it appears that CreateProcess is happy to
1400 accept this (somewhat surprisingly); presumably it looks at
1401 COMSPEC to determine what executable to actually invoke.
1402 Therefore, we have to do the same here as well. */
1403 /* Actually, I think it uses the program association for that
1404 extension, which is defined in the registry. */
1405 p
= egetenv ("COMSPEC");
1407 w32_executable_type (p
, is_dos_app
, is_cygnus_app
, is_gui_app
);
1411 /* Look for DOS .exe signature - if found, we must also check that
1412 it isn't really a 16- or 32-bit Windows exe, since both formats
1413 start with a DOS program stub. Note that 16-bit Windows
1414 executables use the OS/2 1.x format. */
1416 IMAGE_DOS_HEADER
* dos_header
;
1417 IMAGE_NT_HEADERS
* nt_header
;
1419 dos_header
= (PIMAGE_DOS_HEADER
) executable
.file_base
;
1420 if (dos_header
->e_magic
!= IMAGE_DOS_SIGNATURE
)
1423 nt_header
= (PIMAGE_NT_HEADERS
) ((unsigned char *) dos_header
+ dos_header
->e_lfanew
);
1425 if ((char *) nt_header
> (char *) dos_header
+ executable
.size
)
1427 /* Some dos headers (pkunzip) have bogus e_lfanew fields. */
1430 else if (nt_header
->Signature
!= IMAGE_NT_SIGNATURE
1431 && LOWORD (nt_header
->Signature
) != IMAGE_OS2_SIGNATURE
)
1435 else if (nt_header
->Signature
== IMAGE_NT_SIGNATURE
)
1437 IMAGE_DATA_DIRECTORY
*data_dir
= NULL
;
1438 if (nt_header
->OptionalHeader
.Magic
== IMAGE_NT_OPTIONAL_HDR32_MAGIC
)
1440 /* Ensure we are using the 32 bit structure. */
1441 IMAGE_OPTIONAL_HEADER32
*opt
1442 = (IMAGE_OPTIONAL_HEADER32
*) &(nt_header
->OptionalHeader
);
1443 data_dir
= opt
->DataDirectory
;
1444 *is_gui_app
= (opt
->Subsystem
== IMAGE_SUBSYSTEM_WINDOWS_GUI
);
1446 /* MingW 3.12 has the required 64 bit structs, but in case older
1447 versions don't, only check 64 bit exes if we know how. */
1448 #ifdef IMAGE_NT_OPTIONAL_HDR64_MAGIC
1449 else if (nt_header
->OptionalHeader
.Magic
1450 == IMAGE_NT_OPTIONAL_HDR64_MAGIC
)
1452 IMAGE_OPTIONAL_HEADER64
*opt
1453 = (IMAGE_OPTIONAL_HEADER64
*) &(nt_header
->OptionalHeader
);
1454 data_dir
= opt
->DataDirectory
;
1455 *is_gui_app
= (opt
->Subsystem
== IMAGE_SUBSYSTEM_WINDOWS_GUI
);
1460 /* Look for cygwin.dll in DLL import list. */
1461 IMAGE_DATA_DIRECTORY import_dir
=
1462 data_dir
[IMAGE_DIRECTORY_ENTRY_IMPORT
];
1463 IMAGE_IMPORT_DESCRIPTOR
* imports
;
1464 IMAGE_SECTION_HEADER
* section
;
1466 section
= rva_to_section (import_dir
.VirtualAddress
, nt_header
);
1467 imports
= RVA_TO_PTR (import_dir
.VirtualAddress
, section
,
1470 for ( ; imports
->Name
; imports
++)
1472 char * dllname
= RVA_TO_PTR (imports
->Name
, section
,
1475 /* The exact name of the cygwin dll has changed with
1476 various releases, but hopefully this will be reasonably
1478 if (strncmp (dllname
, "cygwin", 6) == 0)
1480 *is_cygnus_app
= TRUE
;
1489 close_file_data (&executable
);
1493 compare_env (const void *strp1
, const void *strp2
)
1495 const char *str1
= *(const char **)strp1
, *str2
= *(const char **)strp2
;
1497 while (*str1
&& *str2
&& *str1
!= '=' && *str2
!= '=')
1499 /* Sort order in command.com/cmd.exe is based on uppercasing
1500 names, so do the same here. */
1501 if (toupper (*str1
) > toupper (*str2
))
1503 else if (toupper (*str1
) < toupper (*str2
))
1508 if (*str1
== '=' && *str2
== '=')
1510 else if (*str1
== '=')
1517 merge_and_sort_env (char **envp1
, char **envp2
, char **new_envp
)
1519 char **optr
, **nptr
;
1531 num
+= optr
- envp2
;
1533 qsort (new_envp
, num
, sizeof (char *), compare_env
);
1538 /* When a new child process is created we need to register it in our list,
1539 so intercept spawn requests. */
1541 sys_spawnve (int mode
, char *cmdname
, char **argv
, char **envp
)
1543 Lisp_Object program
, full
;
1544 char *cmdline
, *env
, *parg
, **targ
;
1548 int is_dos_app
, is_cygnus_app
, is_gui_app
;
1550 /* We pass our process ID to our children by setting up an environment
1551 variable in their environment. */
1552 char ppid_env_var_buffer
[64];
1553 char *extra_env
[] = {ppid_env_var_buffer
, NULL
};
1554 /* These are the characters that cause an argument to need quoting.
1555 Arguments with whitespace characters need quoting to prevent the
1556 argument being split into two or more. Arguments with wildcards
1557 are also quoted, for consistency with posix platforms, where wildcards
1558 are not expanded if we run the program directly without a shell.
1559 Some extra whitespace characters need quoting in Cygwin programs,
1560 so this list is conditionally modified below. */
1561 char *sepchars
= " \t*?";
1562 /* This is for native w32 apps; modified below for Cygwin apps. */
1563 char escape_char
= '\\';
1565 /* We don't care about the other modes */
1566 if (mode
!= _P_NOWAIT
)
1572 /* Handle executable names without an executable suffix. */
1573 program
= build_string (cmdname
);
1574 if (NILP (Ffile_executable_p (program
)))
1576 struct gcpro gcpro1
;
1580 openp (Vexec_path
, program
, Vexec_suffixes
, &full
, make_number (X_OK
));
1590 /* make sure argv[0] and cmdname are both in DOS format */
1591 cmdname
= SDATA (program
);
1592 unixtodos_filename (cmdname
);
1595 /* Determine whether program is a 16-bit DOS executable, or a 32-bit Windows
1596 executable that is implicitly linked to the Cygnus dll (implying it
1597 was compiled with the Cygnus GNU toolchain and hence relies on
1598 cygwin.dll to parse the command line - we use this to decide how to
1599 escape quote chars in command line args that must be quoted).
1601 Also determine whether it is a GUI app, so that we don't hide its
1602 initial window unless specifically requested. */
1603 w32_executable_type (cmdname
, &is_dos_app
, &is_cygnus_app
, &is_gui_app
);
1605 /* On Windows 95, if cmdname is a DOS app, we invoke a helper
1606 application to start it by specifying the helper app as cmdname,
1607 while leaving the real app name as argv[0]. */
1610 cmdname
= alloca (MAXPATHLEN
);
1611 if (egetenv ("CMDPROXY"))
1612 strcpy (cmdname
, egetenv ("CMDPROXY"));
1615 strcpy (cmdname
, SDATA (Vinvocation_directory
));
1616 strcat (cmdname
, "cmdproxy.exe");
1618 unixtodos_filename (cmdname
);
1621 /* we have to do some conjuring here to put argv and envp into the
1622 form CreateProcess wants... argv needs to be a space separated/null
1623 terminated list of parameters, and envp is a null
1624 separated/double-null terminated list of parameters.
1626 Additionally, zero-length args and args containing whitespace or
1627 quote chars need to be wrapped in double quotes - for this to work,
1628 embedded quotes need to be escaped as well. The aim is to ensure
1629 the child process reconstructs the argv array we start with
1630 exactly, so we treat quotes at the beginning and end of arguments
1633 The w32 GNU-based library from Cygnus doubles quotes to escape
1634 them, while MSVC uses backslash for escaping. (Actually the MSVC
1635 startup code does attempt to recognize doubled quotes and accept
1636 them, but gets it wrong and ends up requiring three quotes to get a
1637 single embedded quote!) So by default we decide whether to use
1638 quote or backslash as the escape character based on whether the
1639 binary is apparently a Cygnus compiled app.
1641 Note that using backslash to escape embedded quotes requires
1642 additional special handling if an embedded quote is already
1643 preceded by backslash, or if an arg requiring quoting ends with
1644 backslash. In such cases, the run of escape characters needs to be
1645 doubled. For consistency, we apply this special handling as long
1646 as the escape character is not quote.
1648 Since we have no idea how large argv and envp are likely to be we
1649 figure out list lengths on the fly and allocate them. */
1651 if (!NILP (Vw32_quote_process_args
))
1654 /* Override escape char by binding w32-quote-process-args to
1655 desired character, or use t for auto-selection. */
1656 if (INTEGERP (Vw32_quote_process_args
))
1657 escape_char
= XINT (Vw32_quote_process_args
);
1659 escape_char
= is_cygnus_app
? '"' : '\\';
1662 /* Cygwin apps needs quoting a bit more often. */
1663 if (escape_char
== '"')
1664 sepchars
= "\r\n\t\f '";
1672 int need_quotes
= 0;
1673 int escape_char_run
= 0;
1679 if (escape_char
== '"' && *p
== '\\')
1680 /* If it's a Cygwin app, \ needs to be escaped. */
1684 /* allow for embedded quotes to be escaped */
1687 /* handle the case where the embedded quote is already escaped */
1688 if (escape_char_run
> 0)
1690 /* To preserve the arg exactly, we need to double the
1691 preceding escape characters (plus adding one to
1692 escape the quote character itself). */
1693 arglen
+= escape_char_run
;
1696 else if (strchr (sepchars
, *p
) != NULL
)
1701 if (*p
== escape_char
&& escape_char
!= '"')
1704 escape_char_run
= 0;
1709 /* handle the case where the arg ends with an escape char - we
1710 must not let the enclosing quote be escaped. */
1711 if (escape_char_run
> 0)
1712 arglen
+= escape_char_run
;
1714 arglen
+= strlen (*targ
++) + 1;
1716 cmdline
= alloca (arglen
);
1722 int need_quotes
= 0;
1730 if ((strchr (sepchars
, *p
) != NULL
) || *p
== '"')
1735 int escape_char_run
= 0;
1741 last
= p
+ strlen (p
) - 1;
1744 /* This version does not escape quotes if they occur at the
1745 beginning or end of the arg - this could lead to incorrect
1746 behavior when the arg itself represents a command line
1747 containing quoted args. I believe this was originally done
1748 as a hack to make some things work, before
1749 `w32-quote-process-args' was added. */
1752 if (*p
== '"' && p
> first
&& p
< last
)
1753 *parg
++ = escape_char
; /* escape embedded quotes */
1761 /* double preceding escape chars if any */
1762 while (escape_char_run
> 0)
1764 *parg
++ = escape_char
;
1767 /* escape all quote chars, even at beginning or end */
1768 *parg
++ = escape_char
;
1770 else if (escape_char
== '"' && *p
== '\\')
1774 if (*p
== escape_char
&& escape_char
!= '"')
1777 escape_char_run
= 0;
1779 /* double escape chars before enclosing quote */
1780 while (escape_char_run
> 0)
1782 *parg
++ = escape_char
;
1790 strcpy (parg
, *targ
);
1791 parg
+= strlen (*targ
);
1801 numenv
= 1; /* for end null */
1804 arglen
+= strlen (*targ
++) + 1;
1807 /* extra env vars... */
1808 sprintf (ppid_env_var_buffer
, "EM_PARENT_PROCESS_ID=%lu",
1809 GetCurrentProcessId ());
1810 arglen
+= strlen (ppid_env_var_buffer
) + 1;
1813 /* merge env passed in and extra env into one, and sort it. */
1814 targ
= (char **) alloca (numenv
* sizeof (char *));
1815 merge_and_sort_env (envp
, extra_env
, targ
);
1817 /* concatenate env entries. */
1818 env
= alloca (arglen
);
1822 strcpy (parg
, *targ
);
1823 parg
+= strlen (*targ
++);
1836 /* Now create the process. */
1837 if (!create_child (cmdname
, cmdline
, env
, is_gui_app
, &pid
, cp
))
1847 /* Emulate the select call
1848 Wait for available input on any of the given rfds, or timeout if
1849 a timeout is given and no input is detected
1850 wfds and efds are not supported and must be NULL.
1852 For simplicity, we detect the death of child processes here and
1853 synchronously call the SIGCHLD handler. Since it is possible for
1854 children to be created without a corresponding pipe handle from which
1855 to read output, we wait separately on the process handles as well as
1856 the char_avail events for each process pipe. We only call
1857 wait/reap_process when the process actually terminates.
1859 To reduce the number of places in which Emacs can be hung such that
1860 C-g is not able to interrupt it, we always wait on interrupt_handle
1861 (which is signaled by the input thread when C-g is detected). If we
1862 detect that we were woken up by C-g, we return -1 with errno set to
1863 EINTR as on Unix. */
1865 /* From w32console.c */
1866 extern HANDLE keyboard_handle
;
1868 /* From w32xfns.c */
1869 extern HANDLE interrupt_handle
;
1871 /* From process.c */
1872 extern int proc_buffered_char
[];
1875 sys_select (int nfds
, SELECT_TYPE
*rfds
, SELECT_TYPE
*wfds
, SELECT_TYPE
*efds
,
1876 struct timespec
*timeout
, void *ignored
)
1879 DWORD timeout_ms
, start_time
;
1882 child_process
*cp
, *cps
[MAX_CHILDREN
];
1883 HANDLE wait_hnd
[MAXDESC
+ MAX_CHILDREN
];
1884 int fdindex
[MAXDESC
]; /* mapping from wait handles back to descriptors */
1887 timeout
? (timeout
->tv_sec
* 1000 + timeout
->tv_nsec
/ 1000000) : INFINITE
;
1889 /* If the descriptor sets are NULL but timeout isn't, then just Sleep. */
1890 if (rfds
== NULL
&& wfds
== NULL
&& efds
== NULL
&& timeout
!= NULL
)
1896 /* Otherwise, we only handle rfds, so fail otherwise. */
1897 if (rfds
== NULL
|| wfds
!= NULL
|| efds
!= NULL
)
1907 /* Always wait on interrupt_handle, to detect C-g (quit). */
1908 wait_hnd
[0] = interrupt_handle
;
1911 /* Build a list of pipe handles to wait on. */
1913 for (i
= 0; i
< nfds
; i
++)
1914 if (FD_ISSET (i
, &orfds
))
1918 if (keyboard_handle
)
1920 /* Handle stdin specially */
1921 wait_hnd
[nh
] = keyboard_handle
;
1926 /* Check for any emacs-generated input in the queue since
1927 it won't be detected in the wait */
1928 if (detect_input_pending ())
1936 /* Child process and socket/comm port input. */
1940 int current_status
= cp
->status
;
1942 if (current_status
== STATUS_READ_ACKNOWLEDGED
)
1944 /* Tell reader thread which file handle to use. */
1946 /* Wake up the reader thread for this process */
1947 cp
->status
= STATUS_READ_READY
;
1948 if (!SetEvent (cp
->char_consumed
))
1949 DebPrint (("sys_select.SetEvent failed with "
1950 "%lu for fd %ld\n", GetLastError (), i
));
1953 #ifdef CHECK_INTERLOCK
1954 /* slightly crude cross-checking of interlock between threads */
1956 current_status
= cp
->status
;
1957 if (WaitForSingleObject (cp
->char_avail
, 0) == WAIT_OBJECT_0
)
1959 /* char_avail has been signaled, so status (which may
1960 have changed) should indicate read has completed
1961 but has not been acknowledged. */
1962 current_status
= cp
->status
;
1963 if (current_status
!= STATUS_READ_SUCCEEDED
1964 && current_status
!= STATUS_READ_FAILED
)
1965 DebPrint (("char_avail set, but read not completed: status %d\n",
1970 /* char_avail has not been signaled, so status should
1971 indicate that read is in progress; small possibility
1972 that read has completed but event wasn't yet signaled
1973 when we tested it (because a context switch occurred
1974 or if running on separate CPUs). */
1975 if (current_status
!= STATUS_READ_READY
1976 && current_status
!= STATUS_READ_IN_PROGRESS
1977 && current_status
!= STATUS_READ_SUCCEEDED
1978 && current_status
!= STATUS_READ_FAILED
)
1979 DebPrint (("char_avail reset, but read status is bad: %d\n",
1983 wait_hnd
[nh
] = cp
->char_avail
;
1985 if (!wait_hnd
[nh
]) emacs_abort ();
1988 DebPrint (("select waiting on child %d fd %d\n",
1989 cp
-child_procs
, i
));
1994 /* Unable to find something to wait on for this fd, skip */
1996 /* Note that this is not a fatal error, and can in fact
1997 happen in unusual circumstances. Specifically, if
1998 sys_spawnve fails, eg. because the program doesn't
1999 exist, and debug-on-error is t so Fsignal invokes a
2000 nested input loop, then the process output pipe is
2001 still included in input_wait_mask with no child_proc
2002 associated with it. (It is removed when the debugger
2003 exits the nested input loop and the error is thrown.) */
2005 DebPrint (("sys_select: fd %ld is invalid! ignoring\n", i
));
2011 /* Add handles of child processes. */
2013 for (cp
= child_procs
+ (child_proc_count
-1); cp
>= child_procs
; cp
--)
2014 /* Some child_procs might be sockets; ignore them. Also some
2015 children may have died already, but we haven't finished reading
2016 the process output; ignore them too. */
2017 if ((CHILD_ACTIVE (cp
) && cp
->procinfo
.hProcess
)
2019 || (fd_info
[cp
->fd
].flags
& FILE_SEND_SIGCHLD
) == 0
2020 || (fd_info
[cp
->fd
].flags
& FILE_AT_EOF
) != 0)
2023 wait_hnd
[nh
+ nc
] = cp
->procinfo
.hProcess
;
2028 /* Nothing to look for, so we didn't find anything */
2036 start_time
= GetTickCount ();
2038 /* Wait for input or child death to be signaled. If user input is
2039 allowed, then also accept window messages. */
2040 if (FD_ISSET (0, &orfds
))
2041 active
= MsgWaitForMultipleObjects (nh
+ nc
, wait_hnd
, FALSE
, timeout_ms
,
2044 active
= WaitForMultipleObjects (nh
+ nc
, wait_hnd
, FALSE
, timeout_ms
);
2046 if (active
== WAIT_FAILED
)
2048 DebPrint (("select.WaitForMultipleObjects (%d, %lu) failed with %lu\n",
2049 nh
+ nc
, timeout_ms
, GetLastError ()));
2050 /* don't return EBADF - this causes wait_reading_process_output to
2051 abort; WAIT_FAILED is returned when single-stepping under
2052 Windows 95 after switching thread focus in debugger, and
2053 possibly at other times. */
2057 else if (active
== WAIT_TIMEOUT
)
2061 else if (active
>= WAIT_OBJECT_0
2062 && active
< WAIT_OBJECT_0
+MAXIMUM_WAIT_OBJECTS
)
2064 active
-= WAIT_OBJECT_0
;
2066 else if (active
>= WAIT_ABANDONED_0
2067 && active
< WAIT_ABANDONED_0
+MAXIMUM_WAIT_OBJECTS
)
2069 active
-= WAIT_ABANDONED_0
;
2074 /* Loop over all handles after active (now officially documented as
2075 being the first signaled handle in the array). We do this to
2076 ensure fairness, so that all channels with data available will be
2077 processed - otherwise higher numbered channels could be starved. */
2080 if (active
== nh
+ nc
)
2082 /* There are messages in the lisp thread's queue; we must
2083 drain the queue now to ensure they are processed promptly,
2084 because if we don't do so, we will not be woken again until
2085 further messages arrive.
2087 NB. If ever we allow window message procedures to callback
2088 into lisp, we will need to ensure messages are dispatched
2089 at a safe time for lisp code to be run (*), and we may also
2090 want to provide some hooks in the dispatch loop to cater
2091 for modeless dialogs created by lisp (ie. to register
2092 window handles to pass to IsDialogMessage).
2094 (*) Note that MsgWaitForMultipleObjects above is an
2095 internal dispatch point for messages that are sent to
2096 windows created by this thread. */
2097 if (drain_message_queue ()
2098 /* If drain_message_queue returns non-zero, that means
2099 we received a WM_EMACS_FILENOTIFY message. If this
2100 is a TTY frame, we must signal the caller that keyboard
2101 input is available, so that w32_console_read_socket
2102 will be called to pick up the notifications. If we
2103 don't do that, file notifications will only work when
2104 the Emacs TTY frame has focus. */
2105 && FRAME_TERMCAP_P (SELECTED_FRAME ())
2106 /* they asked for stdin reads */
2107 && FD_ISSET (0, &orfds
)
2108 /* the stdin handle is valid */
2116 else if (active
>= nh
)
2118 cp
= cps
[active
- nh
];
2120 /* We cannot always signal SIGCHLD immediately; if we have not
2121 finished reading the process output, we must delay sending
2122 SIGCHLD until we do. */
2124 if (cp
->fd
>= 0 && (fd_info
[cp
->fd
].flags
& FILE_AT_EOF
) == 0)
2125 fd_info
[cp
->fd
].flags
|= FILE_SEND_SIGCHLD
;
2126 /* SIG_DFL for SIGCHLD is ignore */
2127 else if (sig_handlers
[SIGCHLD
] != SIG_DFL
&&
2128 sig_handlers
[SIGCHLD
] != SIG_IGN
)
2131 DebPrint (("select calling SIGCHLD handler for pid %d\n",
2134 sig_handlers
[SIGCHLD
] (SIGCHLD
);
2137 else if (fdindex
[active
] == -1)
2139 /* Quit (C-g) was detected. */
2143 else if (fdindex
[active
] == 0)
2145 /* Keyboard input available */
2151 /* must be a socket or pipe - read ahead should have
2152 completed, either succeeding or failing. */
2153 FD_SET (fdindex
[active
], rfds
);
2157 /* Even though wait_reading_process_output only reads from at most
2158 one channel, we must process all channels here so that we reap
2159 all children that have died. */
2160 while (++active
< nh
+ nc
)
2161 if (WaitForSingleObject (wait_hnd
[active
], 0) == WAIT_OBJECT_0
)
2163 } while (active
< nh
+ nc
);
2165 /* If no input has arrived and timeout hasn't expired, wait again. */
2168 DWORD elapsed
= GetTickCount () - start_time
;
2170 if (timeout_ms
> elapsed
) /* INFINITE is MAX_UINT */
2172 if (timeout_ms
!= INFINITE
)
2173 timeout_ms
-= elapsed
;
2174 goto count_children
;
2181 /* Substitute for certain kill () operations */
2183 static BOOL CALLBACK
2184 find_child_console (HWND hwnd
, LPARAM arg
)
2186 child_process
* cp
= (child_process
*) arg
;
2190 thread_id
= GetWindowThreadProcessId (hwnd
, &process_id
);
2191 if (process_id
== cp
->procinfo
.dwProcessId
)
2193 char window_class
[32];
2195 GetClassName (hwnd
, window_class
, sizeof (window_class
));
2196 if (strcmp (window_class
,
2197 (os_subtype
== OS_9X
)
2199 : "ConsoleWindowClass") == 0)
2209 /* Emulate 'kill', but only for other processes. */
2211 sys_kill (pid_t pid
, int sig
)
2215 int need_to_free
= 0;
2218 /* Each process is in its own process group. */
2222 /* Only handle signals that will result in the process dying */
2224 && sig
!= SIGINT
&& sig
!= SIGKILL
&& sig
!= SIGQUIT
&& sig
!= SIGHUP
)
2232 /* It will take _some_ time before PID 4 or less on Windows will
2239 proc_hand
= OpenProcess (PROCESS_QUERY_INFORMATION
, 0, pid
);
2240 if (proc_hand
== NULL
)
2242 DWORD err
= GetLastError ();
2246 case ERROR_ACCESS_DENIED
: /* existing process, but access denied */
2249 case ERROR_INVALID_PARAMETER
: /* process PID does not exist */
2255 CloseHandle (proc_hand
);
2259 cp
= find_child_pid (pid
);
2262 /* We were passed a PID of something other than our subprocess.
2263 If that is our own PID, we will send to ourself a message to
2264 close the selected frame, which does not necessarily
2265 terminates Emacs. But then we are not supposed to call
2266 sys_kill with our own PID. */
2267 proc_hand
= OpenProcess (PROCESS_TERMINATE
, 0, pid
);
2268 if (proc_hand
== NULL
)
2277 proc_hand
= cp
->procinfo
.hProcess
;
2278 pid
= cp
->procinfo
.dwProcessId
;
2280 /* Try to locate console window for process. */
2281 EnumWindows (find_child_console
, (LPARAM
) cp
);
2284 if (sig
== SIGINT
|| sig
== SIGQUIT
)
2286 if (NILP (Vw32_start_process_share_console
) && cp
&& cp
->hwnd
)
2288 BYTE control_scan_code
= (BYTE
) MapVirtualKey (VK_CONTROL
, 0);
2289 /* Fake Ctrl-C for SIGINT, and Ctrl-Break for SIGQUIT. */
2290 BYTE vk_break_code
= (sig
== SIGINT
) ? 'C' : VK_CANCEL
;
2291 BYTE break_scan_code
= (BYTE
) MapVirtualKey (vk_break_code
, 0);
2292 HWND foreground_window
;
2294 if (break_scan_code
== 0)
2296 /* Fake Ctrl-C for SIGQUIT if we can't manage Ctrl-Break. */
2297 vk_break_code
= 'C';
2298 break_scan_code
= (BYTE
) MapVirtualKey (vk_break_code
, 0);
2301 foreground_window
= GetForegroundWindow ();
2302 if (foreground_window
)
2304 /* NT 5.0, and apparently also Windows 98, will not allow
2305 a Window to be set to foreground directly without the
2306 user's involvement. The workaround is to attach
2307 ourselves to the thread that owns the foreground
2308 window, since that is the only thread that can set the
2309 foreground window. */
2310 DWORD foreground_thread
, child_thread
;
2312 GetWindowThreadProcessId (foreground_window
, NULL
);
2313 if (foreground_thread
== GetCurrentThreadId ()
2314 || !AttachThreadInput (GetCurrentThreadId (),
2315 foreground_thread
, TRUE
))
2316 foreground_thread
= 0;
2318 child_thread
= GetWindowThreadProcessId (cp
->hwnd
, NULL
);
2319 if (child_thread
== GetCurrentThreadId ()
2320 || !AttachThreadInput (GetCurrentThreadId (),
2321 child_thread
, TRUE
))
2324 /* Set the foreground window to the child. */
2325 if (SetForegroundWindow (cp
->hwnd
))
2327 /* Generate keystrokes as if user had typed Ctrl-Break or
2329 keybd_event (VK_CONTROL
, control_scan_code
, 0, 0);
2330 keybd_event (vk_break_code
, break_scan_code
,
2331 (vk_break_code
== 'C' ? 0 : KEYEVENTF_EXTENDEDKEY
), 0);
2332 keybd_event (vk_break_code
, break_scan_code
,
2333 (vk_break_code
== 'C' ? 0 : KEYEVENTF_EXTENDEDKEY
)
2334 | KEYEVENTF_KEYUP
, 0);
2335 keybd_event (VK_CONTROL
, control_scan_code
,
2336 KEYEVENTF_KEYUP
, 0);
2338 /* Sleep for a bit to give time for Emacs frame to respond
2339 to focus change events (if Emacs was active app). */
2342 SetForegroundWindow (foreground_window
);
2344 /* Detach from the foreground and child threads now that
2345 the foreground switching is over. */
2346 if (foreground_thread
)
2347 AttachThreadInput (GetCurrentThreadId (),
2348 foreground_thread
, FALSE
);
2350 AttachThreadInput (GetCurrentThreadId (),
2351 child_thread
, FALSE
);
2354 /* Ctrl-Break is NT equivalent of SIGINT. */
2355 else if (!GenerateConsoleCtrlEvent (CTRL_BREAK_EVENT
, pid
))
2357 DebPrint (("sys_kill.GenerateConsoleCtrlEvent return %d "
2358 "for pid %lu\n", GetLastError (), pid
));
2365 if (NILP (Vw32_start_process_share_console
) && cp
&& cp
->hwnd
)
2368 if (os_subtype
== OS_9X
)
2371 Another possibility is to try terminating the VDM out-right by
2372 calling the Shell VxD (id 0x17) V86 interface, function #4
2373 "SHELL_Destroy_VM", ie.
2379 First need to determine the current VM handle, and then arrange for
2380 the shellapi call to be made from the system vm (by using
2381 Switch_VM_and_callback).
2383 Could try to invoke DestroyVM through CallVxD.
2387 /* On Windows 95, posting WM_QUIT causes the 16-bit subsystem
2388 to hang when cmdproxy is used in conjunction with
2389 command.com for an interactive shell. Posting
2390 WM_CLOSE pops up a dialog that, when Yes is selected,
2391 does the same thing. TerminateProcess is also less
2392 than ideal in that subprocesses tend to stick around
2393 until the machine is shutdown, but at least it
2394 doesn't freeze the 16-bit subsystem. */
2395 PostMessage (cp
->hwnd
, WM_QUIT
, 0xff, 0);
2397 if (!TerminateProcess (proc_hand
, 0xff))
2399 DebPrint (("sys_kill.TerminateProcess returned %d "
2400 "for pid %lu\n", GetLastError (), pid
));
2407 PostMessage (cp
->hwnd
, WM_CLOSE
, 0, 0);
2409 /* Kill the process. On W32 this doesn't kill child processes
2410 so it doesn't work very well for shells which is why it's not
2411 used in every case. */
2412 else if (!TerminateProcess (proc_hand
, 0xff))
2414 DebPrint (("sys_kill.TerminateProcess returned %d "
2415 "for pid %lu\n", GetLastError (), pid
));
2422 CloseHandle (proc_hand
);
2427 /* The following two routines are used to manipulate stdin, stdout, and
2428 stderr of our child processes.
2430 Assuming that in, out, and err are *not* inheritable, we make them
2431 stdin, stdout, and stderr of the child as follows:
2433 - Save the parent's current standard handles.
2434 - Set the std handles to inheritable duplicates of the ones being passed in.
2435 (Note that _get_osfhandle() is an io.h procedure that retrieves the
2436 NT file handle for a crt file descriptor.)
2437 - Spawn the child, which inherits in, out, and err as stdin,
2438 stdout, and stderr. (see Spawnve)
2439 - Close the std handles passed to the child.
2440 - Reset the parent's standard handles to the saved handles.
2441 (see reset_standard_handles)
2442 We assume that the caller closes in, out, and err after calling us. */
2445 prepare_standard_handles (int in
, int out
, int err
, HANDLE handles
[3])
2448 HANDLE newstdin
, newstdout
, newstderr
;
2450 parent
= GetCurrentProcess ();
2452 handles
[0] = GetStdHandle (STD_INPUT_HANDLE
);
2453 handles
[1] = GetStdHandle (STD_OUTPUT_HANDLE
);
2454 handles
[2] = GetStdHandle (STD_ERROR_HANDLE
);
2456 /* make inheritable copies of the new handles */
2457 if (!DuplicateHandle (parent
,
2458 (HANDLE
) _get_osfhandle (in
),
2463 DUPLICATE_SAME_ACCESS
))
2464 report_file_error ("Duplicating input handle for child", Qnil
);
2466 if (!DuplicateHandle (parent
,
2467 (HANDLE
) _get_osfhandle (out
),
2472 DUPLICATE_SAME_ACCESS
))
2473 report_file_error ("Duplicating output handle for child", Qnil
);
2475 if (!DuplicateHandle (parent
,
2476 (HANDLE
) _get_osfhandle (err
),
2481 DUPLICATE_SAME_ACCESS
))
2482 report_file_error ("Duplicating error handle for child", Qnil
);
2484 /* and store them as our std handles */
2485 if (!SetStdHandle (STD_INPUT_HANDLE
, newstdin
))
2486 report_file_error ("Changing stdin handle", Qnil
);
2488 if (!SetStdHandle (STD_OUTPUT_HANDLE
, newstdout
))
2489 report_file_error ("Changing stdout handle", Qnil
);
2491 if (!SetStdHandle (STD_ERROR_HANDLE
, newstderr
))
2492 report_file_error ("Changing stderr handle", Qnil
);
2496 reset_standard_handles (int in
, int out
, int err
, HANDLE handles
[3])
2498 /* close the duplicated handles passed to the child */
2499 CloseHandle (GetStdHandle (STD_INPUT_HANDLE
));
2500 CloseHandle (GetStdHandle (STD_OUTPUT_HANDLE
));
2501 CloseHandle (GetStdHandle (STD_ERROR_HANDLE
));
2503 /* now restore parent's saved std handles */
2504 SetStdHandle (STD_INPUT_HANDLE
, handles
[0]);
2505 SetStdHandle (STD_OUTPUT_HANDLE
, handles
[1]);
2506 SetStdHandle (STD_ERROR_HANDLE
, handles
[2]);
2510 set_process_dir (char * dir
)
2515 /* To avoid problems with winsock implementations that work over dial-up
2516 connections causing or requiring a connection to exist while Emacs is
2517 running, Emacs no longer automatically loads winsock on startup if it
2518 is present. Instead, it will be loaded when open-network-stream is
2521 To allow full control over when winsock is loaded, we provide these
2522 two functions to dynamically load and unload winsock. This allows
2523 dial-up users to only be connected when they actually need to use
2527 extern HANDLE winsock_lib
;
2528 extern BOOL
term_winsock (void);
2529 extern BOOL
init_winsock (int load_now
);
2531 DEFUN ("w32-has-winsock", Fw32_has_winsock
, Sw32_has_winsock
, 0, 1, 0,
2532 doc
: /* Test for presence of the Windows socket library `winsock'.
2533 Returns non-nil if winsock support is present, nil otherwise.
2535 If the optional argument LOAD-NOW is non-nil, the winsock library is
2536 also loaded immediately if not already loaded. If winsock is loaded,
2537 the winsock local hostname is returned (since this may be different from
2538 the value of `system-name' and should supplant it), otherwise t is
2539 returned to indicate winsock support is present. */)
2540 (Lisp_Object load_now
)
2544 have_winsock
= init_winsock (!NILP (load_now
));
2547 if (winsock_lib
!= NULL
)
2549 /* Return new value for system-name. The best way to do this
2550 is to call init_system_name, saving and restoring the
2551 original value to avoid side-effects. */
2552 Lisp_Object orig_hostname
= Vsystem_name
;
2553 Lisp_Object hostname
;
2555 init_system_name ();
2556 hostname
= Vsystem_name
;
2557 Vsystem_name
= orig_hostname
;
2565 DEFUN ("w32-unload-winsock", Fw32_unload_winsock
, Sw32_unload_winsock
,
2567 doc
: /* Unload the Windows socket library `winsock' if loaded.
2568 This is provided to allow dial-up socket connections to be disconnected
2569 when no longer needed. Returns nil without unloading winsock if any
2570 socket connections still exist. */)
2573 return term_winsock () ? Qt
: Qnil
;
2577 /* Some miscellaneous functions that are Windows specific, but not GUI
2578 specific (ie. are applicable in terminal or batch mode as well). */
2580 DEFUN ("w32-short-file-name", Fw32_short_file_name
, Sw32_short_file_name
, 1, 1, 0,
2581 doc
: /* Return the short file name version (8.3) of the full path of FILENAME.
2582 If FILENAME does not exist, return nil.
2583 All path elements in FILENAME are converted to their short names. */)
2584 (Lisp_Object filename
)
2586 char shortname
[MAX_PATH
];
2588 CHECK_STRING (filename
);
2590 /* first expand it. */
2591 filename
= Fexpand_file_name (filename
, Qnil
);
2593 /* luckily, this returns the short version of each element in the path. */
2594 if (w32_get_short_filename (SDATA (ENCODE_FILE (filename
)),
2595 shortname
, MAX_PATH
) == 0)
2598 dostounix_filename (shortname
);
2600 /* No need to DECODE_FILE, because 8.3 names are pure ASCII. */
2601 return build_string (shortname
);
2605 DEFUN ("w32-long-file-name", Fw32_long_file_name
, Sw32_long_file_name
,
2607 doc
: /* Return the long file name version of the full path of FILENAME.
2608 If FILENAME does not exist, return nil.
2609 All path elements in FILENAME are converted to their long names. */)
2610 (Lisp_Object filename
)
2612 char longname
[ MAX_UTF8_PATH
];
2615 CHECK_STRING (filename
);
2617 if (SBYTES (filename
) == 2
2618 && *(SDATA (filename
) + 1) == ':')
2621 /* first expand it. */
2622 filename
= Fexpand_file_name (filename
, Qnil
);
2624 if (!w32_get_long_filename (SDATA (ENCODE_FILE (filename
)), longname
,
2628 dostounix_filename (longname
);
2630 /* If we were passed only a drive, make sure that a slash is not appended
2631 for consistency with directories. Allow for drive mapping via SUBST
2632 in case expand-file-name is ever changed to expand those. */
2633 if (drive_only
&& longname
[1] == ':' && longname
[2] == '/' && !longname
[3])
2636 return DECODE_FILE (build_unibyte_string (longname
));
2639 DEFUN ("w32-set-process-priority", Fw32_set_process_priority
,
2640 Sw32_set_process_priority
, 2, 2, 0,
2641 doc
: /* Set the priority of PROCESS to PRIORITY.
2642 If PROCESS is nil, the priority of Emacs is changed, otherwise the
2643 priority of the process whose pid is PROCESS is changed.
2644 PRIORITY should be one of the symbols high, normal, or low;
2645 any other symbol will be interpreted as normal.
2647 If successful, the return value is t, otherwise nil. */)
2648 (Lisp_Object process
, Lisp_Object priority
)
2650 HANDLE proc_handle
= GetCurrentProcess ();
2651 DWORD priority_class
= NORMAL_PRIORITY_CLASS
;
2652 Lisp_Object result
= Qnil
;
2654 CHECK_SYMBOL (priority
);
2656 if (!NILP (process
))
2661 CHECK_NUMBER (process
);
2663 /* Allow pid to be an internally generated one, or one obtained
2664 externally. This is necessary because real pids on Windows 95 are
2667 pid
= XINT (process
);
2668 cp
= find_child_pid (pid
);
2670 pid
= cp
->procinfo
.dwProcessId
;
2672 proc_handle
= OpenProcess (PROCESS_SET_INFORMATION
, FALSE
, pid
);
2675 if (EQ (priority
, Qhigh
))
2676 priority_class
= HIGH_PRIORITY_CLASS
;
2677 else if (EQ (priority
, Qlow
))
2678 priority_class
= IDLE_PRIORITY_CLASS
;
2680 if (proc_handle
!= NULL
)
2682 if (SetPriorityClass (proc_handle
, priority_class
))
2684 if (!NILP (process
))
2685 CloseHandle (proc_handle
);
2691 #ifdef HAVE_LANGINFO_CODESET
2692 /* Emulation of nl_langinfo. Used in fns.c:Flocale_info. */
2694 nl_langinfo (nl_item item
)
2696 /* Conversion of Posix item numbers to their Windows equivalents. */
2697 static const LCTYPE w32item
[] = {
2698 LOCALE_IDEFAULTANSICODEPAGE
,
2699 LOCALE_SDAYNAME1
, LOCALE_SDAYNAME2
, LOCALE_SDAYNAME3
,
2700 LOCALE_SDAYNAME4
, LOCALE_SDAYNAME5
, LOCALE_SDAYNAME6
, LOCALE_SDAYNAME7
,
2701 LOCALE_SMONTHNAME1
, LOCALE_SMONTHNAME2
, LOCALE_SMONTHNAME3
,
2702 LOCALE_SMONTHNAME4
, LOCALE_SMONTHNAME5
, LOCALE_SMONTHNAME6
,
2703 LOCALE_SMONTHNAME7
, LOCALE_SMONTHNAME8
, LOCALE_SMONTHNAME9
,
2704 LOCALE_SMONTHNAME10
, LOCALE_SMONTHNAME11
, LOCALE_SMONTHNAME12
2707 static char *nl_langinfo_buf
= NULL
;
2708 static int nl_langinfo_len
= 0;
2710 if (nl_langinfo_len
<= 0)
2711 nl_langinfo_buf
= xmalloc (nl_langinfo_len
= 1);
2713 if (item
< 0 || item
>= _NL_NUM
)
2714 nl_langinfo_buf
[0] = 0;
2717 LCID cloc
= GetThreadLocale ();
2718 int need_len
= GetLocaleInfo (cloc
, w32item
[item
] | LOCALE_USE_CP_ACP
,
2722 nl_langinfo_buf
[0] = 0;
2725 if (item
== CODESET
)
2727 need_len
+= 2; /* for the "cp" prefix */
2728 if (need_len
< 8) /* for the case we call GetACP */
2731 if (nl_langinfo_len
<= need_len
)
2732 nl_langinfo_buf
= xrealloc (nl_langinfo_buf
,
2733 nl_langinfo_len
= need_len
);
2734 if (!GetLocaleInfo (cloc
, w32item
[item
] | LOCALE_USE_CP_ACP
,
2735 nl_langinfo_buf
, nl_langinfo_len
))
2736 nl_langinfo_buf
[0] = 0;
2737 else if (item
== CODESET
)
2739 if (strcmp (nl_langinfo_buf
, "0") == 0 /* CP_ACP */
2740 || strcmp (nl_langinfo_buf
, "1") == 0) /* CP_OEMCP */
2741 sprintf (nl_langinfo_buf
, "cp%u", GetACP ());
2744 memmove (nl_langinfo_buf
+ 2, nl_langinfo_buf
,
2745 strlen (nl_langinfo_buf
) + 1);
2746 nl_langinfo_buf
[0] = 'c';
2747 nl_langinfo_buf
[1] = 'p';
2752 return nl_langinfo_buf
;
2754 #endif /* HAVE_LANGINFO_CODESET */
2756 DEFUN ("w32-get-locale-info", Fw32_get_locale_info
,
2757 Sw32_get_locale_info
, 1, 2, 0,
2758 doc
: /* Return information about the Windows locale LCID.
2759 By default, return a three letter locale code which encodes the default
2760 language as the first two characters, and the country or regional variant
2761 as the third letter. For example, ENU refers to `English (United States)',
2762 while ENC means `English (Canadian)'.
2764 If the optional argument LONGFORM is t, the long form of the locale
2765 name is returned, e.g. `English (United States)' instead; if LONGFORM
2766 is a number, it is interpreted as an LCTYPE constant and the corresponding
2767 locale information is returned.
2769 If LCID (a 16-bit number) is not a valid locale, the result is nil. */)
2770 (Lisp_Object lcid
, Lisp_Object longform
)
2774 char abbrev_name
[32] = { 0 };
2775 char full_name
[256] = { 0 };
2777 CHECK_NUMBER (lcid
);
2779 if (!IsValidLocale (XINT (lcid
), LCID_SUPPORTED
))
2782 if (NILP (longform
))
2784 got_abbrev
= GetLocaleInfo (XINT (lcid
),
2785 LOCALE_SABBREVLANGNAME
| LOCALE_USE_CP_ACP
,
2786 abbrev_name
, sizeof (abbrev_name
));
2788 return build_string (abbrev_name
);
2790 else if (EQ (longform
, Qt
))
2792 got_full
= GetLocaleInfo (XINT (lcid
),
2793 LOCALE_SLANGUAGE
| LOCALE_USE_CP_ACP
,
2794 full_name
, sizeof (full_name
));
2796 return DECODE_SYSTEM (build_string (full_name
));
2798 else if (NUMBERP (longform
))
2800 got_full
= GetLocaleInfo (XINT (lcid
),
2802 full_name
, sizeof (full_name
));
2803 /* GetLocaleInfo's return value includes the terminating null
2804 character, when the returned information is a string, whereas
2805 make_unibyte_string needs the string length without the
2806 terminating null. */
2808 return make_unibyte_string (full_name
, got_full
- 1);
2815 DEFUN ("w32-get-current-locale-id", Fw32_get_current_locale_id
,
2816 Sw32_get_current_locale_id
, 0, 0, 0,
2817 doc
: /* Return Windows locale id for current locale setting.
2818 This is a numerical value; use `w32-get-locale-info' to convert to a
2819 human-readable form. */)
2822 return make_number (GetThreadLocale ());
2826 int_from_hex (char * s
)
2829 static char hex
[] = "0123456789abcdefABCDEF";
2832 while (*s
&& (p
= strchr (hex
, *s
)) != NULL
)
2834 unsigned digit
= p
- hex
;
2837 val
= val
* 16 + digit
;
2843 /* We need to build a global list, since the EnumSystemLocale callback
2844 function isn't given a context pointer. */
2845 Lisp_Object Vw32_valid_locale_ids
;
2847 static BOOL CALLBACK
2848 enum_locale_fn (LPTSTR localeNum
)
2850 DWORD id
= int_from_hex (localeNum
);
2851 Vw32_valid_locale_ids
= Fcons (make_number (id
), Vw32_valid_locale_ids
);
2855 DEFUN ("w32-get-valid-locale-ids", Fw32_get_valid_locale_ids
,
2856 Sw32_get_valid_locale_ids
, 0, 0, 0,
2857 doc
: /* Return list of all valid Windows locale ids.
2858 Each id is a numerical value; use `w32-get-locale-info' to convert to a
2859 human-readable form. */)
2862 Vw32_valid_locale_ids
= Qnil
;
2864 EnumSystemLocales (enum_locale_fn
, LCID_SUPPORTED
);
2866 Vw32_valid_locale_ids
= Fnreverse (Vw32_valid_locale_ids
);
2867 return Vw32_valid_locale_ids
;
2871 DEFUN ("w32-get-default-locale-id", Fw32_get_default_locale_id
, Sw32_get_default_locale_id
, 0, 1, 0,
2872 doc
: /* Return Windows locale id for default locale setting.
2873 By default, the system default locale setting is returned; if the optional
2874 parameter USERP is non-nil, the user default locale setting is returned.
2875 This is a numerical value; use `w32-get-locale-info' to convert to a
2876 human-readable form. */)
2880 return make_number (GetSystemDefaultLCID ());
2881 return make_number (GetUserDefaultLCID ());
2885 DEFUN ("w32-set-current-locale", Fw32_set_current_locale
, Sw32_set_current_locale
, 1, 1, 0,
2886 doc
: /* Make Windows locale LCID be the current locale setting for Emacs.
2887 If successful, the new locale id is returned, otherwise nil. */)
2890 CHECK_NUMBER (lcid
);
2892 if (!IsValidLocale (XINT (lcid
), LCID_SUPPORTED
))
2895 if (!SetThreadLocale (XINT (lcid
)))
2898 /* Need to set input thread locale if present. */
2899 if (dwWindowsThreadId
)
2900 /* Reply is not needed. */
2901 PostThreadMessage (dwWindowsThreadId
, WM_EMACS_SETLOCALE
, XINT (lcid
), 0);
2903 return make_number (GetThreadLocale ());
2907 /* We need to build a global list, since the EnumCodePages callback
2908 function isn't given a context pointer. */
2909 Lisp_Object Vw32_valid_codepages
;
2911 static BOOL CALLBACK
2912 enum_codepage_fn (LPTSTR codepageNum
)
2914 DWORD id
= atoi (codepageNum
);
2915 Vw32_valid_codepages
= Fcons (make_number (id
), Vw32_valid_codepages
);
2919 DEFUN ("w32-get-valid-codepages", Fw32_get_valid_codepages
,
2920 Sw32_get_valid_codepages
, 0, 0, 0,
2921 doc
: /* Return list of all valid Windows codepages. */)
2924 Vw32_valid_codepages
= Qnil
;
2926 EnumSystemCodePages (enum_codepage_fn
, CP_SUPPORTED
);
2928 Vw32_valid_codepages
= Fnreverse (Vw32_valid_codepages
);
2929 return Vw32_valid_codepages
;
2933 DEFUN ("w32-get-console-codepage", Fw32_get_console_codepage
,
2934 Sw32_get_console_codepage
, 0, 0, 0,
2935 doc
: /* Return current Windows codepage for console input. */)
2938 return make_number (GetConsoleCP ());
2942 DEFUN ("w32-set-console-codepage", Fw32_set_console_codepage
,
2943 Sw32_set_console_codepage
, 1, 1, 0,
2944 doc
: /* Make Windows codepage CP be the codepage for Emacs tty keyboard input.
2945 This codepage setting affects keyboard input in tty mode.
2946 If successful, the new CP is returned, otherwise nil. */)
2951 if (!IsValidCodePage (XINT (cp
)))
2954 if (!SetConsoleCP (XINT (cp
)))
2957 return make_number (GetConsoleCP ());
2961 DEFUN ("w32-get-console-output-codepage", Fw32_get_console_output_codepage
,
2962 Sw32_get_console_output_codepage
, 0, 0, 0,
2963 doc
: /* Return current Windows codepage for console output. */)
2966 return make_number (GetConsoleOutputCP ());
2970 DEFUN ("w32-set-console-output-codepage", Fw32_set_console_output_codepage
,
2971 Sw32_set_console_output_codepage
, 1, 1, 0,
2972 doc
: /* Make Windows codepage CP be the codepage for Emacs console output.
2973 This codepage setting affects display in tty mode.
2974 If successful, the new CP is returned, otherwise nil. */)
2979 if (!IsValidCodePage (XINT (cp
)))
2982 if (!SetConsoleOutputCP (XINT (cp
)))
2985 return make_number (GetConsoleOutputCP ());
2989 DEFUN ("w32-get-codepage-charset", Fw32_get_codepage_charset
,
2990 Sw32_get_codepage_charset
, 1, 1, 0,
2991 doc
: /* Return charset ID corresponding to codepage CP.
2992 Returns nil if the codepage is not valid. */)
2999 if (!IsValidCodePage (XINT (cp
)))
3002 if (TranslateCharsetInfo ((DWORD
*) XINT (cp
), &info
, TCI_SRCCODEPAGE
))
3003 return make_number (info
.ciCharset
);
3009 DEFUN ("w32-get-valid-keyboard-layouts", Fw32_get_valid_keyboard_layouts
,
3010 Sw32_get_valid_keyboard_layouts
, 0, 0, 0,
3011 doc
: /* Return list of Windows keyboard languages and layouts.
3012 The return value is a list of pairs of language id and layout id. */)
3015 int num_layouts
= GetKeyboardLayoutList (0, NULL
);
3016 HKL
* layouts
= (HKL
*) alloca (num_layouts
* sizeof (HKL
));
3017 Lisp_Object obj
= Qnil
;
3019 if (GetKeyboardLayoutList (num_layouts
, layouts
) == num_layouts
)
3021 while (--num_layouts
>= 0)
3023 DWORD kl
= (DWORD
) layouts
[num_layouts
];
3025 obj
= Fcons (Fcons (make_number (kl
& 0xffff),
3026 make_number ((kl
>> 16) & 0xffff)),
3035 DEFUN ("w32-get-keyboard-layout", Fw32_get_keyboard_layout
,
3036 Sw32_get_keyboard_layout
, 0, 0, 0,
3037 doc
: /* Return current Windows keyboard language and layout.
3038 The return value is the cons of the language id and the layout id. */)
3041 DWORD kl
= (DWORD
) GetKeyboardLayout (dwWindowsThreadId
);
3043 return Fcons (make_number (kl
& 0xffff),
3044 make_number ((kl
>> 16) & 0xffff));
3048 DEFUN ("w32-set-keyboard-layout", Fw32_set_keyboard_layout
,
3049 Sw32_set_keyboard_layout
, 1, 1, 0,
3050 doc
: /* Make LAYOUT be the current keyboard layout for Emacs.
3051 The keyboard layout setting affects interpretation of keyboard input.
3052 If successful, the new layout id is returned, otherwise nil. */)
3053 (Lisp_Object layout
)
3057 CHECK_CONS (layout
);
3058 CHECK_NUMBER_CAR (layout
);
3059 CHECK_NUMBER_CDR (layout
);
3061 kl
= (XINT (XCAR (layout
)) & 0xffff)
3062 | (XINT (XCDR (layout
)) << 16);
3064 /* Synchronize layout with input thread. */
3065 if (dwWindowsThreadId
)
3067 if (PostThreadMessage (dwWindowsThreadId
, WM_EMACS_SETKEYBOARDLAYOUT
,
3071 GetMessage (&msg
, NULL
, WM_EMACS_DONE
, WM_EMACS_DONE
);
3073 if (msg
.wParam
== 0)
3077 else if (!ActivateKeyboardLayout ((HKL
) kl
, 0))
3080 return Fw32_get_keyboard_layout ();
3085 syms_of_ntproc (void)
3087 DEFSYM (Qhigh
, "high");
3088 DEFSYM (Qlow
, "low");
3090 defsubr (&Sw32_has_winsock
);
3091 defsubr (&Sw32_unload_winsock
);
3093 defsubr (&Sw32_short_file_name
);
3094 defsubr (&Sw32_long_file_name
);
3095 defsubr (&Sw32_set_process_priority
);
3096 defsubr (&Sw32_get_locale_info
);
3097 defsubr (&Sw32_get_current_locale_id
);
3098 defsubr (&Sw32_get_default_locale_id
);
3099 defsubr (&Sw32_get_valid_locale_ids
);
3100 defsubr (&Sw32_set_current_locale
);
3102 defsubr (&Sw32_get_console_codepage
);
3103 defsubr (&Sw32_set_console_codepage
);
3104 defsubr (&Sw32_get_console_output_codepage
);
3105 defsubr (&Sw32_set_console_output_codepage
);
3106 defsubr (&Sw32_get_valid_codepages
);
3107 defsubr (&Sw32_get_codepage_charset
);
3109 defsubr (&Sw32_get_valid_keyboard_layouts
);
3110 defsubr (&Sw32_get_keyboard_layout
);
3111 defsubr (&Sw32_set_keyboard_layout
);
3113 DEFVAR_LISP ("w32-quote-process-args", Vw32_quote_process_args
,
3114 doc
: /* Non-nil enables quoting of process arguments to ensure correct parsing.
3115 Because Windows does not directly pass argv arrays to child processes,
3116 programs have to reconstruct the argv array by parsing the command
3117 line string. For an argument to contain a space, it must be enclosed
3118 in double quotes or it will be parsed as multiple arguments.
3120 If the value is a character, that character will be used to escape any
3121 quote characters that appear, otherwise a suitable escape character
3122 will be chosen based on the type of the program. */);
3123 Vw32_quote_process_args
= Qt
;
3125 DEFVAR_LISP ("w32-start-process-show-window",
3126 Vw32_start_process_show_window
,
3127 doc
: /* When nil, new child processes hide their windows.
3128 When non-nil, they show their window in the method of their choice.
3129 This variable doesn't affect GUI applications, which will never be hidden. */);
3130 Vw32_start_process_show_window
= Qnil
;
3132 DEFVAR_LISP ("w32-start-process-share-console",
3133 Vw32_start_process_share_console
,
3134 doc
: /* When nil, new child processes are given a new console.
3135 When non-nil, they share the Emacs console; this has the limitation of
3136 allowing only one DOS subprocess to run at a time (whether started directly
3137 or indirectly by Emacs), and preventing Emacs from cleanly terminating the
3138 subprocess group, but may allow Emacs to interrupt a subprocess that doesn't
3139 otherwise respond to interrupts from Emacs. */);
3140 Vw32_start_process_share_console
= Qnil
;
3142 DEFVAR_LISP ("w32-start-process-inherit-error-mode",
3143 Vw32_start_process_inherit_error_mode
,
3144 doc
: /* When nil, new child processes revert to the default error mode.
3145 When non-nil, they inherit their error mode setting from Emacs, which stops
3146 them blocking when trying to access unmounted drives etc. */);
3147 Vw32_start_process_inherit_error_mode
= Qt
;
3149 DEFVAR_INT ("w32-pipe-read-delay", w32_pipe_read_delay
,
3150 doc
: /* Forced delay before reading subprocess output.
3151 This is done to improve the buffering of subprocess output, by
3152 avoiding the inefficiency of frequently reading small amounts of data.
3154 If positive, the value is the number of milliseconds to sleep before
3155 reading the subprocess output. If negative, the magnitude is the number
3156 of time slices to wait (effectively boosting the priority of the child
3157 process temporarily). A value of zero disables waiting entirely. */);
3158 w32_pipe_read_delay
= 50;
3160 DEFVAR_LISP ("w32-downcase-file-names", Vw32_downcase_file_names
,
3161 doc
: /* Non-nil means convert all-upper case file names to lower case.
3162 This applies when performing completions and file name expansion.
3163 Note that the value of this setting also affects remote file names,
3164 so you probably don't want to set to non-nil if you use case-sensitive
3165 filesystems via ange-ftp. */);
3166 Vw32_downcase_file_names
= Qnil
;
3169 DEFVAR_LISP ("w32-generate-fake-inodes", Vw32_generate_fake_inodes
,
3170 doc
: /* Non-nil means attempt to fake realistic inode values.
3171 This works by hashing the truename of files, and should detect
3172 aliasing between long and short (8.3 DOS) names, but can have
3173 false positives because of hash collisions. Note that determining
3174 the truename of a file can be slow. */);
3175 Vw32_generate_fake_inodes
= Qnil
;
3178 DEFVAR_LISP ("w32-get-true-file-attributes", Vw32_get_true_file_attributes
,
3179 doc
: /* Non-nil means determine accurate file attributes in `file-attributes'.
3180 This option controls whether to issue additional system calls to determine
3181 accurate link counts, file type, and ownership information. It is more
3182 useful for files on NTFS volumes, where hard links and file security are
3183 supported, than on volumes of the FAT family.
3185 Without these system calls, link count will always be reported as 1 and file
3186 ownership will be attributed to the current user.
3187 The default value `local' means only issue these system calls for files
3188 on local fixed drives. A value of nil means never issue them.
3189 Any other non-nil value means do this even on remote and removable drives
3190 where the performance impact may be noticeable even on modern hardware. */);
3191 Vw32_get_true_file_attributes
= Qlocal
;
3193 staticpro (&Vw32_valid_locale_ids
);
3194 staticpro (&Vw32_valid_codepages
);
3196 /* end of w32proc.c */