1 /* Process support for GNU Emacs on the Microsoft Windows API.
3 Copyright (C) 1992, 1995, 1999-2015 Free Software Foundation, Inc.
5 This file is part of GNU Emacs.
7 GNU Emacs is free software: you can redistribute it and/or modify
8 it under the terms of the GNU General Public License as published by
9 the Free Software Foundation, either version 3 of the License, or
10 (at your option) any later version.
12 GNU Emacs is distributed in the hope that it will be useful,
13 but WITHOUT ANY WARRANTY; without even the implied warranty of
14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 GNU General Public License for more details.
17 You should have received a copy of the GNU General Public License
18 along with GNU Emacs. If not, see <http://www.gnu.org/licenses/>. */
21 Drew Bliss Oct 14, 1993
22 Adapted from alarm.c by Tim Fleehart
25 #include <mingw_time.h>
37 /* must include CRT headers *before* config.h */
47 #if defined(__GNUC__) && !defined(__MINGW64__)
48 /* This definition is missing from mingw.org headers, but not MinGW64
50 extern BOOL WINAPI
IsValidLocale (LCID
, DWORD
);
53 #ifdef HAVE_LANGINFO_CODESET
60 #include "w32common.h"
65 #include "syssignal.h"
67 #include "dispextern.h" /* for xstrcasecmp */
70 #define RVA_TO_PTR(var,section,filedata) \
71 ((void *)((section)->PointerToRawData \
72 + ((DWORD_PTR)(var) - (section)->VirtualAddress) \
73 + (filedata).file_base))
75 /* Signal handlers...SIG_DFL == 0 so this is initialized correctly. */
76 static signal_handler sig_handlers
[NSIG
];
78 static sigset_t sig_mask
;
80 static CRITICAL_SECTION crit_sig
;
82 /* Improve on the CRT 'signal' implementation so that we could record
83 the SIGCHLD handler and fake interval timers. */
85 sys_signal (int sig
, signal_handler handler
)
89 /* SIGCHLD is needed for supporting subprocesses, see sys_kill
90 below. SIGALRM and SIGPROF are used by setitimer. All the
91 others are the only ones supported by the MS runtime. */
92 if (!(sig
== SIGCHLD
|| sig
== SIGSEGV
|| sig
== SIGILL
93 || sig
== SIGFPE
|| sig
== SIGABRT
|| sig
== SIGTERM
94 || sig
== SIGALRM
|| sig
== SIGPROF
))
99 old
= sig_handlers
[sig
];
100 /* SIGABRT is treated specially because w32.c installs term_ntproc
101 as its handler, so we don't want to override that afterwards.
102 Aborting Emacs works specially anyway: either by calling
103 emacs_abort directly or through terminate_due_to_signal, which
104 calls emacs_abort through emacs_raise. */
105 if (!(sig
== SIGABRT
&& old
== term_ntproc
))
107 sig_handlers
[sig
] = handler
;
108 if (!(sig
== SIGCHLD
|| sig
== SIGALRM
|| sig
== SIGPROF
))
109 signal (sig
, handler
);
114 /* Emulate sigaction. */
116 sigaction (int sig
, const struct sigaction
*act
, struct sigaction
*oact
)
118 signal_handler old
= SIG_DFL
;
122 old
= sys_signal (sig
, act
->sa_handler
);
124 old
= sig_handlers
[sig
];
133 oact
->sa_handler
= old
;
135 oact
->sa_mask
= empty_mask
;
140 /* Emulate signal sets and blocking of signals used by timers. */
143 sigemptyset (sigset_t
*set
)
150 sigaddset (sigset_t
*set
, int signo
)
157 if (signo
< 0 || signo
>= NSIG
)
163 *set
|= (1U << signo
);
169 sigfillset (sigset_t
*set
)
182 sigprocmask (int how
, const sigset_t
*set
, sigset_t
*oset
)
184 if (!(how
== SIG_BLOCK
|| how
== SIG_UNBLOCK
|| how
== SIG_SETMASK
))
205 /* FIXME: Catch signals that are blocked and reissue them when
206 they are unblocked. Important for SIGALRM and SIGPROF only. */
215 pthread_sigmask (int how
, const sigset_t
*set
, sigset_t
*oset
)
217 if (sigprocmask (how
, set
, oset
) == -1)
223 sigismember (const sigset_t
*set
, int signo
)
225 if (signo
< 0 || signo
>= NSIG
)
230 if (signo
> sizeof (*set
) * BITS_PER_CHAR
)
233 return (*set
& (1U << signo
)) != 0;
249 setpgid (pid_t pid
, pid_t pgid
)
260 /* Emulations of interval timers.
262 Limitations: only ITIMER_REAL and ITIMER_PROF are supported.
264 Implementation: a separate thread is started for each timer type,
265 the thread calls the appropriate signal handler when the timer
266 expires, after stopping the thread which installed the timer. */
269 volatile ULONGLONG expire
;
270 volatile ULONGLONG reload
;
271 volatile int terminate
;
273 HANDLE caller_thread
;
277 static ULONGLONG ticks_now
;
278 static struct itimer_data real_itimer
, prof_itimer
;
279 static ULONGLONG clocks_min
;
280 /* If non-zero, itimers are disabled. Used during shutdown, when we
281 delete the critical sections used by the timer threads. */
282 static int disable_itimers
;
284 static CRITICAL_SECTION crit_real
, crit_prof
;
286 /* GetThreadTimes is not available on Windows 9X and possibly also on 2K. */
287 typedef BOOL (WINAPI
*GetThreadTimes_Proc
) (
289 LPFILETIME lpCreationTime
,
290 LPFILETIME lpExitTime
,
291 LPFILETIME lpKernelTime
,
292 LPFILETIME lpUserTime
);
294 static GetThreadTimes_Proc s_pfn_Get_Thread_Times
;
296 #define MAX_SINGLE_SLEEP 30
297 #define TIMER_TICKS_PER_SEC 1000
299 /* Return a suitable time value, in 1-ms units, for THREAD, a handle
300 to a thread. If THREAD is NULL or an invalid handle, return the
301 current wall-clock time since January 1, 1601 (UTC). Otherwise,
302 return the sum of kernel and user times used by THREAD since it was
303 created, plus its creation time. */
305 w32_get_timer_time (HANDLE thread
)
308 int use_system_time
= 1;
309 /* The functions below return times in 100-ns units. */
310 const int tscale
= 10 * TIMER_TICKS_PER_SEC
;
312 if (thread
&& thread
!= INVALID_HANDLE_VALUE
313 && s_pfn_Get_Thread_Times
!= NULL
)
315 FILETIME creation_ftime
, exit_ftime
, kernel_ftime
, user_ftime
;
316 ULARGE_INTEGER temp_creation
, temp_kernel
, temp_user
;
318 if (s_pfn_Get_Thread_Times (thread
, &creation_ftime
, &exit_ftime
,
319 &kernel_ftime
, &user_ftime
))
322 temp_creation
.LowPart
= creation_ftime
.dwLowDateTime
;
323 temp_creation
.HighPart
= creation_ftime
.dwHighDateTime
;
324 temp_kernel
.LowPart
= kernel_ftime
.dwLowDateTime
;
325 temp_kernel
.HighPart
= kernel_ftime
.dwHighDateTime
;
326 temp_user
.LowPart
= user_ftime
.dwLowDateTime
;
327 temp_user
.HighPart
= user_ftime
.dwHighDateTime
;
329 temp_creation
.QuadPart
/ tscale
+ temp_kernel
.QuadPart
/ tscale
330 + temp_user
.QuadPart
/ tscale
;
333 DebPrint (("GetThreadTimes failed with error code %lu\n",
339 FILETIME current_ftime
;
342 GetSystemTimeAsFileTime (¤t_ftime
);
344 temp
.LowPart
= current_ftime
.dwLowDateTime
;
345 temp
.HighPart
= current_ftime
.dwHighDateTime
;
347 retval
= temp
.QuadPart
/ tscale
;
353 /* Thread function for a timer thread. */
355 timer_loop (LPVOID arg
)
357 struct itimer_data
*itimer
= (struct itimer_data
*)arg
;
358 int which
= itimer
->type
;
359 int sig
= (which
== ITIMER_REAL
) ? SIGALRM
: SIGPROF
;
360 CRITICAL_SECTION
*crit
= (which
== ITIMER_REAL
) ? &crit_real
: &crit_prof
;
361 const DWORD max_sleep
= MAX_SINGLE_SLEEP
* 1000 / TIMER_TICKS_PER_SEC
;
362 HANDLE hth
= (which
== ITIMER_REAL
) ? NULL
: itimer
->caller_thread
;
367 signal_handler handler
;
368 ULONGLONG now
, expire
, reload
;
370 /* Load new values if requested by setitimer. */
371 EnterCriticalSection (crit
);
372 expire
= itimer
->expire
;
373 reload
= itimer
->reload
;
374 LeaveCriticalSection (crit
);
375 if (itimer
->terminate
)
385 if (expire
> (now
= w32_get_timer_time (hth
)))
386 sleep_time
= expire
- now
;
389 /* Don't sleep too long at a time, to be able to see the
390 termination flag without too long a delay. */
391 while (sleep_time
> max_sleep
)
393 if (itimer
->terminate
)
396 EnterCriticalSection (crit
);
397 expire
= itimer
->expire
;
398 LeaveCriticalSection (crit
);
400 (expire
> (now
= w32_get_timer_time (hth
))) ? expire
- now
: 0;
402 if (itimer
->terminate
)
406 Sleep (sleep_time
* 1000 / TIMER_TICKS_PER_SEC
);
407 /* Always sleep past the expiration time, to make sure we
408 never call the handler _before_ the expiration time,
409 always slightly after it. Sleep(5) makes sure we don't
410 hog the CPU by calling 'w32_get_timer_time' with high
411 frequency, and also let other threads work. */
412 while (w32_get_timer_time (hth
) < expire
)
416 EnterCriticalSection (crit
);
417 expire
= itimer
->expire
;
418 LeaveCriticalSection (crit
);
423 handler
= sig_handlers
[sig
];
424 if (!(handler
== SIG_DFL
|| handler
== SIG_IGN
|| handler
== SIG_ERR
)
425 /* FIXME: Don't ignore masked signals. Instead, record that
426 they happened and reissue them when the signal is
428 && !sigismember (&sig_mask
, sig
)
429 /* Simulate masking of SIGALRM and SIGPROF when processing
431 && !fatal_error_in_progress
432 && itimer
->caller_thread
)
434 /* Simulate a signal delivered to the thread which installed
435 the timer, by suspending that thread while the handler
437 HANDLE th
= itimer
->caller_thread
;
438 DWORD result
= SuspendThread (th
);
440 if (result
== (DWORD
)-1)
447 /* Update expiration time and loop. */
448 EnterCriticalSection (crit
);
449 expire
= itimer
->expire
;
452 LeaveCriticalSection (crit
);
455 reload
= itimer
->reload
;
458 now
= w32_get_timer_time (hth
);
461 ULONGLONG lag
= now
- expire
;
463 /* If we missed some opportunities (presumably while
464 sleeping or while the signal handler ran), skip
467 expire
= now
- (lag
% reload
);
473 expire
= 0; /* become idle */
474 itimer
->expire
= expire
;
475 LeaveCriticalSection (crit
);
481 stop_timer_thread (int which
)
483 struct itimer_data
*itimer
=
484 (which
== ITIMER_REAL
) ? &real_itimer
: &prof_itimer
;
486 DWORD err
, exit_code
= 255;
489 /* Signal the thread that it should terminate. */
490 itimer
->terminate
= 1;
492 if (itimer
->timer_thread
== NULL
)
495 /* Wait for the timer thread to terminate voluntarily, then kill it
496 if it doesn't. This loop waits twice more than the maximum
497 amount of time a timer thread sleeps, see above. */
498 for (i
= 0; i
< MAX_SINGLE_SLEEP
/ 5; i
++)
500 if (!((status
= GetExitCodeThread (itimer
->timer_thread
, &exit_code
))
501 && exit_code
== STILL_ACTIVE
))
505 if ((status
== FALSE
&& (err
= GetLastError ()) == ERROR_INVALID_HANDLE
)
506 || exit_code
== STILL_ACTIVE
)
508 if (!(status
== FALSE
&& err
== ERROR_INVALID_HANDLE
))
509 TerminateThread (itimer
->timer_thread
, 0);
513 CloseHandle (itimer
->timer_thread
);
514 itimer
->timer_thread
= NULL
;
515 if (itimer
->caller_thread
)
517 CloseHandle (itimer
->caller_thread
);
518 itimer
->caller_thread
= NULL
;
522 /* This is called at shutdown time from term_ntproc. */
526 if (real_itimer
.timer_thread
)
527 stop_timer_thread (ITIMER_REAL
);
528 if (prof_itimer
.timer_thread
)
529 stop_timer_thread (ITIMER_PROF
);
531 /* We are going to delete the critical sections, so timers cannot
535 DeleteCriticalSection (&crit_real
);
536 DeleteCriticalSection (&crit_prof
);
537 DeleteCriticalSection (&crit_sig
);
540 /* This is called at initialization time from init_ntproc. */
544 /* GetThreadTimes is not available on all versions of Windows, so
545 need to probe for its availability dynamically, and call it
546 through a pointer. */
547 s_pfn_Get_Thread_Times
= NULL
; /* in case dumped Emacs comes with a value */
548 if (os_subtype
!= OS_9X
)
549 s_pfn_Get_Thread_Times
=
550 (GetThreadTimes_Proc
)GetProcAddress (GetModuleHandle ("kernel32.dll"),
553 /* Make sure we start with zeroed out itimer structures, since
554 dumping may have left there traces of threads long dead. */
555 memset (&real_itimer
, 0, sizeof real_itimer
);
556 memset (&prof_itimer
, 0, sizeof prof_itimer
);
558 InitializeCriticalSection (&crit_real
);
559 InitializeCriticalSection (&crit_prof
);
560 InitializeCriticalSection (&crit_sig
);
566 start_timer_thread (int which
)
568 DWORD exit_code
, tid
;
570 struct itimer_data
*itimer
=
571 (which
== ITIMER_REAL
) ? &real_itimer
: &prof_itimer
;
573 if (itimer
->timer_thread
574 && GetExitCodeThread (itimer
->timer_thread
, &exit_code
)
575 && exit_code
== STILL_ACTIVE
)
578 /* Clean up after possibly exited thread. */
579 if (itimer
->timer_thread
)
581 CloseHandle (itimer
->timer_thread
);
582 itimer
->timer_thread
= NULL
;
584 if (itimer
->caller_thread
)
586 CloseHandle (itimer
->caller_thread
);
587 itimer
->caller_thread
= NULL
;
590 /* Start a new thread. */
591 if (!DuplicateHandle (GetCurrentProcess (), GetCurrentThread (),
592 GetCurrentProcess (), &th
, 0, FALSE
,
593 DUPLICATE_SAME_ACCESS
))
598 itimer
->terminate
= 0;
599 itimer
->type
= which
;
600 itimer
->caller_thread
= th
;
601 /* Request that no more than 64KB of stack be reserved for this
602 thread, to avoid reserving too much memory, which would get in
603 the way of threads we start to wait for subprocesses. See also
605 itimer
->timer_thread
= CreateThread (NULL
, 64 * 1024, timer_loop
,
606 (void *)itimer
, 0x00010000, &tid
);
608 if (!itimer
->timer_thread
)
610 CloseHandle (itimer
->caller_thread
);
611 itimer
->caller_thread
= NULL
;
616 /* This is needed to make sure that the timer thread running for
617 profiling gets CPU as soon as the Sleep call terminates. */
618 if (which
== ITIMER_PROF
)
619 SetThreadPriority (itimer
->timer_thread
, THREAD_PRIORITY_TIME_CRITICAL
);
624 /* Most of the code of getitimer and setitimer (but not of their
625 subroutines) was shamelessly stolen from itimer.c in the DJGPP
626 library, see www.delorie.com/djgpp. */
628 getitimer (int which
, struct itimerval
*value
)
630 volatile ULONGLONG
*t_expire
;
631 volatile ULONGLONG
*t_reload
;
632 ULONGLONG expire
, reload
;
634 CRITICAL_SECTION
*crit
;
635 struct itimer_data
*itimer
;
646 if (which
!= ITIMER_REAL
&& which
!= ITIMER_PROF
)
652 itimer
= (which
== ITIMER_REAL
) ? &real_itimer
: &prof_itimer
;
654 ticks_now
= w32_get_timer_time ((which
== ITIMER_REAL
)
656 : GetCurrentThread ());
658 t_expire
= &itimer
->expire
;
659 t_reload
= &itimer
->reload
;
660 crit
= (which
== ITIMER_REAL
) ? &crit_real
: &crit_prof
;
662 EnterCriticalSection (crit
);
665 LeaveCriticalSection (crit
);
670 value
->it_value
.tv_sec
= expire
/ TIMER_TICKS_PER_SEC
;
672 (expire
% TIMER_TICKS_PER_SEC
) * (__int64
)1000000 / TIMER_TICKS_PER_SEC
;
673 value
->it_value
.tv_usec
= usecs
;
674 value
->it_interval
.tv_sec
= reload
/ TIMER_TICKS_PER_SEC
;
676 (reload
% TIMER_TICKS_PER_SEC
) * (__int64
)1000000 / TIMER_TICKS_PER_SEC
;
677 value
->it_interval
.tv_usec
= usecs
;
683 setitimer(int which
, struct itimerval
*value
, struct itimerval
*ovalue
)
685 volatile ULONGLONG
*t_expire
, *t_reload
;
686 ULONGLONG expire
, reload
, expire_old
, reload_old
;
688 CRITICAL_SECTION
*crit
;
689 struct itimerval tem
, *ptem
;
694 /* Posix systems expect timer values smaller than the resolution of
695 the system clock be rounded up to the clock resolution. First
696 time we are called, measure the clock tick resolution. */
701 for (t1
= w32_get_timer_time (NULL
);
702 (t2
= w32_get_timer_time (NULL
)) == t1
; )
704 clocks_min
= t2
- t1
;
712 if (getitimer (which
, ptem
)) /* also sets ticks_now */
713 return -1; /* errno already set */
716 (which
== ITIMER_REAL
) ? &real_itimer
.expire
: &prof_itimer
.expire
;
718 (which
== ITIMER_REAL
) ? &real_itimer
.reload
: &prof_itimer
.reload
;
720 crit
= (which
== ITIMER_REAL
) ? &crit_real
: &crit_prof
;
723 || (value
->it_value
.tv_sec
== 0 && value
->it_value
.tv_usec
== 0))
725 EnterCriticalSection (crit
);
726 /* Disable the timer. */
729 LeaveCriticalSection (crit
);
733 reload
= value
->it_interval
.tv_sec
* TIMER_TICKS_PER_SEC
;
735 usecs
= value
->it_interval
.tv_usec
;
736 if (value
->it_interval
.tv_sec
== 0
737 && usecs
&& usecs
* TIMER_TICKS_PER_SEC
< clocks_min
* 1000000)
741 usecs
*= TIMER_TICKS_PER_SEC
;
742 reload
+= usecs
/ 1000000;
745 expire
= value
->it_value
.tv_sec
* TIMER_TICKS_PER_SEC
;
746 usecs
= value
->it_value
.tv_usec
;
747 if (value
->it_value
.tv_sec
== 0
748 && usecs
* TIMER_TICKS_PER_SEC
< clocks_min
* 1000000)
752 usecs
*= TIMER_TICKS_PER_SEC
;
753 expire
+= usecs
/ 1000000;
758 EnterCriticalSection (crit
);
759 expire_old
= *t_expire
;
760 reload_old
= *t_reload
;
761 if (!(expire
== expire_old
&& reload
== reload_old
))
766 LeaveCriticalSection (crit
);
768 return start_timer_thread (which
);
774 #ifdef HAVE_SETITIMER
775 struct itimerval new_values
, old_values
;
777 new_values
.it_value
.tv_sec
= seconds
;
778 new_values
.it_value
.tv_usec
= 0;
779 new_values
.it_interval
.tv_sec
= new_values
.it_interval
.tv_usec
= 0;
781 if (setitimer (ITIMER_REAL
, &new_values
, &old_values
) < 0)
783 return old_values
.it_value
.tv_sec
;
789 /* Defined in <process.h> which conflicts with the local copy */
792 /* Child process management list. */
793 int child_proc_count
= 0;
794 child_process child_procs
[ MAX_CHILDREN
];
796 static DWORD WINAPI
reader_thread (void *arg
);
798 /* Find an unused process slot. */
805 for (cp
= child_procs
+ (child_proc_count
-1); cp
>= child_procs
; cp
--)
806 if (!CHILD_ACTIVE (cp
) && cp
->procinfo
.hProcess
== NULL
)
808 if (child_proc_count
== MAX_CHILDREN
)
811 child_process
*dead_cp
= NULL
;
813 DebPrint (("new_child: No vacant slots, looking for dead processes\n"));
814 for (cp
= child_procs
+ (child_proc_count
-1); cp
>= child_procs
; cp
--)
815 if (!CHILD_ACTIVE (cp
) && cp
->procinfo
.hProcess
)
819 if (!GetExitCodeProcess (cp
->procinfo
.hProcess
, &status
))
821 DebPrint (("new_child.GetExitCodeProcess: error %lu for PID %lu\n",
822 GetLastError (), cp
->procinfo
.dwProcessId
));
823 status
= STILL_ACTIVE
;
825 if (status
!= STILL_ACTIVE
826 || WaitForSingleObject (cp
->procinfo
.hProcess
, 0) == WAIT_OBJECT_0
)
828 DebPrint (("new_child: Freeing slot of dead process %d, fd %d\n",
829 cp
->procinfo
.dwProcessId
, cp
->fd
));
830 CloseHandle (cp
->procinfo
.hProcess
);
831 cp
->procinfo
.hProcess
= NULL
;
832 CloseHandle (cp
->procinfo
.hThread
);
833 cp
->procinfo
.hThread
= NULL
;
834 /* Free up to 2 dead slots at a time, so that if we
835 have a lot of them, they will eventually all be
836 freed when the tornado ends. */
850 if (child_proc_count
== MAX_CHILDREN
)
852 cp
= &child_procs
[child_proc_count
++];
855 /* Last opportunity to avoid leaking handles before we forget them
857 if (cp
->procinfo
.hProcess
)
858 CloseHandle (cp
->procinfo
.hProcess
);
859 if (cp
->procinfo
.hThread
)
860 CloseHandle (cp
->procinfo
.hThread
);
861 memset (cp
, 0, sizeof (*cp
));
864 cp
->procinfo
.hProcess
= NULL
;
865 cp
->status
= STATUS_READ_ERROR
;
867 /* use manual reset event so that select() will function properly */
868 cp
->char_avail
= CreateEvent (NULL
, TRUE
, FALSE
, NULL
);
871 cp
->char_consumed
= CreateEvent (NULL
, FALSE
, FALSE
, NULL
);
872 if (cp
->char_consumed
)
874 /* The 0x00010000 flag is STACK_SIZE_PARAM_IS_A_RESERVATION.
875 It means that the 64K stack we are requesting in the 2nd
876 argument is how much memory should be reserved for the
877 stack. If we don't use this flag, the memory requested
878 by the 2nd argument is the amount actually _committed_,
879 but Windows reserves 8MB of memory for each thread's
880 stack. (The 8MB figure comes from the -stack
881 command-line argument we pass to the linker when building
882 Emacs, but that's because we need a large stack for
883 Emacs's main thread.) Since we request 2GB of reserved
884 memory at startup (see w32heap.c), which is close to the
885 maximum memory available for a 32-bit process on Windows,
886 the 8MB reservation for each thread causes failures in
887 starting subprocesses, because we create a thread running
888 reader_thread for each subprocess. As 8MB of stack is
889 way too much for reader_thread, forcing Windows to
890 reserve less wins the day. */
891 cp
->thrd
= CreateThread (NULL
, 64 * 1024, reader_thread
, cp
,
902 delete_child (child_process
*cp
)
906 /* Should not be deleting a child that is still needed. */
907 for (i
= 0; i
< MAXDESC
; i
++)
908 if (fd_info
[i
].cp
== cp
)
911 if (!CHILD_ACTIVE (cp
) && cp
->procinfo
.hProcess
== NULL
)
914 /* reap thread if necessary */
919 if (GetExitCodeThread (cp
->thrd
, &rc
) && rc
== STILL_ACTIVE
)
921 /* let the thread exit cleanly if possible */
922 cp
->status
= STATUS_READ_ERROR
;
923 SetEvent (cp
->char_consumed
);
925 /* We used to forcibly terminate the thread here, but it
926 is normally unnecessary, and in abnormal cases, the worst that
927 will happen is we have an extra idle thread hanging around
928 waiting for the zombie process. */
929 if (WaitForSingleObject (cp
->thrd
, 1000) != WAIT_OBJECT_0
)
931 DebPrint (("delete_child.WaitForSingleObject (thread) failed "
932 "with %lu for fd %ld\n", GetLastError (), cp
->fd
));
933 TerminateThread (cp
->thrd
, 0);
937 CloseHandle (cp
->thrd
);
942 CloseHandle (cp
->char_avail
);
943 cp
->char_avail
= NULL
;
945 if (cp
->char_consumed
)
947 CloseHandle (cp
->char_consumed
);
948 cp
->char_consumed
= NULL
;
951 /* update child_proc_count (highest numbered slot in use plus one) */
952 if (cp
== child_procs
+ child_proc_count
- 1)
954 for (i
= child_proc_count
-1; i
>= 0; i
--)
955 if (CHILD_ACTIVE (&child_procs
[i
])
956 || child_procs
[i
].procinfo
.hProcess
!= NULL
)
958 child_proc_count
= i
+ 1;
963 child_proc_count
= 0;
966 /* Find a child by pid. */
967 static child_process
*
968 find_child_pid (DWORD pid
)
972 for (cp
= child_procs
+ (child_proc_count
-1); cp
>= child_procs
; cp
--)
973 if ((CHILD_ACTIVE (cp
) || cp
->procinfo
.hProcess
!= NULL
)
980 release_listen_threads (void)
984 for (i
= child_proc_count
- 1; i
>= 0; i
--)
986 if (CHILD_ACTIVE (&child_procs
[i
])
987 && (fd_info
[child_procs
[i
].fd
].flags
& FILE_LISTEN
))
988 child_procs
[i
].status
= STATUS_READ_ERROR
;
992 /* Thread proc for child process and socket reader threads. Each thread
993 is normally blocked until woken by select() to check for input by
994 reading one char. When the read completes, char_avail is signaled
995 to wake up the select emulator and the thread blocks itself again. */
997 reader_thread (void *arg
)
1002 cp
= (child_process
*)arg
;
1004 /* We have to wait for the go-ahead before we can start */
1006 || WaitForSingleObject (cp
->char_consumed
, INFINITE
) != WAIT_OBJECT_0
1014 if (cp
->fd
>= 0 && (fd_info
[cp
->fd
].flags
& FILE_CONNECT
) != 0)
1015 rc
= _sys_wait_connect (cp
->fd
);
1016 else if (cp
->fd
>= 0 && (fd_info
[cp
->fd
].flags
& FILE_LISTEN
) != 0)
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
|| rc
== STATUS_CONNECT_FAILED
)
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
1064 directory the new process should start in. This is set just before
1065 calling sys_spawnve, and is not generally valid at any other time.
1066 Note that this directory's name is UTF-8 encoded. */
1067 static char * process_dir
;
1070 create_child (char *exe
, char *cmdline
, char *env
, int is_gui_app
,
1071 pid_t
* pPid
, child_process
*cp
)
1074 SECURITY_ATTRIBUTES sec_attrs
;
1076 SECURITY_DESCRIPTOR sec_desc
;
1079 char dir
[ MAX_PATH
];
1083 if (cp
== NULL
) emacs_abort ();
1085 memset (&start
, 0, sizeof (start
));
1086 start
.cb
= sizeof (start
);
1089 if (NILP (Vw32_start_process_show_window
) && !is_gui_app
)
1090 start
.dwFlags
= STARTF_USESTDHANDLES
| STARTF_USESHOWWINDOW
;
1092 start
.dwFlags
= STARTF_USESTDHANDLES
;
1093 start
.wShowWindow
= SW_HIDE
;
1095 start
.hStdInput
= GetStdHandle (STD_INPUT_HANDLE
);
1096 start
.hStdOutput
= GetStdHandle (STD_OUTPUT_HANDLE
);
1097 start
.hStdError
= GetStdHandle (STD_ERROR_HANDLE
);
1098 #endif /* HAVE_NTGUI */
1101 /* Explicitly specify no security */
1102 if (!InitializeSecurityDescriptor (&sec_desc
, SECURITY_DESCRIPTOR_REVISION
))
1104 if (!SetSecurityDescriptorDacl (&sec_desc
, TRUE
, NULL
, FALSE
))
1107 sec_attrs
.nLength
= sizeof (sec_attrs
);
1108 sec_attrs
.lpSecurityDescriptor
= NULL
/* &sec_desc */;
1109 sec_attrs
.bInheritHandle
= FALSE
;
1111 filename_to_ansi (process_dir
, dir
);
1112 /* Can't use unixtodos_filename here, since that needs its file name
1113 argument encoded in UTF-8. OTOH, process_dir, which _is_ in
1114 UTF-8, points, to the directory computed by our caller, and we
1115 don't want to modify that, either. */
1116 for (p
= dir
; *p
; p
= CharNextA (p
))
1120 /* CreateProcess handles batch files as exe specially. This special
1121 handling fails when both the batch file and arguments are quoted.
1122 We pass NULL as exe to avoid the special handling. */
1123 if (exe
&& cmdline
[0] == '"' &&
1124 (ext
= strrchr (exe
, '.')) &&
1125 (xstrcasecmp (ext
, ".bat") == 0
1126 || xstrcasecmp (ext
, ".cmd") == 0))
1129 flags
= (!NILP (Vw32_start_process_share_console
)
1130 ? CREATE_NEW_PROCESS_GROUP
1131 : CREATE_NEW_CONSOLE
);
1132 if (NILP (Vw32_start_process_inherit_error_mode
))
1133 flags
|= CREATE_DEFAULT_ERROR_MODE
;
1134 if (!CreateProcessA (exe
, cmdline
, &sec_attrs
, NULL
, TRUE
,
1135 flags
, env
, dir
, &start
, &cp
->procinfo
))
1138 cp
->pid
= (int) cp
->procinfo
.dwProcessId
;
1140 /* Hack for Windows 95, which assigns large (ie negative) pids */
1149 DebPrint (("create_child.CreateProcess failed: %ld\n", GetLastError ()););
1153 /* create_child doesn't know what emacs's file handle will be for waiting
1154 on output from the child, so we need to make this additional call
1155 to register the handle with the process
1156 This way the select emulator knows how to match file handles with
1157 entries in child_procs. */
1159 register_child (pid_t pid
, int fd
)
1163 cp
= find_child_pid ((DWORD
)pid
);
1166 DebPrint (("register_child unable to find pid %lu\n", pid
));
1171 DebPrint (("register_child registered fd %d with pid %lu\n", fd
, pid
));
1176 /* thread is initially blocked until select is called; set status so
1177 that select will release thread */
1178 cp
->status
= STATUS_READ_ACKNOWLEDGED
;
1180 /* attach child_process to fd_info */
1181 if (fd_info
[fd
].cp
!= NULL
)
1183 DebPrint (("register_child: fd_info[%d] apparently in use!\n", fd
));
1187 fd_info
[fd
].cp
= cp
;
1190 /* Called from waitpid when a process exits. */
1192 reap_subprocess (child_process
*cp
)
1194 if (cp
->procinfo
.hProcess
)
1196 /* Reap the process */
1198 /* Process should have already died before we are called. */
1199 if (WaitForSingleObject (cp
->procinfo
.hProcess
, 0) != WAIT_OBJECT_0
)
1200 DebPrint (("reap_subprocess: child for fd %d has not died yet!", cp
->fd
));
1202 CloseHandle (cp
->procinfo
.hProcess
);
1203 cp
->procinfo
.hProcess
= NULL
;
1204 CloseHandle (cp
->procinfo
.hThread
);
1205 cp
->procinfo
.hThread
= NULL
;
1208 /* If cp->fd was not closed yet, we might be still reading the
1209 process output, so don't free its resources just yet. The call
1210 to delete_child on behalf of this subprocess will be made by
1211 sys_read when the subprocess output is fully read. */
1216 /* Wait for a child process specified by PID, or for any of our
1217 existing child processes (if PID is nonpositive) to die. When it
1218 does, close its handle. Return the pid of the process that died
1219 and fill in STATUS if non-NULL. */
1222 waitpid (pid_t pid
, int *status
, int options
)
1224 DWORD active
, retval
;
1226 child_process
*cp
, *cps
[MAX_CHILDREN
];
1227 HANDLE wait_hnd
[MAX_CHILDREN
];
1229 int dont_wait
= (options
& WNOHANG
) != 0;
1232 /* According to Posix:
1234 PID = -1 means status is requested for any child process.
1236 PID > 0 means status is requested for a single child process
1239 PID = 0 means status is requested for any child process whose
1240 process group ID is equal to that of the calling process. But
1241 since Windows has only a limited support for process groups (only
1242 for console processes and only for the purposes of passing
1243 Ctrl-BREAK signal to them), and since we have no documented way
1244 of determining whether a given process belongs to our group, we
1247 PID < -1 means status is requested for any child process whose
1248 process group ID is equal to the absolute value of PID. Again,
1249 since we don't support process groups, we treat that as -1. */
1254 /* We are requested to wait for a specific child. */
1255 for (cp
= child_procs
+ (child_proc_count
-1); cp
>= child_procs
; cp
--)
1257 /* Some child_procs might be sockets; ignore them. Also
1258 ignore subprocesses whose output is not yet completely
1260 if (CHILD_ACTIVE (cp
)
1261 && cp
->procinfo
.hProcess
1270 if (cp
->fd
< 0 || (fd_info
[cp
->fd
].flags
& FILE_AT_EOF
) != 0)
1272 wait_hnd
[nh
] = cp
->procinfo
.hProcess
;
1278 /* PID specifies our subprocess, but its status is not
1285 /* No such child process, or nothing to wait for, so fail. */
1292 for (cp
= child_procs
+ (child_proc_count
-1); cp
>= child_procs
; cp
--)
1294 if (CHILD_ACTIVE (cp
)
1295 && cp
->procinfo
.hProcess
1296 && (cp
->fd
< 0 || (fd_info
[cp
->fd
].flags
& FILE_AT_EOF
) != 0))
1298 wait_hnd
[nh
] = cp
->procinfo
.hProcess
;
1305 /* Nothing to wait on, so fail. */
1314 timeout_ms
= 1000; /* check for quit about once a second. */
1319 active
= WaitForMultipleObjects (nh
, wait_hnd
, FALSE
, timeout_ms
);
1320 } while (active
== WAIT_TIMEOUT
&& !dont_wait
);
1322 if (active
== WAIT_FAILED
)
1327 else if (active
== WAIT_TIMEOUT
&& dont_wait
)
1329 /* PID specifies our subprocess, but it didn't exit yet, so its
1330 status is not yet available. */
1332 DebPrint (("Wait: PID %d not reap yet\n", cp
->pid
));
1336 else if (active
>= WAIT_OBJECT_0
1337 && active
< WAIT_OBJECT_0
+MAXIMUM_WAIT_OBJECTS
)
1339 active
-= WAIT_OBJECT_0
;
1341 else if (active
>= WAIT_ABANDONED_0
1342 && active
< WAIT_ABANDONED_0
+MAXIMUM_WAIT_OBJECTS
)
1344 active
-= WAIT_ABANDONED_0
;
1349 if (!GetExitCodeProcess (wait_hnd
[active
], &retval
))
1351 DebPrint (("Wait.GetExitCodeProcess failed with %lu\n",
1355 if (retval
== STILL_ACTIVE
)
1357 /* Should never happen. */
1358 DebPrint (("Wait.WaitForMultipleObjects returned an active process\n"));
1359 if (pid
> 0 && dont_wait
)
1365 /* Massage the exit code from the process to match the format expected
1366 by the WIFSTOPPED et al macros in syswait.h. Only WIFSIGNALED and
1367 WIFEXITED are supported; WIFSTOPPED doesn't make sense under NT. */
1369 if (retval
== STATUS_CONTROL_C_EXIT
)
1374 if (pid
> 0 && active
!= 0)
1379 DebPrint (("Wait signaled with process pid %d\n", cp
->pid
));
1384 reap_subprocess (cp
);
1389 /* Old versions of w32api headers don't have separate 32-bit and
1390 64-bit defines, but the one they have matches the 32-bit variety. */
1391 #ifndef IMAGE_NT_OPTIONAL_HDR32_MAGIC
1392 # define IMAGE_NT_OPTIONAL_HDR32_MAGIC IMAGE_NT_OPTIONAL_HDR_MAGIC
1393 # define IMAGE_OPTIONAL_HEADER32 IMAGE_OPTIONAL_HEADER
1396 /* Implementation note: This function works with file names encoded in
1397 the current ANSI codepage. */
1399 w32_executable_type (char * filename
,
1401 int * is_cygnus_app
,
1404 file_data executable
;
1407 /* Default values in case we can't tell for sure. */
1408 *is_dos_app
= FALSE
;
1409 *is_cygnus_app
= FALSE
;
1410 *is_gui_app
= FALSE
;
1412 if (!open_input_file (&executable
, filename
))
1415 p
= strrchr (filename
, '.');
1417 /* We can only identify DOS .com programs from the extension. */
1418 if (p
&& xstrcasecmp (p
, ".com") == 0)
1420 else if (p
&& (xstrcasecmp (p
, ".bat") == 0
1421 || xstrcasecmp (p
, ".cmd") == 0))
1423 /* A DOS shell script - it appears that CreateProcess is happy to
1424 accept this (somewhat surprisingly); presumably it looks at
1425 COMSPEC to determine what executable to actually invoke.
1426 Therefore, we have to do the same here as well. */
1427 /* Actually, I think it uses the program association for that
1428 extension, which is defined in the registry. */
1429 p
= egetenv ("COMSPEC");
1431 w32_executable_type (p
, is_dos_app
, is_cygnus_app
, is_gui_app
);
1435 /* Look for DOS .exe signature - if found, we must also check that
1436 it isn't really a 16- or 32-bit Windows exe, since both formats
1437 start with a DOS program stub. Note that 16-bit Windows
1438 executables use the OS/2 1.x format. */
1440 IMAGE_DOS_HEADER
* dos_header
;
1441 IMAGE_NT_HEADERS
* nt_header
;
1443 dos_header
= (PIMAGE_DOS_HEADER
) executable
.file_base
;
1444 if (dos_header
->e_magic
!= IMAGE_DOS_SIGNATURE
)
1447 nt_header
= (PIMAGE_NT_HEADERS
) ((unsigned char *) dos_header
+ dos_header
->e_lfanew
);
1449 if ((char *) nt_header
> (char *) dos_header
+ executable
.size
)
1451 /* Some dos headers (pkunzip) have bogus e_lfanew fields. */
1454 else if (nt_header
->Signature
!= IMAGE_NT_SIGNATURE
1455 && LOWORD (nt_header
->Signature
) != IMAGE_OS2_SIGNATURE
)
1459 else if (nt_header
->Signature
== IMAGE_NT_SIGNATURE
)
1461 IMAGE_DATA_DIRECTORY
*data_dir
= NULL
;
1462 if (nt_header
->OptionalHeader
.Magic
== IMAGE_NT_OPTIONAL_HDR32_MAGIC
)
1464 /* Ensure we are using the 32 bit structure. */
1465 IMAGE_OPTIONAL_HEADER32
*opt
1466 = (IMAGE_OPTIONAL_HEADER32
*) &(nt_header
->OptionalHeader
);
1467 data_dir
= opt
->DataDirectory
;
1468 *is_gui_app
= (opt
->Subsystem
== IMAGE_SUBSYSTEM_WINDOWS_GUI
);
1470 /* MingW 3.12 has the required 64 bit structs, but in case older
1471 versions don't, only check 64 bit exes if we know how. */
1472 #ifdef IMAGE_NT_OPTIONAL_HDR64_MAGIC
1473 else if (nt_header
->OptionalHeader
.Magic
1474 == IMAGE_NT_OPTIONAL_HDR64_MAGIC
)
1476 IMAGE_OPTIONAL_HEADER64
*opt
1477 = (IMAGE_OPTIONAL_HEADER64
*) &(nt_header
->OptionalHeader
);
1478 data_dir
= opt
->DataDirectory
;
1479 *is_gui_app
= (opt
->Subsystem
== IMAGE_SUBSYSTEM_WINDOWS_GUI
);
1484 /* Look for cygwin.dll in DLL import list. */
1485 IMAGE_DATA_DIRECTORY import_dir
=
1486 data_dir
[IMAGE_DIRECTORY_ENTRY_IMPORT
];
1487 IMAGE_IMPORT_DESCRIPTOR
* imports
;
1488 IMAGE_SECTION_HEADER
* section
;
1490 section
= rva_to_section (import_dir
.VirtualAddress
, nt_header
);
1491 imports
= RVA_TO_PTR (import_dir
.VirtualAddress
, section
,
1494 for ( ; imports
->Name
; imports
++)
1496 char * dllname
= RVA_TO_PTR (imports
->Name
, section
,
1499 /* The exact name of the cygwin dll has changed with
1500 various releases, but hopefully this will be reasonably
1502 if (strncmp (dllname
, "cygwin", 6) == 0)
1504 *is_cygnus_app
= TRUE
;
1513 close_file_data (&executable
);
1517 compare_env (const void *strp1
, const void *strp2
)
1519 const char *str1
= *(const char **)strp1
, *str2
= *(const char **)strp2
;
1521 while (*str1
&& *str2
&& *str1
!= '=' && *str2
!= '=')
1523 /* Sort order in command.com/cmd.exe is based on uppercasing
1524 names, so do the same here. */
1525 if (toupper (*str1
) > toupper (*str2
))
1527 else if (toupper (*str1
) < toupper (*str2
))
1532 if (*str1
== '=' && *str2
== '=')
1534 else if (*str1
== '=')
1541 merge_and_sort_env (char **envp1
, char **envp2
, char **new_envp
)
1543 char **optr
, **nptr
;
1555 num
+= optr
- envp2
;
1557 qsort (new_envp
, num
, sizeof (char *), compare_env
);
1562 /* When a new child process is created we need to register it in our list,
1563 so intercept spawn requests. */
1565 sys_spawnve (int mode
, char *cmdname
, char **argv
, char **envp
)
1567 Lisp_Object program
, full
;
1568 char *cmdline
, *env
, *parg
, **targ
;
1572 int is_dos_app
, is_cygnus_app
, is_gui_app
;
1574 /* We pass our process ID to our children by setting up an environment
1575 variable in their environment. */
1576 char ppid_env_var_buffer
[64];
1577 char *extra_env
[] = {ppid_env_var_buffer
, NULL
};
1578 /* These are the characters that cause an argument to need quoting.
1579 Arguments with whitespace characters need quoting to prevent the
1580 argument being split into two or more. Arguments with wildcards
1581 are also quoted, for consistency with posix platforms, where wildcards
1582 are not expanded if we run the program directly without a shell.
1583 Some extra whitespace characters need quoting in Cygwin programs,
1584 so this list is conditionally modified below. */
1585 char *sepchars
= " \t*?";
1586 /* This is for native w32 apps; modified below for Cygwin apps. */
1587 char escape_char
= '\\';
1588 char cmdname_a
[MAX_PATH
];
1590 /* We don't care about the other modes */
1591 if (mode
!= _P_NOWAIT
)
1597 /* Handle executable names without an executable suffix. The caller
1598 already searched exec-path and verified the file is executable,
1599 but start-process doesn't do that for file names that are already
1600 absolute. So we double-check this here, just in case. */
1601 if (faccessat (AT_FDCWD
, cmdname
, X_OK
, AT_EACCESS
) != 0)
1603 struct gcpro gcpro1
;
1605 program
= build_string (cmdname
);
1608 openp (Vexec_path
, program
, Vexec_suffixes
, &full
, make_number (X_OK
), 0);
1615 program
= ENCODE_FILE (full
);
1616 cmdname
= SDATA (program
);
1620 char *p
= alloca (strlen (cmdname
) + 1);
1622 /* Don't change the command name we were passed by our caller
1623 (unixtodos_filename below will destructively mirror forward
1625 cmdname
= strcpy (p
, cmdname
);
1628 /* make sure argv[0] and cmdname are both in DOS format */
1629 unixtodos_filename (cmdname
);
1630 /* argv[0] was encoded by caller using ENCODE_FILE, so it is in
1631 UTF-8. All the other arguments are encoded by ENCODE_SYSTEM or
1632 some such, and are in some ANSI codepage. We need to have
1633 argv[0] encoded in ANSI codepage. */
1634 filename_to_ansi (cmdname
, cmdname_a
);
1635 /* We explicitly require that the command's file name be encodable
1636 in the current ANSI codepage, because we will be invoking it via
1638 if (_mbspbrk (cmdname_a
, "?"))
1643 /* From here on, CMDNAME is an ANSI-encoded string. */
1644 cmdname
= cmdname_a
;
1647 /* Determine whether program is a 16-bit DOS executable, or a 32-bit Windows
1648 executable that is implicitly linked to the Cygnus dll (implying it
1649 was compiled with the Cygnus GNU toolchain and hence relies on
1650 cygwin.dll to parse the command line - we use this to decide how to
1651 escape quote chars in command line args that must be quoted).
1653 Also determine whether it is a GUI app, so that we don't hide its
1654 initial window unless specifically requested. */
1655 w32_executable_type (cmdname
, &is_dos_app
, &is_cygnus_app
, &is_gui_app
);
1657 /* On Windows 95, if cmdname is a DOS app, we invoke a helper
1658 application to start it by specifying the helper app as cmdname,
1659 while leaving the real app name as argv[0]. */
1664 cmdname
= alloca (MAX_PATH
);
1665 if (egetenv ("CMDPROXY"))
1666 strcpy (cmdname
, egetenv ("CMDPROXY"));
1668 strcpy (lispstpcpy (cmdname
, Vinvocation_directory
), "cmdproxy.exe");
1670 /* Can't use unixtodos_filename here, since that needs its file
1671 name argument encoded in UTF-8. */
1672 for (p
= cmdname
; *p
; p
= CharNextA (p
))
1677 /* we have to do some conjuring here to put argv and envp into the
1678 form CreateProcess wants... argv needs to be a space separated/null
1679 terminated list of parameters, and envp is a null
1680 separated/double-null terminated list of parameters.
1682 Additionally, zero-length args and args containing whitespace or
1683 quote chars need to be wrapped in double quotes - for this to work,
1684 embedded quotes need to be escaped as well. The aim is to ensure
1685 the child process reconstructs the argv array we start with
1686 exactly, so we treat quotes at the beginning and end of arguments
1689 The w32 GNU-based library from Cygnus doubles quotes to escape
1690 them, while MSVC uses backslash for escaping. (Actually the MSVC
1691 startup code does attempt to recognize doubled quotes and accept
1692 them, but gets it wrong and ends up requiring three quotes to get a
1693 single embedded quote!) So by default we decide whether to use
1694 quote or backslash as the escape character based on whether the
1695 binary is apparently a Cygnus compiled app.
1697 Note that using backslash to escape embedded quotes requires
1698 additional special handling if an embedded quote is already
1699 preceded by backslash, or if an arg requiring quoting ends with
1700 backslash. In such cases, the run of escape characters needs to be
1701 doubled. For consistency, we apply this special handling as long
1702 as the escape character is not quote.
1704 Since we have no idea how large argv and envp are likely to be we
1705 figure out list lengths on the fly and allocate them. */
1707 if (!NILP (Vw32_quote_process_args
))
1710 /* Override escape char by binding w32-quote-process-args to
1711 desired character, or use t for auto-selection. */
1712 if (INTEGERP (Vw32_quote_process_args
))
1713 escape_char
= XINT (Vw32_quote_process_args
);
1715 escape_char
= is_cygnus_app
? '"' : '\\';
1718 /* Cygwin apps needs quoting a bit more often. */
1719 if (escape_char
== '"')
1720 sepchars
= "\r\n\t\f '";
1728 int need_quotes
= 0;
1729 int escape_char_run
= 0;
1735 if (escape_char
== '"' && *p
== '\\')
1736 /* If it's a Cygwin app, \ needs to be escaped. */
1740 /* allow for embedded quotes to be escaped */
1743 /* handle the case where the embedded quote is already escaped */
1744 if (escape_char_run
> 0)
1746 /* To preserve the arg exactly, we need to double the
1747 preceding escape characters (plus adding one to
1748 escape the quote character itself). */
1749 arglen
+= escape_char_run
;
1752 else if (strchr (sepchars
, *p
) != NULL
)
1757 if (*p
== escape_char
&& escape_char
!= '"')
1760 escape_char_run
= 0;
1765 /* handle the case where the arg ends with an escape char - we
1766 must not let the enclosing quote be escaped. */
1767 if (escape_char_run
> 0)
1768 arglen
+= escape_char_run
;
1770 arglen
+= strlen (*targ
++) + 1;
1772 cmdline
= alloca (arglen
);
1778 int need_quotes
= 0;
1786 if ((strchr (sepchars
, *p
) != NULL
) || *p
== '"')
1791 int escape_char_run
= 0;
1797 /* last = p + strlen (p) - 1; */
1800 /* This version does not escape quotes if they occur at the
1801 beginning or end of the arg - this could lead to incorrect
1802 behavior when the arg itself represents a command line
1803 containing quoted args. I believe this was originally done
1804 as a hack to make some things work, before
1805 `w32-quote-process-args' was added. */
1808 if (*p
== '"' && p
> first
&& p
< last
)
1809 *parg
++ = escape_char
; /* escape embedded quotes */
1817 /* double preceding escape chars if any */
1818 while (escape_char_run
> 0)
1820 *parg
++ = escape_char
;
1823 /* escape all quote chars, even at beginning or end */
1824 *parg
++ = escape_char
;
1826 else if (escape_char
== '"' && *p
== '\\')
1830 if (*p
== escape_char
&& escape_char
!= '"')
1833 escape_char_run
= 0;
1835 /* double escape chars before enclosing quote */
1836 while (escape_char_run
> 0)
1838 *parg
++ = escape_char
;
1846 strcpy (parg
, *targ
);
1847 parg
+= strlen (*targ
);
1857 numenv
= 1; /* for end null */
1860 arglen
+= strlen (*targ
++) + 1;
1863 /* extra env vars... */
1864 sprintf (ppid_env_var_buffer
, "EM_PARENT_PROCESS_ID=%lu",
1865 GetCurrentProcessId ());
1866 arglen
+= strlen (ppid_env_var_buffer
) + 1;
1869 /* merge env passed in and extra env into one, and sort it. */
1870 targ
= (char **) alloca (numenv
* sizeof (char *));
1871 merge_and_sort_env (envp
, extra_env
, targ
);
1873 /* concatenate env entries. */
1874 env
= alloca (arglen
);
1878 strcpy (parg
, *targ
);
1879 parg
+= strlen (*targ
++);
1892 /* Now create the process. */
1893 if (!create_child (cmdname
, cmdline
, env
, is_gui_app
, &pid
, cp
))
1903 /* Emulate the select call
1904 Wait for available input on any of the given rfds, or timeout if
1905 a timeout is given and no input is detected
1906 wfds and efds are not supported and must be NULL.
1908 For simplicity, we detect the death of child processes here and
1909 synchronously call the SIGCHLD handler. Since it is possible for
1910 children to be created without a corresponding pipe handle from which
1911 to read output, we wait separately on the process handles as well as
1912 the char_avail events for each process pipe. We only call
1913 wait/reap_process when the process actually terminates.
1915 To reduce the number of places in which Emacs can be hung such that
1916 C-g is not able to interrupt it, we always wait on interrupt_handle
1917 (which is signaled by the input thread when C-g is detected). If we
1918 detect that we were woken up by C-g, we return -1 with errno set to
1919 EINTR as on Unix. */
1921 /* From w32console.c */
1922 extern HANDLE keyboard_handle
;
1924 /* From w32xfns.c */
1925 extern HANDLE interrupt_handle
;
1927 /* From process.c */
1928 extern int proc_buffered_char
[];
1931 sys_select (int nfds
, SELECT_TYPE
*rfds
, SELECT_TYPE
*wfds
, SELECT_TYPE
*efds
,
1932 struct timespec
*timeout
, void *ignored
)
1934 SELECT_TYPE orfds
, owfds
;
1935 DWORD timeout_ms
, start_time
;
1938 child_process
*cp
, *cps
[MAX_CHILDREN
];
1939 HANDLE wait_hnd
[MAXDESC
+ MAX_CHILDREN
];
1940 int fdindex
[MAXDESC
]; /* mapping from wait handles back to descriptors */
1943 timeout
? (timeout
->tv_sec
* 1000 + timeout
->tv_nsec
/ 1000000) : INFINITE
;
1945 /* If the descriptor sets are NULL but timeout isn't, then just Sleep. */
1946 if (rfds
== NULL
&& wfds
== NULL
&& efds
== NULL
&& timeout
!= NULL
)
1952 /* Otherwise, we only handle rfds and wfds, so fail otherwise. */
1953 if ((rfds
== NULL
&& wfds
== NULL
) || efds
!= NULL
)
1975 /* If interrupt_handle is available and valid, always wait on it, to
1976 detect C-g (quit). */
1978 if (interrupt_handle
&& interrupt_handle
!= INVALID_HANDLE_VALUE
)
1980 wait_hnd
[0] = interrupt_handle
;
1985 /* Build a list of pipe handles to wait on. */
1986 for (i
= 0; i
< nfds
; i
++)
1987 if (FD_ISSET (i
, &orfds
) || FD_ISSET (i
, &owfds
))
1991 if (keyboard_handle
)
1993 /* Handle stdin specially */
1994 wait_hnd
[nh
] = keyboard_handle
;
1999 /* Check for any emacs-generated input in the queue since
2000 it won't be detected in the wait */
2001 if (rfds
&& detect_input_pending ())
2006 else if (noninteractive
)
2008 if (handle_file_notifications (NULL
))
2014 /* Child process and socket/comm port input. */
2016 if (FD_ISSET (i
, &owfds
)
2018 && (fd_info
[i
].flags
&& FILE_CONNECT
) == 0)
2020 DebPrint (("sys_select: fd %d is in wfds, but FILE_CONNECT is reset!\n", i
));
2025 int current_status
= cp
->status
;
2027 if (current_status
== STATUS_READ_ACKNOWLEDGED
)
2029 /* Tell reader thread which file handle to use. */
2031 /* Zero out the error code. */
2033 /* Wake up the reader thread for this process */
2034 cp
->status
= STATUS_READ_READY
;
2035 if (!SetEvent (cp
->char_consumed
))
2036 DebPrint (("sys_select.SetEvent failed with "
2037 "%lu for fd %ld\n", GetLastError (), i
));
2040 #ifdef CHECK_INTERLOCK
2041 /* slightly crude cross-checking of interlock between threads */
2043 current_status
= cp
->status
;
2044 if (WaitForSingleObject (cp
->char_avail
, 0) == WAIT_OBJECT_0
)
2046 /* char_avail has been signaled, so status (which may
2047 have changed) should indicate read has completed
2048 but has not been acknowledged. */
2049 current_status
= cp
->status
;
2050 if (current_status
!= STATUS_READ_SUCCEEDED
2051 && current_status
!= STATUS_READ_FAILED
)
2052 DebPrint (("char_avail set, but read not completed: status %d\n",
2057 /* char_avail has not been signaled, so status should
2058 indicate that read is in progress; small possibility
2059 that read has completed but event wasn't yet signaled
2060 when we tested it (because a context switch occurred
2061 or if running on separate CPUs). */
2062 if (current_status
!= STATUS_READ_READY
2063 && current_status
!= STATUS_READ_IN_PROGRESS
2064 && current_status
!= STATUS_READ_SUCCEEDED
2065 && current_status
!= STATUS_READ_FAILED
)
2066 DebPrint (("char_avail reset, but read status is bad: %d\n",
2070 wait_hnd
[nh
] = cp
->char_avail
;
2072 if (!wait_hnd
[nh
]) emacs_abort ();
2075 DebPrint (("select waiting on child %d fd %d\n",
2076 cp
-child_procs
, i
));
2081 /* Unable to find something to wait on for this fd, skip */
2083 /* Note that this is not a fatal error, and can in fact
2084 happen in unusual circumstances. Specifically, if
2085 sys_spawnve fails, eg. because the program doesn't
2086 exist, and debug-on-error is t so Fsignal invokes a
2087 nested input loop, then the process output pipe is
2088 still included in input_wait_mask with no child_proc
2089 associated with it. (It is removed when the debugger
2090 exits the nested input loop and the error is thrown.) */
2092 DebPrint (("sys_select: fd %ld is invalid! ignoring\n", i
));
2098 /* Add handles of child processes. */
2100 for (cp
= child_procs
+ (child_proc_count
-1); cp
>= child_procs
; cp
--)
2101 /* Some child_procs might be sockets; ignore them. Also some
2102 children may have died already, but we haven't finished reading
2103 the process output; ignore them too. */
2104 if ((CHILD_ACTIVE (cp
) && cp
->procinfo
.hProcess
)
2106 || (fd_info
[cp
->fd
].flags
& FILE_SEND_SIGCHLD
) == 0
2107 || (fd_info
[cp
->fd
].flags
& FILE_AT_EOF
) != 0)
2110 wait_hnd
[nh
+ nc
] = cp
->procinfo
.hProcess
;
2115 /* Nothing to look for, so we didn't find anything */
2122 if (handle_file_notifications (NULL
))
2128 start_time
= GetTickCount ();
2130 /* Wait for input or child death to be signaled. If user input is
2131 allowed, then also accept window messages. */
2132 if (FD_ISSET (0, &orfds
))
2133 active
= MsgWaitForMultipleObjects (nh
+ nc
, wait_hnd
, FALSE
, timeout_ms
,
2136 active
= WaitForMultipleObjects (nh
+ nc
, wait_hnd
, FALSE
, timeout_ms
);
2138 if (active
== WAIT_FAILED
)
2140 DebPrint (("select.WaitForMultipleObjects (%d, %lu) failed with %lu\n",
2141 nh
+ nc
, timeout_ms
, GetLastError ()));
2142 /* don't return EBADF - this causes wait_reading_process_output to
2143 abort; WAIT_FAILED is returned when single-stepping under
2144 Windows 95 after switching thread focus in debugger, and
2145 possibly at other times. */
2149 else if (active
== WAIT_TIMEOUT
)
2153 if (handle_file_notifications (NULL
))
2158 else if (active
>= WAIT_OBJECT_0
2159 && active
< WAIT_OBJECT_0
+MAXIMUM_WAIT_OBJECTS
)
2161 active
-= WAIT_OBJECT_0
;
2163 else if (active
>= WAIT_ABANDONED_0
2164 && active
< WAIT_ABANDONED_0
+MAXIMUM_WAIT_OBJECTS
)
2166 active
-= WAIT_ABANDONED_0
;
2171 /* Loop over all handles after active (now officially documented as
2172 being the first signaled handle in the array). We do this to
2173 ensure fairness, so that all channels with data available will be
2174 processed - otherwise higher numbered channels could be starved. */
2177 if (active
== nh
+ nc
)
2179 /* There are messages in the lisp thread's queue; we must
2180 drain the queue now to ensure they are processed promptly,
2181 because if we don't do so, we will not be woken again until
2182 further messages arrive.
2184 NB. If ever we allow window message procedures to callback
2185 into lisp, we will need to ensure messages are dispatched
2186 at a safe time for lisp code to be run (*), and we may also
2187 want to provide some hooks in the dispatch loop to cater
2188 for modeless dialogs created by lisp (ie. to register
2189 window handles to pass to IsDialogMessage).
2191 (*) Note that MsgWaitForMultipleObjects above is an
2192 internal dispatch point for messages that are sent to
2193 windows created by this thread. */
2194 if (drain_message_queue ()
2195 /* If drain_message_queue returns non-zero, that means
2196 we received a WM_EMACS_FILENOTIFY message. If this
2197 is a TTY frame, we must signal the caller that keyboard
2198 input is available, so that w32_console_read_socket
2199 will be called to pick up the notifications. If we
2200 don't do that, file notifications will only work when
2201 the Emacs TTY frame has focus. */
2202 && FRAME_TERMCAP_P (SELECTED_FRAME ())
2203 /* they asked for stdin reads */
2204 && FD_ISSET (0, &orfds
)
2205 /* the stdin handle is valid */
2213 else if (active
>= nh
)
2215 cp
= cps
[active
- nh
];
2217 /* We cannot always signal SIGCHLD immediately; if we have not
2218 finished reading the process output, we must delay sending
2219 SIGCHLD until we do. */
2221 if (cp
->fd
>= 0 && (fd_info
[cp
->fd
].flags
& FILE_AT_EOF
) == 0)
2222 fd_info
[cp
->fd
].flags
|= FILE_SEND_SIGCHLD
;
2223 /* SIG_DFL for SIGCHLD is ignored */
2224 else if (sig_handlers
[SIGCHLD
] != SIG_DFL
&&
2225 sig_handlers
[SIGCHLD
] != SIG_IGN
)
2228 DebPrint (("select calling SIGCHLD handler for pid %d\n",
2231 sig_handlers
[SIGCHLD
] (SIGCHLD
);
2234 else if (fdindex
[active
] == -1)
2236 /* Quit (C-g) was detected. */
2240 else if (rfds
&& fdindex
[active
] == 0)
2242 /* Keyboard input available */
2248 /* Must be a socket or pipe - read ahead should have
2249 completed, either succeeding or failing. If this handle
2250 was waiting for an async 'connect', reset the connect
2251 flag, so it could read from now on. */
2252 if (wfds
&& (fd_info
[fdindex
[active
]].flags
& FILE_CONNECT
) != 0)
2254 cp
= fd_info
[fdindex
[active
]].cp
;
2257 /* Don't reset the FILE_CONNECT bit and don't
2258 acknowledge the read if the status is
2259 STATUS_CONNECT_FAILED or some other
2260 failure. That's because the thread exits in those
2261 cases, so it doesn't need the ACK, and we want to
2262 keep the FILE_CONNECT bit as evidence that the
2263 connect failed, to be checked in sys_read. */
2264 if (cp
->status
== STATUS_READ_SUCCEEDED
)
2266 fd_info
[cp
->fd
].flags
&= ~FILE_CONNECT
;
2267 cp
->status
= STATUS_READ_ACKNOWLEDGED
;
2269 ResetEvent (cp
->char_avail
);
2271 FD_SET (fdindex
[active
], wfds
);
2274 FD_SET (fdindex
[active
], rfds
);
2278 /* Even though wait_reading_process_output only reads from at most
2279 one channel, we must process all channels here so that we reap
2280 all children that have died. */
2281 while (++active
< nh
+ nc
)
2282 if (WaitForSingleObject (wait_hnd
[active
], 0) == WAIT_OBJECT_0
)
2284 } while (active
< nh
+ nc
);
2288 if (handle_file_notifications (NULL
))
2292 /* If no input has arrived and timeout hasn't expired, wait again. */
2295 DWORD elapsed
= GetTickCount () - start_time
;
2297 if (timeout_ms
> elapsed
) /* INFINITE is MAX_UINT */
2299 if (timeout_ms
!= INFINITE
)
2300 timeout_ms
-= elapsed
;
2301 goto count_children
;
2308 /* Substitute for certain kill () operations */
2310 static BOOL CALLBACK
2311 find_child_console (HWND hwnd
, LPARAM arg
)
2313 child_process
* cp
= (child_process
*) arg
;
2316 GetWindowThreadProcessId (hwnd
, &process_id
);
2317 if (process_id
== cp
->procinfo
.dwProcessId
)
2319 char window_class
[32];
2321 GetClassName (hwnd
, window_class
, sizeof (window_class
));
2322 if (strcmp (window_class
,
2323 (os_subtype
== OS_9X
)
2325 : "ConsoleWindowClass") == 0)
2335 /* Emulate 'kill', but only for other processes. */
2337 sys_kill (pid_t pid
, int sig
)
2341 int need_to_free
= 0;
2344 /* Each process is in its own process group. */
2348 /* Only handle signals that will result in the process dying */
2350 && sig
!= SIGINT
&& sig
!= SIGKILL
&& sig
!= SIGQUIT
&& sig
!= SIGHUP
)
2358 /* It will take _some_ time before PID 4 or less on Windows will
2365 proc_hand
= OpenProcess (PROCESS_QUERY_INFORMATION
, 0, pid
);
2366 if (proc_hand
== NULL
)
2368 DWORD err
= GetLastError ();
2372 case ERROR_ACCESS_DENIED
: /* existing process, but access denied */
2375 case ERROR_INVALID_PARAMETER
: /* process PID does not exist */
2381 CloseHandle (proc_hand
);
2385 cp
= find_child_pid (pid
);
2388 /* We were passed a PID of something other than our subprocess.
2389 If that is our own PID, we will send to ourself a message to
2390 close the selected frame, which does not necessarily
2391 terminates Emacs. But then we are not supposed to call
2392 sys_kill with our own PID. */
2393 proc_hand
= OpenProcess (PROCESS_TERMINATE
, 0, pid
);
2394 if (proc_hand
== NULL
)
2403 proc_hand
= cp
->procinfo
.hProcess
;
2404 pid
= cp
->procinfo
.dwProcessId
;
2406 /* Try to locate console window for process. */
2407 EnumWindows (find_child_console
, (LPARAM
) cp
);
2410 if (sig
== SIGINT
|| sig
== SIGQUIT
)
2412 if (NILP (Vw32_start_process_share_console
) && cp
&& cp
->hwnd
)
2414 BYTE control_scan_code
= (BYTE
) MapVirtualKey (VK_CONTROL
, 0);
2415 /* Fake Ctrl-C for SIGINT, and Ctrl-Break for SIGQUIT. */
2416 BYTE vk_break_code
= (sig
== SIGINT
) ? 'C' : VK_CANCEL
;
2417 BYTE break_scan_code
= (BYTE
) MapVirtualKey (vk_break_code
, 0);
2418 HWND foreground_window
;
2420 if (break_scan_code
== 0)
2422 /* Fake Ctrl-C for SIGQUIT if we can't manage Ctrl-Break. */
2423 vk_break_code
= 'C';
2424 break_scan_code
= (BYTE
) MapVirtualKey (vk_break_code
, 0);
2427 foreground_window
= GetForegroundWindow ();
2428 if (foreground_window
)
2430 /* NT 5.0, and apparently also Windows 98, will not allow
2431 a Window to be set to foreground directly without the
2432 user's involvement. The workaround is to attach
2433 ourselves to the thread that owns the foreground
2434 window, since that is the only thread that can set the
2435 foreground window. */
2436 DWORD foreground_thread
, child_thread
;
2438 GetWindowThreadProcessId (foreground_window
, NULL
);
2439 if (foreground_thread
== GetCurrentThreadId ()
2440 || !AttachThreadInput (GetCurrentThreadId (),
2441 foreground_thread
, TRUE
))
2442 foreground_thread
= 0;
2444 child_thread
= GetWindowThreadProcessId (cp
->hwnd
, NULL
);
2445 if (child_thread
== GetCurrentThreadId ()
2446 || !AttachThreadInput (GetCurrentThreadId (),
2447 child_thread
, TRUE
))
2450 /* Set the foreground window to the child. */
2451 if (SetForegroundWindow (cp
->hwnd
))
2453 /* Generate keystrokes as if user had typed Ctrl-Break or
2455 keybd_event (VK_CONTROL
, control_scan_code
, 0, 0);
2456 keybd_event (vk_break_code
, break_scan_code
,
2457 (vk_break_code
== 'C' ? 0 : KEYEVENTF_EXTENDEDKEY
), 0);
2458 keybd_event (vk_break_code
, break_scan_code
,
2459 (vk_break_code
== 'C' ? 0 : KEYEVENTF_EXTENDEDKEY
)
2460 | KEYEVENTF_KEYUP
, 0);
2461 keybd_event (VK_CONTROL
, control_scan_code
,
2462 KEYEVENTF_KEYUP
, 0);
2464 /* Sleep for a bit to give time for Emacs frame to respond
2465 to focus change events (if Emacs was active app). */
2468 SetForegroundWindow (foreground_window
);
2470 /* Detach from the foreground and child threads now that
2471 the foreground switching is over. */
2472 if (foreground_thread
)
2473 AttachThreadInput (GetCurrentThreadId (),
2474 foreground_thread
, FALSE
);
2476 AttachThreadInput (GetCurrentThreadId (),
2477 child_thread
, FALSE
);
2480 /* Ctrl-Break is NT equivalent of SIGINT. */
2481 else if (!GenerateConsoleCtrlEvent (CTRL_BREAK_EVENT
, pid
))
2483 DebPrint (("sys_kill.GenerateConsoleCtrlEvent return %d "
2484 "for pid %lu\n", GetLastError (), pid
));
2491 if (NILP (Vw32_start_process_share_console
) && cp
&& cp
->hwnd
)
2494 if (os_subtype
== OS_9X
)
2497 Another possibility is to try terminating the VDM out-right by
2498 calling the Shell VxD (id 0x17) V86 interface, function #4
2499 "SHELL_Destroy_VM", ie.
2505 First need to determine the current VM handle, and then arrange for
2506 the shellapi call to be made from the system vm (by using
2507 Switch_VM_and_callback).
2509 Could try to invoke DestroyVM through CallVxD.
2513 /* On Windows 95, posting WM_QUIT causes the 16-bit subsystem
2514 to hang when cmdproxy is used in conjunction with
2515 command.com for an interactive shell. Posting
2516 WM_CLOSE pops up a dialog that, when Yes is selected,
2517 does the same thing. TerminateProcess is also less
2518 than ideal in that subprocesses tend to stick around
2519 until the machine is shutdown, but at least it
2520 doesn't freeze the 16-bit subsystem. */
2521 PostMessage (cp
->hwnd
, WM_QUIT
, 0xff, 0);
2523 if (!TerminateProcess (proc_hand
, 0xff))
2525 DebPrint (("sys_kill.TerminateProcess returned %d "
2526 "for pid %lu\n", GetLastError (), pid
));
2533 PostMessage (cp
->hwnd
, WM_CLOSE
, 0, 0);
2535 /* Kill the process. On W32 this doesn't kill child processes
2536 so it doesn't work very well for shells which is why it's not
2537 used in every case. */
2538 else if (!TerminateProcess (proc_hand
, 0xff))
2540 DebPrint (("sys_kill.TerminateProcess returned %d "
2541 "for pid %lu\n", GetLastError (), pid
));
2548 CloseHandle (proc_hand
);
2553 /* The following two routines are used to manipulate stdin, stdout, and
2554 stderr of our child processes.
2556 Assuming that in, out, and err are *not* inheritable, we make them
2557 stdin, stdout, and stderr of the child as follows:
2559 - Save the parent's current standard handles.
2560 - Set the std handles to inheritable duplicates of the ones being passed in.
2561 (Note that _get_osfhandle() is an io.h procedure that retrieves the
2562 NT file handle for a crt file descriptor.)
2563 - Spawn the child, which inherits in, out, and err as stdin,
2564 stdout, and stderr. (see Spawnve)
2565 - Close the std handles passed to the child.
2566 - Reset the parent's standard handles to the saved handles.
2567 (see reset_standard_handles)
2568 We assume that the caller closes in, out, and err after calling us. */
2571 prepare_standard_handles (int in
, int out
, int err
, HANDLE handles
[3])
2574 HANDLE newstdin
, newstdout
, newstderr
;
2576 parent
= GetCurrentProcess ();
2578 handles
[0] = GetStdHandle (STD_INPUT_HANDLE
);
2579 handles
[1] = GetStdHandle (STD_OUTPUT_HANDLE
);
2580 handles
[2] = GetStdHandle (STD_ERROR_HANDLE
);
2582 /* make inheritable copies of the new handles */
2583 if (!DuplicateHandle (parent
,
2584 (HANDLE
) _get_osfhandle (in
),
2589 DUPLICATE_SAME_ACCESS
))
2590 report_file_error ("Duplicating input handle for child", Qnil
);
2592 if (!DuplicateHandle (parent
,
2593 (HANDLE
) _get_osfhandle (out
),
2598 DUPLICATE_SAME_ACCESS
))
2599 report_file_error ("Duplicating output handle for child", Qnil
);
2601 if (!DuplicateHandle (parent
,
2602 (HANDLE
) _get_osfhandle (err
),
2607 DUPLICATE_SAME_ACCESS
))
2608 report_file_error ("Duplicating error handle for child", Qnil
);
2610 /* and store them as our std handles */
2611 if (!SetStdHandle (STD_INPUT_HANDLE
, newstdin
))
2612 report_file_error ("Changing stdin handle", Qnil
);
2614 if (!SetStdHandle (STD_OUTPUT_HANDLE
, newstdout
))
2615 report_file_error ("Changing stdout handle", Qnil
);
2617 if (!SetStdHandle (STD_ERROR_HANDLE
, newstderr
))
2618 report_file_error ("Changing stderr handle", Qnil
);
2622 reset_standard_handles (int in
, int out
, int err
, HANDLE handles
[3])
2624 /* close the duplicated handles passed to the child */
2625 CloseHandle (GetStdHandle (STD_INPUT_HANDLE
));
2626 CloseHandle (GetStdHandle (STD_OUTPUT_HANDLE
));
2627 CloseHandle (GetStdHandle (STD_ERROR_HANDLE
));
2629 /* now restore parent's saved std handles */
2630 SetStdHandle (STD_INPUT_HANDLE
, handles
[0]);
2631 SetStdHandle (STD_OUTPUT_HANDLE
, handles
[1]);
2632 SetStdHandle (STD_ERROR_HANDLE
, handles
[2]);
2636 set_process_dir (char * dir
)
2641 /* To avoid problems with winsock implementations that work over dial-up
2642 connections causing or requiring a connection to exist while Emacs is
2643 running, Emacs no longer automatically loads winsock on startup if it
2644 is present. Instead, it will be loaded when open-network-stream is
2647 To allow full control over when winsock is loaded, we provide these
2648 two functions to dynamically load and unload winsock. This allows
2649 dial-up users to only be connected when they actually need to use
2653 extern HANDLE winsock_lib
;
2654 extern BOOL
term_winsock (void);
2655 extern BOOL
init_winsock (int load_now
);
2657 DEFUN ("w32-has-winsock", Fw32_has_winsock
, Sw32_has_winsock
, 0, 1, 0,
2658 doc
: /* Test for presence of the Windows socket library `winsock'.
2659 Returns non-nil if winsock support is present, nil otherwise.
2661 If the optional argument LOAD-NOW is non-nil, the winsock library is
2662 also loaded immediately if not already loaded. If winsock is loaded,
2663 the winsock local hostname is returned (since this may be different from
2664 the value of `system-name' and should supplant it), otherwise t is
2665 returned to indicate winsock support is present. */)
2666 (Lisp_Object load_now
)
2670 have_winsock
= init_winsock (!NILP (load_now
));
2673 if (winsock_lib
!= NULL
)
2675 /* Return new value for system-name. The best way to do this
2676 is to call init_system_name, saving and restoring the
2677 original value to avoid side-effects. */
2678 Lisp_Object orig_hostname
= Vsystem_name
;
2679 Lisp_Object hostname
;
2681 init_system_name ();
2682 hostname
= Vsystem_name
;
2683 Vsystem_name
= orig_hostname
;
2691 DEFUN ("w32-unload-winsock", Fw32_unload_winsock
, Sw32_unload_winsock
,
2693 doc
: /* Unload the Windows socket library `winsock' if loaded.
2694 This is provided to allow dial-up socket connections to be disconnected
2695 when no longer needed. Returns nil without unloading winsock if any
2696 socket connections still exist. */)
2699 return term_winsock () ? Qt
: Qnil
;
2703 /* Some miscellaneous functions that are Windows specific, but not GUI
2704 specific (ie. are applicable in terminal or batch mode as well). */
2706 DEFUN ("w32-short-file-name", Fw32_short_file_name
, Sw32_short_file_name
, 1, 1, 0,
2707 doc
: /* Return the short file name version (8.3) of the full path of FILENAME.
2708 If FILENAME does not exist, return nil.
2709 All path elements in FILENAME are converted to their short names. */)
2710 (Lisp_Object filename
)
2712 char shortname
[MAX_PATH
];
2714 CHECK_STRING (filename
);
2716 /* first expand it. */
2717 filename
= Fexpand_file_name (filename
, Qnil
);
2719 /* luckily, this returns the short version of each element in the path. */
2720 if (w32_get_short_filename (SDATA (ENCODE_FILE (filename
)),
2721 shortname
, MAX_PATH
) == 0)
2724 dostounix_filename (shortname
);
2726 /* No need to DECODE_FILE, because 8.3 names are pure ASCII. */
2727 return build_string (shortname
);
2731 DEFUN ("w32-long-file-name", Fw32_long_file_name
, Sw32_long_file_name
,
2733 doc
: /* Return the long file name version of the full path of FILENAME.
2734 If FILENAME does not exist, return nil.
2735 All path elements in FILENAME are converted to their long names. */)
2736 (Lisp_Object filename
)
2738 char longname
[ MAX_UTF8_PATH
];
2741 CHECK_STRING (filename
);
2743 if (SBYTES (filename
) == 2
2744 && *(SDATA (filename
) + 1) == ':')
2747 /* first expand it. */
2748 filename
= Fexpand_file_name (filename
, Qnil
);
2750 if (!w32_get_long_filename (SDATA (ENCODE_FILE (filename
)), longname
,
2754 dostounix_filename (longname
);
2756 /* If we were passed only a drive, make sure that a slash is not appended
2757 for consistency with directories. Allow for drive mapping via SUBST
2758 in case expand-file-name is ever changed to expand those. */
2759 if (drive_only
&& longname
[1] == ':' && longname
[2] == '/' && !longname
[3])
2762 return DECODE_FILE (build_unibyte_string (longname
));
2765 DEFUN ("w32-set-process-priority", Fw32_set_process_priority
,
2766 Sw32_set_process_priority
, 2, 2, 0,
2767 doc
: /* Set the priority of PROCESS to PRIORITY.
2768 If PROCESS is nil, the priority of Emacs is changed, otherwise the
2769 priority of the process whose pid is PROCESS is changed.
2770 PRIORITY should be one of the symbols high, normal, or low;
2771 any other symbol will be interpreted as normal.
2773 If successful, the return value is t, otherwise nil. */)
2774 (Lisp_Object process
, Lisp_Object priority
)
2776 HANDLE proc_handle
= GetCurrentProcess ();
2777 DWORD priority_class
= NORMAL_PRIORITY_CLASS
;
2778 Lisp_Object result
= Qnil
;
2780 CHECK_SYMBOL (priority
);
2782 if (!NILP (process
))
2787 CHECK_NUMBER (process
);
2789 /* Allow pid to be an internally generated one, or one obtained
2790 externally. This is necessary because real pids on Windows 95 are
2793 pid
= XINT (process
);
2794 cp
= find_child_pid (pid
);
2796 pid
= cp
->procinfo
.dwProcessId
;
2798 proc_handle
= OpenProcess (PROCESS_SET_INFORMATION
, FALSE
, pid
);
2801 if (EQ (priority
, Qhigh
))
2802 priority_class
= HIGH_PRIORITY_CLASS
;
2803 else if (EQ (priority
, Qlow
))
2804 priority_class
= IDLE_PRIORITY_CLASS
;
2806 if (proc_handle
!= NULL
)
2808 if (SetPriorityClass (proc_handle
, priority_class
))
2810 if (!NILP (process
))
2811 CloseHandle (proc_handle
);
2817 #ifdef HAVE_LANGINFO_CODESET
2818 /* Emulation of nl_langinfo. Used in fns.c:Flocale_info. */
2820 nl_langinfo (nl_item item
)
2822 /* Conversion of Posix item numbers to their Windows equivalents. */
2823 static const LCTYPE w32item
[] = {
2824 LOCALE_IDEFAULTANSICODEPAGE
,
2825 LOCALE_SDAYNAME1
, LOCALE_SDAYNAME2
, LOCALE_SDAYNAME3
,
2826 LOCALE_SDAYNAME4
, LOCALE_SDAYNAME5
, LOCALE_SDAYNAME6
, LOCALE_SDAYNAME7
,
2827 LOCALE_SMONTHNAME1
, LOCALE_SMONTHNAME2
, LOCALE_SMONTHNAME3
,
2828 LOCALE_SMONTHNAME4
, LOCALE_SMONTHNAME5
, LOCALE_SMONTHNAME6
,
2829 LOCALE_SMONTHNAME7
, LOCALE_SMONTHNAME8
, LOCALE_SMONTHNAME9
,
2830 LOCALE_SMONTHNAME10
, LOCALE_SMONTHNAME11
, LOCALE_SMONTHNAME12
2833 static char *nl_langinfo_buf
= NULL
;
2834 static int nl_langinfo_len
= 0;
2836 if (nl_langinfo_len
<= 0)
2837 nl_langinfo_buf
= xmalloc (nl_langinfo_len
= 1);
2839 if (item
< 0 || item
>= _NL_NUM
)
2840 nl_langinfo_buf
[0] = 0;
2843 LCID cloc
= GetThreadLocale ();
2844 int need_len
= GetLocaleInfo (cloc
, w32item
[item
] | LOCALE_USE_CP_ACP
,
2848 nl_langinfo_buf
[0] = 0;
2851 if (item
== CODESET
)
2853 need_len
+= 2; /* for the "cp" prefix */
2854 if (need_len
< 8) /* for the case we call GetACP */
2857 if (nl_langinfo_len
<= need_len
)
2858 nl_langinfo_buf
= xrealloc (nl_langinfo_buf
,
2859 nl_langinfo_len
= need_len
);
2860 if (!GetLocaleInfo (cloc
, w32item
[item
] | LOCALE_USE_CP_ACP
,
2861 nl_langinfo_buf
, nl_langinfo_len
))
2862 nl_langinfo_buf
[0] = 0;
2863 else if (item
== CODESET
)
2865 if (strcmp (nl_langinfo_buf
, "0") == 0 /* CP_ACP */
2866 || strcmp (nl_langinfo_buf
, "1") == 0) /* CP_OEMCP */
2867 sprintf (nl_langinfo_buf
, "cp%u", GetACP ());
2870 memmove (nl_langinfo_buf
+ 2, nl_langinfo_buf
,
2871 strlen (nl_langinfo_buf
) + 1);
2872 nl_langinfo_buf
[0] = 'c';
2873 nl_langinfo_buf
[1] = 'p';
2878 return nl_langinfo_buf
;
2880 #endif /* HAVE_LANGINFO_CODESET */
2882 DEFUN ("w32-get-locale-info", Fw32_get_locale_info
,
2883 Sw32_get_locale_info
, 1, 2, 0,
2884 doc
: /* Return information about the Windows locale LCID.
2885 By default, return a three letter locale code which encodes the default
2886 language as the first two characters, and the country or regional variant
2887 as the third letter. For example, ENU refers to `English (United States)',
2888 while ENC means `English (Canadian)'.
2890 If the optional argument LONGFORM is t, the long form of the locale
2891 name is returned, e.g. `English (United States)' instead; if LONGFORM
2892 is a number, it is interpreted as an LCTYPE constant and the corresponding
2893 locale information is returned.
2895 If LCID (a 16-bit number) is not a valid locale, the result is nil. */)
2896 (Lisp_Object lcid
, Lisp_Object longform
)
2900 char abbrev_name
[32] = { 0 };
2901 char full_name
[256] = { 0 };
2903 CHECK_NUMBER (lcid
);
2905 if (!IsValidLocale (XINT (lcid
), LCID_SUPPORTED
))
2908 if (NILP (longform
))
2910 got_abbrev
= GetLocaleInfo (XINT (lcid
),
2911 LOCALE_SABBREVLANGNAME
| LOCALE_USE_CP_ACP
,
2912 abbrev_name
, sizeof (abbrev_name
));
2914 return build_string (abbrev_name
);
2916 else if (EQ (longform
, Qt
))
2918 got_full
= GetLocaleInfo (XINT (lcid
),
2919 LOCALE_SLANGUAGE
| LOCALE_USE_CP_ACP
,
2920 full_name
, sizeof (full_name
));
2922 return DECODE_SYSTEM (build_string (full_name
));
2924 else if (NUMBERP (longform
))
2926 got_full
= GetLocaleInfo (XINT (lcid
),
2928 full_name
, sizeof (full_name
));
2929 /* GetLocaleInfo's return value includes the terminating null
2930 character, when the returned information is a string, whereas
2931 make_unibyte_string needs the string length without the
2932 terminating null. */
2934 return make_unibyte_string (full_name
, got_full
- 1);
2941 DEFUN ("w32-get-current-locale-id", Fw32_get_current_locale_id
,
2942 Sw32_get_current_locale_id
, 0, 0, 0,
2943 doc
: /* Return Windows locale id for current locale setting.
2944 This is a numerical value; use `w32-get-locale-info' to convert to a
2945 human-readable form. */)
2948 return make_number (GetThreadLocale ());
2952 int_from_hex (char * s
)
2955 static char hex
[] = "0123456789abcdefABCDEF";
2958 while (*s
&& (p
= strchr (hex
, *s
)) != NULL
)
2960 unsigned digit
= p
- hex
;
2963 val
= val
* 16 + digit
;
2969 /* We need to build a global list, since the EnumSystemLocale callback
2970 function isn't given a context pointer. */
2971 Lisp_Object Vw32_valid_locale_ids
;
2973 static BOOL CALLBACK ALIGN_STACK
2974 enum_locale_fn (LPTSTR localeNum
)
2976 DWORD id
= int_from_hex (localeNum
);
2977 Vw32_valid_locale_ids
= Fcons (make_number (id
), Vw32_valid_locale_ids
);
2981 DEFUN ("w32-get-valid-locale-ids", Fw32_get_valid_locale_ids
,
2982 Sw32_get_valid_locale_ids
, 0, 0, 0,
2983 doc
: /* Return list of all valid Windows locale ids.
2984 Each id is a numerical value; use `w32-get-locale-info' to convert to a
2985 human-readable form. */)
2988 Vw32_valid_locale_ids
= Qnil
;
2990 EnumSystemLocales (enum_locale_fn
, LCID_SUPPORTED
);
2992 Vw32_valid_locale_ids
= Fnreverse (Vw32_valid_locale_ids
);
2993 return Vw32_valid_locale_ids
;
2997 DEFUN ("w32-get-default-locale-id", Fw32_get_default_locale_id
, Sw32_get_default_locale_id
, 0, 1, 0,
2998 doc
: /* Return Windows locale id for default locale setting.
2999 By default, the system default locale setting is returned; if the optional
3000 parameter USERP is non-nil, the user default locale setting is returned.
3001 This is a numerical value; use `w32-get-locale-info' to convert to a
3002 human-readable form. */)
3006 return make_number (GetSystemDefaultLCID ());
3007 return make_number (GetUserDefaultLCID ());
3011 DEFUN ("w32-set-current-locale", Fw32_set_current_locale
, Sw32_set_current_locale
, 1, 1, 0,
3012 doc
: /* Make Windows locale LCID be the current locale setting for Emacs.
3013 If successful, the new locale id is returned, otherwise nil. */)
3016 CHECK_NUMBER (lcid
);
3018 if (!IsValidLocale (XINT (lcid
), LCID_SUPPORTED
))
3021 if (!SetThreadLocale (XINT (lcid
)))
3024 /* Need to set input thread locale if present. */
3025 if (dwWindowsThreadId
)
3026 /* Reply is not needed. */
3027 PostThreadMessage (dwWindowsThreadId
, WM_EMACS_SETLOCALE
, XINT (lcid
), 0);
3029 return make_number (GetThreadLocale ());
3033 /* We need to build a global list, since the EnumCodePages callback
3034 function isn't given a context pointer. */
3035 Lisp_Object Vw32_valid_codepages
;
3037 static BOOL CALLBACK ALIGN_STACK
3038 enum_codepage_fn (LPTSTR codepageNum
)
3040 DWORD id
= atoi (codepageNum
);
3041 Vw32_valid_codepages
= Fcons (make_number (id
), Vw32_valid_codepages
);
3045 DEFUN ("w32-get-valid-codepages", Fw32_get_valid_codepages
,
3046 Sw32_get_valid_codepages
, 0, 0, 0,
3047 doc
: /* Return list of all valid Windows codepages. */)
3050 Vw32_valid_codepages
= Qnil
;
3052 EnumSystemCodePages (enum_codepage_fn
, CP_SUPPORTED
);
3054 Vw32_valid_codepages
= Fnreverse (Vw32_valid_codepages
);
3055 return Vw32_valid_codepages
;
3059 DEFUN ("w32-get-console-codepage", Fw32_get_console_codepage
,
3060 Sw32_get_console_codepage
, 0, 0, 0,
3061 doc
: /* Return current Windows codepage for console input. */)
3064 return make_number (GetConsoleCP ());
3068 DEFUN ("w32-set-console-codepage", Fw32_set_console_codepage
,
3069 Sw32_set_console_codepage
, 1, 1, 0,
3070 doc
: /* Make Windows codepage CP be the codepage for Emacs tty keyboard input.
3071 This codepage setting affects keyboard input in tty mode.
3072 If successful, the new CP is returned, otherwise nil. */)
3077 if (!IsValidCodePage (XINT (cp
)))
3080 if (!SetConsoleCP (XINT (cp
)))
3083 return make_number (GetConsoleCP ());
3087 DEFUN ("w32-get-console-output-codepage", Fw32_get_console_output_codepage
,
3088 Sw32_get_console_output_codepage
, 0, 0, 0,
3089 doc
: /* Return current Windows codepage for console output. */)
3092 return make_number (GetConsoleOutputCP ());
3096 DEFUN ("w32-set-console-output-codepage", Fw32_set_console_output_codepage
,
3097 Sw32_set_console_output_codepage
, 1, 1, 0,
3098 doc
: /* Make Windows codepage CP be the codepage for Emacs console output.
3099 This codepage setting affects display in tty mode.
3100 If successful, the new CP is returned, otherwise nil. */)
3105 if (!IsValidCodePage (XINT (cp
)))
3108 if (!SetConsoleOutputCP (XINT (cp
)))
3111 return make_number (GetConsoleOutputCP ());
3115 DEFUN ("w32-get-codepage-charset", Fw32_get_codepage_charset
,
3116 Sw32_get_codepage_charset
, 1, 1, 0,
3117 doc
: /* Return charset ID corresponding to codepage CP.
3118 Returns nil if the codepage is not valid or its charset ID could
3121 Note that this function is only guaranteed to work with ANSI
3122 codepages; most console codepages are not supported and will
3131 if (!IsValidCodePage (XINT (cp
)))
3134 /* Going through a temporary DWORD variable avoids compiler warning
3135 about cast to pointer from integer of different size, when
3136 building --with-wide-int. */
3138 if (TranslateCharsetInfo ((DWORD
*) dwcp
, &info
, TCI_SRCCODEPAGE
))
3139 return make_number (info
.ciCharset
);
3145 DEFUN ("w32-get-valid-keyboard-layouts", Fw32_get_valid_keyboard_layouts
,
3146 Sw32_get_valid_keyboard_layouts
, 0, 0, 0,
3147 doc
: /* Return list of Windows keyboard languages and layouts.
3148 The return value is a list of pairs of language id and layout id. */)
3151 int num_layouts
= GetKeyboardLayoutList (0, NULL
);
3152 HKL
* layouts
= (HKL
*) alloca (num_layouts
* sizeof (HKL
));
3153 Lisp_Object obj
= Qnil
;
3155 if (GetKeyboardLayoutList (num_layouts
, layouts
) == num_layouts
)
3157 while (--num_layouts
>= 0)
3159 HKL kl
= layouts
[num_layouts
];
3161 obj
= Fcons (Fcons (make_number (LOWORD (kl
)),
3162 make_number (HIWORD (kl
))),
3171 DEFUN ("w32-get-keyboard-layout", Fw32_get_keyboard_layout
,
3172 Sw32_get_keyboard_layout
, 0, 0, 0,
3173 doc
: /* Return current Windows keyboard language and layout.
3174 The return value is the cons of the language id and the layout id. */)
3177 HKL kl
= GetKeyboardLayout (dwWindowsThreadId
);
3179 return Fcons (make_number (LOWORD (kl
)),
3180 make_number (HIWORD (kl
)));
3184 DEFUN ("w32-set-keyboard-layout", Fw32_set_keyboard_layout
,
3185 Sw32_set_keyboard_layout
, 1, 1, 0,
3186 doc
: /* Make LAYOUT be the current keyboard layout for Emacs.
3187 The keyboard layout setting affects interpretation of keyboard input.
3188 If successful, the new layout id is returned, otherwise nil. */)
3189 (Lisp_Object layout
)
3193 CHECK_CONS (layout
);
3194 CHECK_NUMBER_CAR (layout
);
3195 CHECK_NUMBER_CDR (layout
);
3197 kl
= (HKL
) (UINT_PTR
) ((XINT (XCAR (layout
)) & 0xffff)
3198 | (XINT (XCDR (layout
)) << 16));
3200 /* Synchronize layout with input thread. */
3201 if (dwWindowsThreadId
)
3203 if (PostThreadMessage (dwWindowsThreadId
, WM_EMACS_SETKEYBOARDLAYOUT
,
3207 GetMessage (&msg
, NULL
, WM_EMACS_DONE
, WM_EMACS_DONE
);
3209 if (msg
.wParam
== 0)
3213 else if (!ActivateKeyboardLayout (kl
, 0))
3216 return Fw32_get_keyboard_layout ();
3219 /* Two variables to interface between get_lcid and the EnumLocales
3220 callback function below. */
3221 #ifndef LOCALE_NAME_MAX_LENGTH
3222 # define LOCALE_NAME_MAX_LENGTH 85
3224 static LCID found_lcid
;
3225 static char lname
[3 * LOCALE_NAME_MAX_LENGTH
+ 1 + 1];
3227 /* Callback function for EnumLocales. */
3228 static BOOL CALLBACK
3229 get_lcid_callback (LPTSTR locale_num_str
)
3232 char locval
[2 * LOCALE_NAME_MAX_LENGTH
+ 1 + 1];
3233 LCID try_lcid
= strtoul (locale_num_str
, &endp
, 16);
3235 if (GetLocaleInfo (try_lcid
, LOCALE_SABBREVLANGNAME
,
3236 locval
, LOCALE_NAME_MAX_LENGTH
))
3240 /* This is for when they only specify the language, as in "ENU". */
3241 if (stricmp (locval
, lname
) == 0)
3243 found_lcid
= try_lcid
;
3246 locval_len
= strlen (locval
);
3247 strcpy (locval
+ locval_len
, "_");
3248 if (GetLocaleInfo (try_lcid
, LOCALE_SABBREVCTRYNAME
,
3249 locval
+ locval_len
+ 1, LOCALE_NAME_MAX_LENGTH
))
3251 locval_len
= strlen (locval
);
3252 if (strnicmp (locval
, lname
, locval_len
) == 0
3253 && (lname
[locval_len
] == '.'
3254 || lname
[locval_len
] == '\0'))
3256 found_lcid
= try_lcid
;
3264 /* Return the Locale ID (LCID) number given the locale's name, a
3265 string, in LOCALE_NAME. This works by enumerating all the locales
3266 supported by the system, until we find one whose name matches
3269 get_lcid (const char *locale_name
)
3271 /* A simple cache. */
3272 static LCID last_lcid
;
3273 static char last_locale
[1000];
3275 /* The code below is not thread-safe, as it uses static variables.
3276 But this function is called only from the Lisp thread. */
3277 if (last_lcid
> 0 && strcmp (locale_name
, last_locale
) == 0)
3280 strncpy (lname
, locale_name
, sizeof (lname
) - 1);
3281 lname
[sizeof (lname
) - 1] = '\0';
3283 EnumSystemLocales (get_lcid_callback
, LCID_SUPPORTED
);
3286 last_lcid
= found_lcid
;
3287 strcpy (last_locale
, locale_name
);
3292 #ifndef _NSLCMPERROR
3293 # define _NSLCMPERROR INT_MAX
3295 #ifndef LINGUISTIC_IGNORECASE
3296 # define LINGUISTIC_IGNORECASE 0x00000010
3300 w32_compare_strings (const char *s1
, const char *s2
, char *locname
,
3303 LCID lcid
= GetThreadLocale ();
3304 wchar_t *string1_w
, *string2_w
;
3306 extern BOOL g_b_init_compare_string_w
;
3307 static int (WINAPI
*pCompareStringW
)(LCID
, DWORD
, LPCWSTR
, int, LPCWSTR
, int);
3312 /* The LCID machinery doesn't seem to support the "C" locale, so we
3313 need to do that by hand. */
3315 && ((locname
[0] == 'C' && (locname
[1] == '\0' || locname
[1] == '.'))
3316 || strcmp (locname
, "POSIX") == 0))
3317 return (ignore_case
? stricmp (s1
, s2
) : strcmp (s1
, s2
));
3319 if (!g_b_init_compare_string_w
)
3321 if (os_subtype
== OS_9X
)
3323 pCompareStringW
= GetProcAddress (LoadLibrary ("Unicows.dll"),
3325 if (!pCompareStringW
)
3328 /* This return value is compatible with wcscoll and
3329 other MS CRT functions. */
3330 return _NSLCMPERROR
;
3334 pCompareStringW
= CompareStringW
;
3336 g_b_init_compare_string_w
= 1;
3339 needed
= pMultiByteToWideChar (CP_UTF8
, MB_ERR_INVALID_CHARS
, s1
, -1, NULL
, 0);
3342 SAFE_NALLOCA (string1_w
, 1, needed
+ 1);
3343 pMultiByteToWideChar (CP_UTF8
, MB_ERR_INVALID_CHARS
, s1
, -1,
3349 return _NSLCMPERROR
;
3352 needed
= pMultiByteToWideChar (CP_UTF8
, MB_ERR_INVALID_CHARS
, s2
, -1, NULL
, 0);
3355 SAFE_NALLOCA (string2_w
, 1, needed
+ 1);
3356 pMultiByteToWideChar (CP_UTF8
, MB_ERR_INVALID_CHARS
, s2
, -1,
3363 return _NSLCMPERROR
;
3368 /* Convert locale name string to LCID. We don't want to use
3369 LocaleNameToLCID because (a) it is only available since
3370 Vista, and (b) it doesn't accept locale names returned by
3371 'setlocale' and 'GetLocaleInfo'. */
3372 LCID new_lcid
= get_lcid (locname
);
3377 error ("Invalid locale %s: Invalid argument", locname
);
3382 /* NORM_IGNORECASE ignores any tertiary distinction, not just
3383 case variants. LINGUISTIC_IGNORECASE is more selective, and
3384 is sensitive to the locale's language, but it is not
3385 available before Vista. */
3386 if (w32_major_version
>= 6)
3387 flags
|= LINGUISTIC_IGNORECASE
;
3389 flags
|= NORM_IGNORECASE
;
3391 /* This approximates what glibc collation functions do when the
3392 locale's codeset is UTF-8. */
3393 if (!NILP (Vw32_collate_ignore_punctuation
))
3394 flags
|= NORM_IGNORESYMBOLS
;
3395 val
= pCompareStringW (lcid
, flags
, string1_w
, -1, string2_w
, -1);
3400 return _NSLCMPERROR
;
3407 syms_of_ntproc (void)
3409 DEFSYM (Qhigh
, "high");
3410 DEFSYM (Qlow
, "low");
3412 defsubr (&Sw32_has_winsock
);
3413 defsubr (&Sw32_unload_winsock
);
3415 defsubr (&Sw32_short_file_name
);
3416 defsubr (&Sw32_long_file_name
);
3417 defsubr (&Sw32_set_process_priority
);
3418 defsubr (&Sw32_get_locale_info
);
3419 defsubr (&Sw32_get_current_locale_id
);
3420 defsubr (&Sw32_get_default_locale_id
);
3421 defsubr (&Sw32_get_valid_locale_ids
);
3422 defsubr (&Sw32_set_current_locale
);
3424 defsubr (&Sw32_get_console_codepage
);
3425 defsubr (&Sw32_set_console_codepage
);
3426 defsubr (&Sw32_get_console_output_codepage
);
3427 defsubr (&Sw32_set_console_output_codepage
);
3428 defsubr (&Sw32_get_valid_codepages
);
3429 defsubr (&Sw32_get_codepage_charset
);
3431 defsubr (&Sw32_get_valid_keyboard_layouts
);
3432 defsubr (&Sw32_get_keyboard_layout
);
3433 defsubr (&Sw32_set_keyboard_layout
);
3435 DEFVAR_LISP ("w32-quote-process-args", Vw32_quote_process_args
,
3436 doc
: /* Non-nil enables quoting of process arguments to ensure correct parsing.
3437 Because Windows does not directly pass argv arrays to child processes,
3438 programs have to reconstruct the argv array by parsing the command
3439 line string. For an argument to contain a space, it must be enclosed
3440 in double quotes or it will be parsed as multiple arguments.
3442 If the value is a character, that character will be used to escape any
3443 quote characters that appear, otherwise a suitable escape character
3444 will be chosen based on the type of the program. */);
3445 Vw32_quote_process_args
= Qt
;
3447 DEFVAR_LISP ("w32-start-process-show-window",
3448 Vw32_start_process_show_window
,
3449 doc
: /* When nil, new child processes hide their windows.
3450 When non-nil, they show their window in the method of their choice.
3451 This variable doesn't affect GUI applications, which will never be hidden. */);
3452 Vw32_start_process_show_window
= Qnil
;
3454 DEFVAR_LISP ("w32-start-process-share-console",
3455 Vw32_start_process_share_console
,
3456 doc
: /* When nil, new child processes are given a new console.
3457 When non-nil, they share the Emacs console; this has the limitation of
3458 allowing only one DOS subprocess to run at a time (whether started directly
3459 or indirectly by Emacs), and preventing Emacs from cleanly terminating the
3460 subprocess group, but may allow Emacs to interrupt a subprocess that doesn't
3461 otherwise respond to interrupts from Emacs. */);
3462 Vw32_start_process_share_console
= Qnil
;
3464 DEFVAR_LISP ("w32-start-process-inherit-error-mode",
3465 Vw32_start_process_inherit_error_mode
,
3466 doc
: /* When nil, new child processes revert to the default error mode.
3467 When non-nil, they inherit their error mode setting from Emacs, which stops
3468 them blocking when trying to access unmounted drives etc. */);
3469 Vw32_start_process_inherit_error_mode
= Qt
;
3471 DEFVAR_INT ("w32-pipe-read-delay", w32_pipe_read_delay
,
3472 doc
: /* Forced delay before reading subprocess output.
3473 This is done to improve the buffering of subprocess output, by
3474 avoiding the inefficiency of frequently reading small amounts of data.
3476 If positive, the value is the number of milliseconds to sleep before
3477 reading the subprocess output. If negative, the magnitude is the number
3478 of time slices to wait (effectively boosting the priority of the child
3479 process temporarily). A value of zero disables waiting entirely. */);
3480 w32_pipe_read_delay
= 50;
3482 DEFVAR_LISP ("w32-downcase-file-names", Vw32_downcase_file_names
,
3483 doc
: /* Non-nil means convert all-upper case file names to lower case.
3484 This applies when performing completions and file name expansion.
3485 Note that the value of this setting also affects remote file names,
3486 so you probably don't want to set to non-nil if you use case-sensitive
3487 filesystems via ange-ftp. */);
3488 Vw32_downcase_file_names
= Qnil
;
3491 DEFVAR_LISP ("w32-generate-fake-inodes", Vw32_generate_fake_inodes
,
3492 doc
: /* Non-nil means attempt to fake realistic inode values.
3493 This works by hashing the truename of files, and should detect
3494 aliasing between long and short (8.3 DOS) names, but can have
3495 false positives because of hash collisions. Note that determining
3496 the truename of a file can be slow. */);
3497 Vw32_generate_fake_inodes
= Qnil
;
3500 DEFVAR_LISP ("w32-get-true-file-attributes", Vw32_get_true_file_attributes
,
3501 doc
: /* Non-nil means determine accurate file attributes in `file-attributes'.
3502 This option controls whether to issue additional system calls to determine
3503 accurate link counts, file type, and ownership information. It is more
3504 useful for files on NTFS volumes, where hard links and file security are
3505 supported, than on volumes of the FAT family.
3507 Without these system calls, link count will always be reported as 1 and file
3508 ownership will be attributed to the current user.
3509 The default value `local' means only issue these system calls for files
3510 on local fixed drives. A value of nil means never issue them.
3511 Any other non-nil value means do this even on remote and removable drives
3512 where the performance impact may be noticeable even on modern hardware. */);
3513 Vw32_get_true_file_attributes
= Qlocal
;
3515 DEFVAR_LISP ("w32-collate-ignore-punctuation",
3516 Vw32_collate_ignore_punctuation
,
3517 doc
: /* Non-nil causes string collation functions ignore punctuation on MS-Windows.
3518 On Posix platforms, `string-collate-lessp' and `string-collate-equalp'
3519 ignore punctuation characters when they compare strings, if the
3520 locale's codeset is UTF-8, as in \"en_US.UTF-8\". Binding this option
3521 to a non-nil value will achieve a similar effect on MS-Windows, where
3522 locales with UTF-8 codeset are not supported.
3524 Note that setting this to non-nil will also ignore blanks and symbols
3525 in the strings. So do NOT use this option when comparing file names
3526 for equality, only when you need to sort them. */);
3527 Vw32_collate_ignore_punctuation
= Qnil
;
3529 staticpro (&Vw32_valid_locale_ids
);
3530 staticpro (&Vw32_valid_codepages
);
3532 /* end of w32proc.c */