1 /* Process support for GNU Emacs on the Microsoft Windows API.
3 Copyright (C) 1992, 1995, 1999-2014 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 Lisp_Object Qhigh
, Qlow
;
77 /* Signal handlers...SIG_DFL == 0 so this is initialized correctly. */
78 static signal_handler sig_handlers
[NSIG
];
80 static sigset_t sig_mask
;
82 static CRITICAL_SECTION crit_sig
;
84 /* Improve on the CRT 'signal' implementation so that we could record
85 the SIGCHLD handler and fake interval timers. */
87 sys_signal (int sig
, signal_handler handler
)
91 /* SIGCHLD is needed for supporting subprocesses, see sys_kill
92 below. SIGALRM and SIGPROF are used by setitimer. All the
93 others are the only ones supported by the MS runtime. */
94 if (!(sig
== SIGCHLD
|| sig
== SIGSEGV
|| sig
== SIGILL
95 || sig
== SIGFPE
|| sig
== SIGABRT
|| sig
== SIGTERM
96 || sig
== SIGALRM
|| sig
== SIGPROF
))
101 old
= sig_handlers
[sig
];
102 /* SIGABRT is treated specially because w32.c installs term_ntproc
103 as its handler, so we don't want to override that afterwards.
104 Aborting Emacs works specially anyway: either by calling
105 emacs_abort directly or through terminate_due_to_signal, which
106 calls emacs_abort through emacs_raise. */
107 if (!(sig
== SIGABRT
&& old
== term_ntproc
))
109 sig_handlers
[sig
] = handler
;
110 if (!(sig
== SIGCHLD
|| sig
== SIGALRM
|| sig
== SIGPROF
))
111 signal (sig
, handler
);
116 /* Emulate sigaction. */
118 sigaction (int sig
, const struct sigaction
*act
, struct sigaction
*oact
)
120 signal_handler old
= SIG_DFL
;
124 old
= sys_signal (sig
, act
->sa_handler
);
126 old
= sig_handlers
[sig
];
135 oact
->sa_handler
= old
;
137 oact
->sa_mask
= empty_mask
;
142 /* Emulate signal sets and blocking of signals used by timers. */
145 sigemptyset (sigset_t
*set
)
152 sigaddset (sigset_t
*set
, int signo
)
159 if (signo
< 0 || signo
>= NSIG
)
165 *set
|= (1U << signo
);
171 sigfillset (sigset_t
*set
)
184 sigprocmask (int how
, const sigset_t
*set
, sigset_t
*oset
)
186 if (!(how
== SIG_BLOCK
|| how
== SIG_UNBLOCK
|| how
== SIG_SETMASK
))
207 /* FIXME: Catch signals that are blocked and reissue them when
208 they are unblocked. Important for SIGALRM and SIGPROF only. */
217 pthread_sigmask (int how
, const sigset_t
*set
, sigset_t
*oset
)
219 if (sigprocmask (how
, set
, oset
) == -1)
225 sigismember (const sigset_t
*set
, int signo
)
227 if (signo
< 0 || signo
>= NSIG
)
232 if (signo
> sizeof (*set
) * BITS_PER_CHAR
)
235 return (*set
& (1U << signo
)) != 0;
251 setpgid (pid_t pid
, pid_t pgid
)
262 /* Emulations of interval timers.
264 Limitations: only ITIMER_REAL and ITIMER_PROF are supported.
266 Implementation: a separate thread is started for each timer type,
267 the thread calls the appropriate signal handler when the timer
268 expires, after stopping the thread which installed the timer. */
271 volatile ULONGLONG expire
;
272 volatile ULONGLONG reload
;
273 volatile int terminate
;
275 HANDLE caller_thread
;
279 static ULONGLONG ticks_now
;
280 static struct itimer_data real_itimer
, prof_itimer
;
281 static ULONGLONG clocks_min
;
282 /* If non-zero, itimers are disabled. Used during shutdown, when we
283 delete the critical sections used by the timer threads. */
284 static int disable_itimers
;
286 static CRITICAL_SECTION crit_real
, crit_prof
;
288 /* GetThreadTimes is not available on Windows 9X and possibly also on 2K. */
289 typedef BOOL (WINAPI
*GetThreadTimes_Proc
) (
291 LPFILETIME lpCreationTime
,
292 LPFILETIME lpExitTime
,
293 LPFILETIME lpKernelTime
,
294 LPFILETIME lpUserTime
);
296 static GetThreadTimes_Proc s_pfn_Get_Thread_Times
;
298 #define MAX_SINGLE_SLEEP 30
299 #define TIMER_TICKS_PER_SEC 1000
301 /* Return a suitable time value, in 1-ms units, for THREAD, a handle
302 to a thread. If THREAD is NULL or an invalid handle, return the
303 current wall-clock time since January 1, 1601 (UTC). Otherwise,
304 return the sum of kernel and user times used by THREAD since it was
305 created, plus its creation time. */
307 w32_get_timer_time (HANDLE thread
)
310 int use_system_time
= 1;
311 /* The functions below return times in 100-ns units. */
312 const int tscale
= 10 * TIMER_TICKS_PER_SEC
;
314 if (thread
&& thread
!= INVALID_HANDLE_VALUE
315 && s_pfn_Get_Thread_Times
!= NULL
)
317 FILETIME creation_ftime
, exit_ftime
, kernel_ftime
, user_ftime
;
318 ULARGE_INTEGER temp_creation
, temp_kernel
, temp_user
;
320 if (s_pfn_Get_Thread_Times (thread
, &creation_ftime
, &exit_ftime
,
321 &kernel_ftime
, &user_ftime
))
324 temp_creation
.LowPart
= creation_ftime
.dwLowDateTime
;
325 temp_creation
.HighPart
= creation_ftime
.dwHighDateTime
;
326 temp_kernel
.LowPart
= kernel_ftime
.dwLowDateTime
;
327 temp_kernel
.HighPart
= kernel_ftime
.dwHighDateTime
;
328 temp_user
.LowPart
= user_ftime
.dwLowDateTime
;
329 temp_user
.HighPart
= user_ftime
.dwHighDateTime
;
331 temp_creation
.QuadPart
/ tscale
+ temp_kernel
.QuadPart
/ tscale
332 + temp_user
.QuadPart
/ tscale
;
335 DebPrint (("GetThreadTimes failed with error code %lu\n",
341 FILETIME current_ftime
;
344 GetSystemTimeAsFileTime (¤t_ftime
);
346 temp
.LowPart
= current_ftime
.dwLowDateTime
;
347 temp
.HighPart
= current_ftime
.dwHighDateTime
;
349 retval
= temp
.QuadPart
/ tscale
;
355 /* Thread function for a timer thread. */
357 timer_loop (LPVOID arg
)
359 struct itimer_data
*itimer
= (struct itimer_data
*)arg
;
360 int which
= itimer
->type
;
361 int sig
= (which
== ITIMER_REAL
) ? SIGALRM
: SIGPROF
;
362 CRITICAL_SECTION
*crit
= (which
== ITIMER_REAL
) ? &crit_real
: &crit_prof
;
363 const DWORD max_sleep
= MAX_SINGLE_SLEEP
* 1000 / TIMER_TICKS_PER_SEC
;
364 HANDLE hth
= (which
== ITIMER_REAL
) ? NULL
: itimer
->caller_thread
;
369 signal_handler handler
;
370 ULONGLONG now
, expire
, reload
;
372 /* Load new values if requested by setitimer. */
373 EnterCriticalSection (crit
);
374 expire
= itimer
->expire
;
375 reload
= itimer
->reload
;
376 LeaveCriticalSection (crit
);
377 if (itimer
->terminate
)
387 if (expire
> (now
= w32_get_timer_time (hth
)))
388 sleep_time
= expire
- now
;
391 /* Don't sleep too long at a time, to be able to see the
392 termination flag without too long a delay. */
393 while (sleep_time
> max_sleep
)
395 if (itimer
->terminate
)
398 EnterCriticalSection (crit
);
399 expire
= itimer
->expire
;
400 LeaveCriticalSection (crit
);
402 (expire
> (now
= w32_get_timer_time (hth
))) ? expire
- now
: 0;
404 if (itimer
->terminate
)
408 Sleep (sleep_time
* 1000 / TIMER_TICKS_PER_SEC
);
409 /* Always sleep past the expiration time, to make sure we
410 never call the handler _before_ the expiration time,
411 always slightly after it. Sleep(5) makes sure we don't
412 hog the CPU by calling 'w32_get_timer_time' with high
413 frequency, and also let other threads work. */
414 while (w32_get_timer_time (hth
) < expire
)
418 EnterCriticalSection (crit
);
419 expire
= itimer
->expire
;
420 LeaveCriticalSection (crit
);
425 handler
= sig_handlers
[sig
];
426 if (!(handler
== SIG_DFL
|| handler
== SIG_IGN
|| handler
== SIG_ERR
)
427 /* FIXME: Don't ignore masked signals. Instead, record that
428 they happened and reissue them when the signal is
430 && !sigismember (&sig_mask
, sig
)
431 /* Simulate masking of SIGALRM and SIGPROF when processing
433 && !fatal_error_in_progress
434 && itimer
->caller_thread
)
436 /* Simulate a signal delivered to the thread which installed
437 the timer, by suspending that thread while the handler
439 HANDLE th
= itimer
->caller_thread
;
440 DWORD result
= SuspendThread (th
);
442 if (result
== (DWORD
)-1)
449 /* Update expiration time and loop. */
450 EnterCriticalSection (crit
);
451 expire
= itimer
->expire
;
454 LeaveCriticalSection (crit
);
457 reload
= itimer
->reload
;
460 now
= w32_get_timer_time (hth
);
463 ULONGLONG lag
= now
- expire
;
465 /* If we missed some opportunities (presumably while
466 sleeping or while the signal handler ran), skip
469 expire
= now
- (lag
% reload
);
475 expire
= 0; /* become idle */
476 itimer
->expire
= expire
;
477 LeaveCriticalSection (crit
);
483 stop_timer_thread (int which
)
485 struct itimer_data
*itimer
=
486 (which
== ITIMER_REAL
) ? &real_itimer
: &prof_itimer
;
488 DWORD err
, exit_code
= 255;
491 /* Signal the thread that it should terminate. */
492 itimer
->terminate
= 1;
494 if (itimer
->timer_thread
== NULL
)
497 /* Wait for the timer thread to terminate voluntarily, then kill it
498 if it doesn't. This loop waits twice more than the maximum
499 amount of time a timer thread sleeps, see above. */
500 for (i
= 0; i
< MAX_SINGLE_SLEEP
/ 5; i
++)
502 if (!((status
= GetExitCodeThread (itimer
->timer_thread
, &exit_code
))
503 && exit_code
== STILL_ACTIVE
))
507 if ((status
== FALSE
&& (err
= GetLastError ()) == ERROR_INVALID_HANDLE
)
508 || exit_code
== STILL_ACTIVE
)
510 if (!(status
== FALSE
&& err
== ERROR_INVALID_HANDLE
))
511 TerminateThread (itimer
->timer_thread
, 0);
515 CloseHandle (itimer
->timer_thread
);
516 itimer
->timer_thread
= NULL
;
517 if (itimer
->caller_thread
)
519 CloseHandle (itimer
->caller_thread
);
520 itimer
->caller_thread
= NULL
;
524 /* This is called at shutdown time from term_ntproc. */
528 if (real_itimer
.timer_thread
)
529 stop_timer_thread (ITIMER_REAL
);
530 if (prof_itimer
.timer_thread
)
531 stop_timer_thread (ITIMER_PROF
);
533 /* We are going to delete the critical sections, so timers cannot
537 DeleteCriticalSection (&crit_real
);
538 DeleteCriticalSection (&crit_prof
);
539 DeleteCriticalSection (&crit_sig
);
542 /* This is called at initialization time from init_ntproc. */
546 /* GetThreadTimes is not available on all versions of Windows, so
547 need to probe for its availability dynamically, and call it
548 through a pointer. */
549 s_pfn_Get_Thread_Times
= NULL
; /* in case dumped Emacs comes with a value */
550 if (os_subtype
!= OS_9X
)
551 s_pfn_Get_Thread_Times
=
552 (GetThreadTimes_Proc
)GetProcAddress (GetModuleHandle ("kernel32.dll"),
555 /* Make sure we start with zeroed out itimer structures, since
556 dumping may have left there traces of threads long dead. */
557 memset (&real_itimer
, 0, sizeof real_itimer
);
558 memset (&prof_itimer
, 0, sizeof prof_itimer
);
560 InitializeCriticalSection (&crit_real
);
561 InitializeCriticalSection (&crit_prof
);
562 InitializeCriticalSection (&crit_sig
);
568 start_timer_thread (int which
)
570 DWORD exit_code
, tid
;
572 struct itimer_data
*itimer
=
573 (which
== ITIMER_REAL
) ? &real_itimer
: &prof_itimer
;
575 if (itimer
->timer_thread
576 && GetExitCodeThread (itimer
->timer_thread
, &exit_code
)
577 && exit_code
== STILL_ACTIVE
)
580 /* Clean up after possibly exited thread. */
581 if (itimer
->timer_thread
)
583 CloseHandle (itimer
->timer_thread
);
584 itimer
->timer_thread
= NULL
;
586 if (itimer
->caller_thread
)
588 CloseHandle (itimer
->caller_thread
);
589 itimer
->caller_thread
= NULL
;
592 /* Start a new thread. */
593 if (!DuplicateHandle (GetCurrentProcess (), GetCurrentThread (),
594 GetCurrentProcess (), &th
, 0, FALSE
,
595 DUPLICATE_SAME_ACCESS
))
600 itimer
->terminate
= 0;
601 itimer
->type
= which
;
602 itimer
->caller_thread
= th
;
603 /* Request that no more than 64KB of stack be reserved for this
604 thread, to avoid reserving too much memory, which would get in
605 the way of threads we start to wait for subprocesses. See also
607 itimer
->timer_thread
= CreateThread (NULL
, 64 * 1024, timer_loop
,
608 (void *)itimer
, 0x00010000, &tid
);
610 if (!itimer
->timer_thread
)
612 CloseHandle (itimer
->caller_thread
);
613 itimer
->caller_thread
= NULL
;
618 /* This is needed to make sure that the timer thread running for
619 profiling gets CPU as soon as the Sleep call terminates. */
620 if (which
== ITIMER_PROF
)
621 SetThreadPriority (itimer
->timer_thread
, THREAD_PRIORITY_TIME_CRITICAL
);
626 /* Most of the code of getitimer and setitimer (but not of their
627 subroutines) was shamelessly stolen from itimer.c in the DJGPP
628 library, see www.delorie.com/djgpp. */
630 getitimer (int which
, struct itimerval
*value
)
632 volatile ULONGLONG
*t_expire
;
633 volatile ULONGLONG
*t_reload
;
634 ULONGLONG expire
, reload
;
636 CRITICAL_SECTION
*crit
;
637 struct itimer_data
*itimer
;
648 if (which
!= ITIMER_REAL
&& which
!= ITIMER_PROF
)
654 itimer
= (which
== ITIMER_REAL
) ? &real_itimer
: &prof_itimer
;
656 ticks_now
= w32_get_timer_time ((which
== ITIMER_REAL
)
658 : GetCurrentThread ());
660 t_expire
= &itimer
->expire
;
661 t_reload
= &itimer
->reload
;
662 crit
= (which
== ITIMER_REAL
) ? &crit_real
: &crit_prof
;
664 EnterCriticalSection (crit
);
667 LeaveCriticalSection (crit
);
672 value
->it_value
.tv_sec
= expire
/ TIMER_TICKS_PER_SEC
;
674 (expire
% TIMER_TICKS_PER_SEC
) * (__int64
)1000000 / TIMER_TICKS_PER_SEC
;
675 value
->it_value
.tv_usec
= usecs
;
676 value
->it_interval
.tv_sec
= reload
/ TIMER_TICKS_PER_SEC
;
678 (reload
% TIMER_TICKS_PER_SEC
) * (__int64
)1000000 / TIMER_TICKS_PER_SEC
;
679 value
->it_interval
.tv_usec
= usecs
;
685 setitimer(int which
, struct itimerval
*value
, struct itimerval
*ovalue
)
687 volatile ULONGLONG
*t_expire
, *t_reload
;
688 ULONGLONG expire
, reload
, expire_old
, reload_old
;
690 CRITICAL_SECTION
*crit
;
691 struct itimerval tem
, *ptem
;
696 /* Posix systems expect timer values smaller than the resolution of
697 the system clock be rounded up to the clock resolution. First
698 time we are called, measure the clock tick resolution. */
703 for (t1
= w32_get_timer_time (NULL
);
704 (t2
= w32_get_timer_time (NULL
)) == t1
; )
706 clocks_min
= t2
- t1
;
714 if (getitimer (which
, ptem
)) /* also sets ticks_now */
715 return -1; /* errno already set */
718 (which
== ITIMER_REAL
) ? &real_itimer
.expire
: &prof_itimer
.expire
;
720 (which
== ITIMER_REAL
) ? &real_itimer
.reload
: &prof_itimer
.reload
;
722 crit
= (which
== ITIMER_REAL
) ? &crit_real
: &crit_prof
;
725 || (value
->it_value
.tv_sec
== 0 && value
->it_value
.tv_usec
== 0))
727 EnterCriticalSection (crit
);
728 /* Disable the timer. */
731 LeaveCriticalSection (crit
);
735 reload
= value
->it_interval
.tv_sec
* TIMER_TICKS_PER_SEC
;
737 usecs
= value
->it_interval
.tv_usec
;
738 if (value
->it_interval
.tv_sec
== 0
739 && usecs
&& usecs
* TIMER_TICKS_PER_SEC
< clocks_min
* 1000000)
743 usecs
*= TIMER_TICKS_PER_SEC
;
744 reload
+= usecs
/ 1000000;
747 expire
= value
->it_value
.tv_sec
* TIMER_TICKS_PER_SEC
;
748 usecs
= value
->it_value
.tv_usec
;
749 if (value
->it_value
.tv_sec
== 0
750 && usecs
* TIMER_TICKS_PER_SEC
< clocks_min
* 1000000)
754 usecs
*= TIMER_TICKS_PER_SEC
;
755 expire
+= usecs
/ 1000000;
760 EnterCriticalSection (crit
);
761 expire_old
= *t_expire
;
762 reload_old
= *t_reload
;
763 if (!(expire
== expire_old
&& reload
== reload_old
))
768 LeaveCriticalSection (crit
);
770 return start_timer_thread (which
);
776 #ifdef HAVE_SETITIMER
777 struct itimerval new_values
, old_values
;
779 new_values
.it_value
.tv_sec
= seconds
;
780 new_values
.it_value
.tv_usec
= 0;
781 new_values
.it_interval
.tv_sec
= new_values
.it_interval
.tv_usec
= 0;
783 if (setitimer (ITIMER_REAL
, &new_values
, &old_values
) < 0)
785 return old_values
.it_value
.tv_sec
;
791 /* Defined in <process.h> which conflicts with the local copy */
794 /* Child process management list. */
795 int child_proc_count
= 0;
796 child_process child_procs
[ MAX_CHILDREN
];
798 static DWORD WINAPI
reader_thread (void *arg
);
800 /* Find an unused process slot. */
807 for (cp
= child_procs
+ (child_proc_count
-1); cp
>= child_procs
; cp
--)
808 if (!CHILD_ACTIVE (cp
) && cp
->procinfo
.hProcess
== NULL
)
810 if (child_proc_count
== MAX_CHILDREN
)
813 child_process
*dead_cp
= NULL
;
815 DebPrint (("new_child: No vacant slots, looking for dead processes\n"));
816 for (cp
= child_procs
+ (child_proc_count
-1); cp
>= child_procs
; cp
--)
817 if (!CHILD_ACTIVE (cp
) && cp
->procinfo
.hProcess
)
821 if (!GetExitCodeProcess (cp
->procinfo
.hProcess
, &status
))
823 DebPrint (("new_child.GetExitCodeProcess: error %lu for PID %lu\n",
824 GetLastError (), cp
->procinfo
.dwProcessId
));
825 status
= STILL_ACTIVE
;
827 if (status
!= STILL_ACTIVE
828 || WaitForSingleObject (cp
->procinfo
.hProcess
, 0) == WAIT_OBJECT_0
)
830 DebPrint (("new_child: Freeing slot of dead process %d, fd %d\n",
831 cp
->procinfo
.dwProcessId
, cp
->fd
));
832 CloseHandle (cp
->procinfo
.hProcess
);
833 cp
->procinfo
.hProcess
= NULL
;
834 CloseHandle (cp
->procinfo
.hThread
);
835 cp
->procinfo
.hThread
= NULL
;
836 /* Free up to 2 dead slots at a time, so that if we
837 have a lot of them, they will eventually all be
838 freed when the tornado ends. */
852 if (child_proc_count
== MAX_CHILDREN
)
854 cp
= &child_procs
[child_proc_count
++];
857 /* Last opportunity to avoid leaking handles before we forget them
859 if (cp
->procinfo
.hProcess
)
860 CloseHandle (cp
->procinfo
.hProcess
);
861 if (cp
->procinfo
.hThread
)
862 CloseHandle (cp
->procinfo
.hThread
);
863 memset (cp
, 0, sizeof (*cp
));
866 cp
->procinfo
.hProcess
= NULL
;
867 cp
->status
= STATUS_READ_ERROR
;
869 /* use manual reset event so that select() will function properly */
870 cp
->char_avail
= CreateEvent (NULL
, TRUE
, FALSE
, NULL
);
873 cp
->char_consumed
= CreateEvent (NULL
, FALSE
, FALSE
, NULL
);
874 if (cp
->char_consumed
)
876 /* The 0x00010000 flag is STACK_SIZE_PARAM_IS_A_RESERVATION.
877 It means that the 64K stack we are requesting in the 2nd
878 argument is how much memory should be reserved for the
879 stack. If we don't use this flag, the memory requested
880 by the 2nd argument is the amount actually _committed_,
881 but Windows reserves 8MB of memory for each thread's
882 stack. (The 8MB figure comes from the -stack
883 command-line argument we pass to the linker when building
884 Emacs, but that's because we need a large stack for
885 Emacs's main thread.) Since we request 2GB of reserved
886 memory at startup (see w32heap.c), which is close to the
887 maximum memory available for a 32-bit process on Windows,
888 the 8MB reservation for each thread causes failures in
889 starting subprocesses, because we create a thread running
890 reader_thread for each subprocess. As 8MB of stack is
891 way too much for reader_thread, forcing Windows to
892 reserve less wins the day. */
893 cp
->thrd
= CreateThread (NULL
, 64 * 1024, reader_thread
, cp
,
904 delete_child (child_process
*cp
)
908 /* Should not be deleting a child that is still needed. */
909 for (i
= 0; i
< MAXDESC
; i
++)
910 if (fd_info
[i
].cp
== cp
)
913 if (!CHILD_ACTIVE (cp
) && cp
->procinfo
.hProcess
== NULL
)
916 /* reap thread if necessary */
921 if (GetExitCodeThread (cp
->thrd
, &rc
) && rc
== STILL_ACTIVE
)
923 /* let the thread exit cleanly if possible */
924 cp
->status
= STATUS_READ_ERROR
;
925 SetEvent (cp
->char_consumed
);
927 /* We used to forcibly terminate the thread here, but it
928 is normally unnecessary, and in abnormal cases, the worst that
929 will happen is we have an extra idle thread hanging around
930 waiting for the zombie process. */
931 if (WaitForSingleObject (cp
->thrd
, 1000) != WAIT_OBJECT_0
)
933 DebPrint (("delete_child.WaitForSingleObject (thread) failed "
934 "with %lu for fd %ld\n", GetLastError (), cp
->fd
));
935 TerminateThread (cp
->thrd
, 0);
939 CloseHandle (cp
->thrd
);
944 CloseHandle (cp
->char_avail
);
945 cp
->char_avail
= NULL
;
947 if (cp
->char_consumed
)
949 CloseHandle (cp
->char_consumed
);
950 cp
->char_consumed
= NULL
;
953 /* update child_proc_count (highest numbered slot in use plus one) */
954 if (cp
== child_procs
+ child_proc_count
- 1)
956 for (i
= child_proc_count
-1; i
>= 0; i
--)
957 if (CHILD_ACTIVE (&child_procs
[i
])
958 || child_procs
[i
].procinfo
.hProcess
!= NULL
)
960 child_proc_count
= i
+ 1;
965 child_proc_count
= 0;
968 /* Find a child by pid. */
969 static child_process
*
970 find_child_pid (DWORD pid
)
974 for (cp
= child_procs
+ (child_proc_count
-1); cp
>= child_procs
; cp
--)
975 if ((CHILD_ACTIVE (cp
) || cp
->procinfo
.hProcess
!= NULL
)
982 release_listen_threads (void)
986 for (i
= child_proc_count
- 1; i
>= 0; i
--)
988 if (CHILD_ACTIVE (&child_procs
[i
])
989 && (fd_info
[child_procs
[i
].fd
].flags
& FILE_LISTEN
))
990 child_procs
[i
].status
= STATUS_READ_ERROR
;
994 /* Thread proc for child process and socket reader threads. Each thread
995 is normally blocked until woken by select() to check for input by
996 reading one char. When the read completes, char_avail is signaled
997 to wake up the select emulator and the thread blocks itself again. */
999 reader_thread (void *arg
)
1004 cp
= (child_process
*)arg
;
1006 /* We have to wait for the go-ahead before we can start */
1008 || WaitForSingleObject (cp
->char_consumed
, INFINITE
) != WAIT_OBJECT_0
1016 if (cp
->fd
>= 0 && fd_info
[cp
->fd
].flags
& FILE_LISTEN
)
1017 rc
= _sys_wait_accept (cp
->fd
);
1019 rc
= _sys_read_ahead (cp
->fd
);
1021 /* Don't bother waiting for the event if we already have been
1022 told to exit by delete_child. */
1023 if (cp
->status
== STATUS_READ_ERROR
|| !cp
->char_avail
)
1026 /* The name char_avail is a misnomer - it really just means the
1027 read-ahead has completed, whether successfully or not. */
1028 if (!SetEvent (cp
->char_avail
))
1030 DebPrint (("reader_thread.SetEvent(0x%x) failed with %lu for fd %ld (PID %d)\n",
1031 (DWORD_PTR
)cp
->char_avail
, GetLastError (),
1036 if (rc
== STATUS_READ_ERROR
)
1039 /* If the read died, the child has died so let the thread die */
1040 if (rc
== STATUS_READ_FAILED
)
1043 /* Don't bother waiting for the acknowledge if we already have
1044 been told to exit by delete_child. */
1045 if (cp
->status
== STATUS_READ_ERROR
|| !cp
->char_consumed
)
1048 /* Wait until our input is acknowledged before reading again */
1049 if (WaitForSingleObject (cp
->char_consumed
, INFINITE
) != WAIT_OBJECT_0
)
1051 DebPrint (("reader_thread.WaitForSingleObject failed with "
1052 "%lu for fd %ld\n", GetLastError (), cp
->fd
));
1055 /* delete_child sets status to STATUS_READ_ERROR when it wants
1057 if (cp
->status
== STATUS_READ_ERROR
)
1063 /* To avoid Emacs changing directory, we just record here the
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
];
1082 if (cp
== NULL
) emacs_abort ();
1084 memset (&start
, 0, sizeof (start
));
1085 start
.cb
= sizeof (start
);
1088 if (NILP (Vw32_start_process_show_window
) && !is_gui_app
)
1089 start
.dwFlags
= STARTF_USESTDHANDLES
| STARTF_USESHOWWINDOW
;
1091 start
.dwFlags
= STARTF_USESTDHANDLES
;
1092 start
.wShowWindow
= SW_HIDE
;
1094 start
.hStdInput
= GetStdHandle (STD_INPUT_HANDLE
);
1095 start
.hStdOutput
= GetStdHandle (STD_OUTPUT_HANDLE
);
1096 start
.hStdError
= GetStdHandle (STD_ERROR_HANDLE
);
1097 #endif /* HAVE_NTGUI */
1100 /* Explicitly specify no security */
1101 if (!InitializeSecurityDescriptor (&sec_desc
, SECURITY_DESCRIPTOR_REVISION
))
1103 if (!SetSecurityDescriptorDacl (&sec_desc
, TRUE
, NULL
, FALSE
))
1106 sec_attrs
.nLength
= sizeof (sec_attrs
);
1107 sec_attrs
.lpSecurityDescriptor
= NULL
/* &sec_desc */;
1108 sec_attrs
.bInheritHandle
= FALSE
;
1110 filename_to_ansi (process_dir
, dir
);
1111 /* Can't use unixtodos_filename here, since that needs its file name
1112 argument encoded in UTF-8. OTOH, process_dir, which _is_ in
1113 UTF-8, points, to the directory computed by our caller, and we
1114 don't want to modify that, either. */
1115 for (p
= dir
; *p
; p
= CharNextA (p
))
1119 flags
= (!NILP (Vw32_start_process_share_console
)
1120 ? CREATE_NEW_PROCESS_GROUP
1121 : CREATE_NEW_CONSOLE
);
1122 if (NILP (Vw32_start_process_inherit_error_mode
))
1123 flags
|= CREATE_DEFAULT_ERROR_MODE
;
1124 if (!CreateProcessA (exe
, cmdline
, &sec_attrs
, NULL
, TRUE
,
1125 flags
, env
, dir
, &start
, &cp
->procinfo
))
1128 cp
->pid
= (int) cp
->procinfo
.dwProcessId
;
1130 /* Hack for Windows 95, which assigns large (ie negative) pids */
1139 DebPrint (("create_child.CreateProcess failed: %ld\n", GetLastError ()););
1143 /* create_child doesn't know what emacs's file handle will be for waiting
1144 on output from the child, so we need to make this additional call
1145 to register the handle with the process
1146 This way the select emulator knows how to match file handles with
1147 entries in child_procs. */
1149 register_child (pid_t pid
, int fd
)
1153 cp
= find_child_pid ((DWORD
)pid
);
1156 DebPrint (("register_child unable to find pid %lu\n", pid
));
1161 DebPrint (("register_child registered fd %d with pid %lu\n", fd
, pid
));
1166 /* thread is initially blocked until select is called; set status so
1167 that select will release thread */
1168 cp
->status
= STATUS_READ_ACKNOWLEDGED
;
1170 /* attach child_process to fd_info */
1171 if (fd_info
[fd
].cp
!= NULL
)
1173 DebPrint (("register_child: fd_info[%d] apparently in use!\n", fd
));
1177 fd_info
[fd
].cp
= cp
;
1180 /* Called from waitpid when a process exits. */
1182 reap_subprocess (child_process
*cp
)
1184 if (cp
->procinfo
.hProcess
)
1186 /* Reap the process */
1188 /* Process should have already died before we are called. */
1189 if (WaitForSingleObject (cp
->procinfo
.hProcess
, 0) != WAIT_OBJECT_0
)
1190 DebPrint (("reap_subprocess: child for fd %d has not died yet!", cp
->fd
));
1192 CloseHandle (cp
->procinfo
.hProcess
);
1193 cp
->procinfo
.hProcess
= NULL
;
1194 CloseHandle (cp
->procinfo
.hThread
);
1195 cp
->procinfo
.hThread
= NULL
;
1198 /* If cp->fd was not closed yet, we might be still reading the
1199 process output, so don't free its resources just yet. The call
1200 to delete_child on behalf of this subprocess will be made by
1201 sys_read when the subprocess output is fully read. */
1206 /* Wait for a child process specified by PID, or for any of our
1207 existing child processes (if PID is nonpositive) to die. When it
1208 does, close its handle. Return the pid of the process that died
1209 and fill in STATUS if non-NULL. */
1212 waitpid (pid_t pid
, int *status
, int options
)
1214 DWORD active
, retval
;
1216 child_process
*cp
, *cps
[MAX_CHILDREN
];
1217 HANDLE wait_hnd
[MAX_CHILDREN
];
1219 int dont_wait
= (options
& WNOHANG
) != 0;
1222 /* According to Posix:
1224 PID = -1 means status is requested for any child process.
1226 PID > 0 means status is requested for a single child process
1229 PID = 0 means status is requested for any child process whose
1230 process group ID is equal to that of the calling process. But
1231 since Windows has only a limited support for process groups (only
1232 for console processes and only for the purposes of passing
1233 Ctrl-BREAK signal to them), and since we have no documented way
1234 of determining whether a given process belongs to our group, we
1237 PID < -1 means status is requested for any child process whose
1238 process group ID is equal to the absolute value of PID. Again,
1239 since we don't support process groups, we treat that as -1. */
1244 /* We are requested to wait for a specific child. */
1245 for (cp
= child_procs
+ (child_proc_count
-1); cp
>= child_procs
; cp
--)
1247 /* Some child_procs might be sockets; ignore them. Also
1248 ignore subprocesses whose output is not yet completely
1250 if (CHILD_ACTIVE (cp
)
1251 && cp
->procinfo
.hProcess
1260 if (cp
->fd
< 0 || (fd_info
[cp
->fd
].flags
& FILE_AT_EOF
) != 0)
1262 wait_hnd
[nh
] = cp
->procinfo
.hProcess
;
1268 /* PID specifies our subprocess, but its status is not
1275 /* No such child process, or nothing to wait for, so fail. */
1282 for (cp
= child_procs
+ (child_proc_count
-1); cp
>= child_procs
; cp
--)
1284 if (CHILD_ACTIVE (cp
)
1285 && cp
->procinfo
.hProcess
1286 && (cp
->fd
< 0 || (fd_info
[cp
->fd
].flags
& FILE_AT_EOF
) != 0))
1288 wait_hnd
[nh
] = cp
->procinfo
.hProcess
;
1295 /* Nothing to wait on, so fail. */
1304 timeout_ms
= 1000; /* check for quit about once a second. */
1309 active
= WaitForMultipleObjects (nh
, wait_hnd
, FALSE
, timeout_ms
);
1310 } while (active
== WAIT_TIMEOUT
&& !dont_wait
);
1312 if (active
== WAIT_FAILED
)
1317 else if (active
== WAIT_TIMEOUT
&& dont_wait
)
1319 /* PID specifies our subprocess, but it didn't exit yet, so its
1320 status is not yet available. */
1322 DebPrint (("Wait: PID %d not reap yet\n", cp
->pid
));
1326 else if (active
>= WAIT_OBJECT_0
1327 && active
< WAIT_OBJECT_0
+MAXIMUM_WAIT_OBJECTS
)
1329 active
-= WAIT_OBJECT_0
;
1331 else if (active
>= WAIT_ABANDONED_0
1332 && active
< WAIT_ABANDONED_0
+MAXIMUM_WAIT_OBJECTS
)
1334 active
-= WAIT_ABANDONED_0
;
1339 if (!GetExitCodeProcess (wait_hnd
[active
], &retval
))
1341 DebPrint (("Wait.GetExitCodeProcess failed with %lu\n",
1345 if (retval
== STILL_ACTIVE
)
1347 /* Should never happen. */
1348 DebPrint (("Wait.WaitForMultipleObjects returned an active process\n"));
1349 if (pid
> 0 && dont_wait
)
1355 /* Massage the exit code from the process to match the format expected
1356 by the WIFSTOPPED et al macros in syswait.h. Only WIFSIGNALED and
1357 WIFEXITED are supported; WIFSTOPPED doesn't make sense under NT. */
1359 if (retval
== STATUS_CONTROL_C_EXIT
)
1364 if (pid
> 0 && active
!= 0)
1369 DebPrint (("Wait signaled with process pid %d\n", cp
->pid
));
1374 reap_subprocess (cp
);
1379 /* Old versions of w32api headers don't have separate 32-bit and
1380 64-bit defines, but the one they have matches the 32-bit variety. */
1381 #ifndef IMAGE_NT_OPTIONAL_HDR32_MAGIC
1382 # define IMAGE_NT_OPTIONAL_HDR32_MAGIC IMAGE_NT_OPTIONAL_HDR_MAGIC
1383 # define IMAGE_OPTIONAL_HEADER32 IMAGE_OPTIONAL_HEADER
1386 /* Implementation note: This function works with file names encoded in
1387 the current ANSI codepage. */
1389 w32_executable_type (char * filename
,
1391 int * is_cygnus_app
,
1394 file_data executable
;
1397 /* Default values in case we can't tell for sure. */
1398 *is_dos_app
= FALSE
;
1399 *is_cygnus_app
= FALSE
;
1400 *is_gui_app
= FALSE
;
1402 if (!open_input_file (&executable
, filename
))
1405 p
= strrchr (filename
, '.');
1407 /* We can only identify DOS .com programs from the extension. */
1408 if (p
&& xstrcasecmp (p
, ".com") == 0)
1410 else if (p
&& (xstrcasecmp (p
, ".bat") == 0
1411 || xstrcasecmp (p
, ".cmd") == 0))
1413 /* A DOS shell script - it appears that CreateProcess is happy to
1414 accept this (somewhat surprisingly); presumably it looks at
1415 COMSPEC to determine what executable to actually invoke.
1416 Therefore, we have to do the same here as well. */
1417 /* Actually, I think it uses the program association for that
1418 extension, which is defined in the registry. */
1419 p
= egetenv ("COMSPEC");
1421 w32_executable_type (p
, is_dos_app
, is_cygnus_app
, is_gui_app
);
1425 /* Look for DOS .exe signature - if found, we must also check that
1426 it isn't really a 16- or 32-bit Windows exe, since both formats
1427 start with a DOS program stub. Note that 16-bit Windows
1428 executables use the OS/2 1.x format. */
1430 IMAGE_DOS_HEADER
* dos_header
;
1431 IMAGE_NT_HEADERS
* nt_header
;
1433 dos_header
= (PIMAGE_DOS_HEADER
) executable
.file_base
;
1434 if (dos_header
->e_magic
!= IMAGE_DOS_SIGNATURE
)
1437 nt_header
= (PIMAGE_NT_HEADERS
) ((unsigned char *) dos_header
+ dos_header
->e_lfanew
);
1439 if ((char *) nt_header
> (char *) dos_header
+ executable
.size
)
1441 /* Some dos headers (pkunzip) have bogus e_lfanew fields. */
1444 else if (nt_header
->Signature
!= IMAGE_NT_SIGNATURE
1445 && LOWORD (nt_header
->Signature
) != IMAGE_OS2_SIGNATURE
)
1449 else if (nt_header
->Signature
== IMAGE_NT_SIGNATURE
)
1451 IMAGE_DATA_DIRECTORY
*data_dir
= NULL
;
1452 if (nt_header
->OptionalHeader
.Magic
== IMAGE_NT_OPTIONAL_HDR32_MAGIC
)
1454 /* Ensure we are using the 32 bit structure. */
1455 IMAGE_OPTIONAL_HEADER32
*opt
1456 = (IMAGE_OPTIONAL_HEADER32
*) &(nt_header
->OptionalHeader
);
1457 data_dir
= opt
->DataDirectory
;
1458 *is_gui_app
= (opt
->Subsystem
== IMAGE_SUBSYSTEM_WINDOWS_GUI
);
1460 /* MingW 3.12 has the required 64 bit structs, but in case older
1461 versions don't, only check 64 bit exes if we know how. */
1462 #ifdef IMAGE_NT_OPTIONAL_HDR64_MAGIC
1463 else if (nt_header
->OptionalHeader
.Magic
1464 == IMAGE_NT_OPTIONAL_HDR64_MAGIC
)
1466 IMAGE_OPTIONAL_HEADER64
*opt
1467 = (IMAGE_OPTIONAL_HEADER64
*) &(nt_header
->OptionalHeader
);
1468 data_dir
= opt
->DataDirectory
;
1469 *is_gui_app
= (opt
->Subsystem
== IMAGE_SUBSYSTEM_WINDOWS_GUI
);
1474 /* Look for cygwin.dll in DLL import list. */
1475 IMAGE_DATA_DIRECTORY import_dir
=
1476 data_dir
[IMAGE_DIRECTORY_ENTRY_IMPORT
];
1477 IMAGE_IMPORT_DESCRIPTOR
* imports
;
1478 IMAGE_SECTION_HEADER
* section
;
1480 section
= rva_to_section (import_dir
.VirtualAddress
, nt_header
);
1481 imports
= RVA_TO_PTR (import_dir
.VirtualAddress
, section
,
1484 for ( ; imports
->Name
; imports
++)
1486 char * dllname
= RVA_TO_PTR (imports
->Name
, section
,
1489 /* The exact name of the cygwin dll has changed with
1490 various releases, but hopefully this will be reasonably
1492 if (strncmp (dllname
, "cygwin", 6) == 0)
1494 *is_cygnus_app
= TRUE
;
1503 close_file_data (&executable
);
1507 compare_env (const void *strp1
, const void *strp2
)
1509 const char *str1
= *(const char **)strp1
, *str2
= *(const char **)strp2
;
1511 while (*str1
&& *str2
&& *str1
!= '=' && *str2
!= '=')
1513 /* Sort order in command.com/cmd.exe is based on uppercasing
1514 names, so do the same here. */
1515 if (toupper (*str1
) > toupper (*str2
))
1517 else if (toupper (*str1
) < toupper (*str2
))
1522 if (*str1
== '=' && *str2
== '=')
1524 else if (*str1
== '=')
1531 merge_and_sort_env (char **envp1
, char **envp2
, char **new_envp
)
1533 char **optr
, **nptr
;
1545 num
+= optr
- envp2
;
1547 qsort (new_envp
, num
, sizeof (char *), compare_env
);
1552 /* When a new child process is created we need to register it in our list,
1553 so intercept spawn requests. */
1555 sys_spawnve (int mode
, char *cmdname
, char **argv
, char **envp
)
1557 Lisp_Object program
, full
;
1558 char *cmdline
, *env
, *parg
, **targ
;
1562 int is_dos_app
, is_cygnus_app
, is_gui_app
;
1564 /* We pass our process ID to our children by setting up an environment
1565 variable in their environment. */
1566 char ppid_env_var_buffer
[64];
1567 char *extra_env
[] = {ppid_env_var_buffer
, NULL
};
1568 /* These are the characters that cause an argument to need quoting.
1569 Arguments with whitespace characters need quoting to prevent the
1570 argument being split into two or more. Arguments with wildcards
1571 are also quoted, for consistency with posix platforms, where wildcards
1572 are not expanded if we run the program directly without a shell.
1573 Some extra whitespace characters need quoting in Cygwin programs,
1574 so this list is conditionally modified below. */
1575 char *sepchars
= " \t*?";
1576 /* This is for native w32 apps; modified below for Cygwin apps. */
1577 char escape_char
= '\\';
1578 char cmdname_a
[MAX_PATH
];
1580 /* We don't care about the other modes */
1581 if (mode
!= _P_NOWAIT
)
1587 /* Handle executable names without an executable suffix. The caller
1588 already searched exec-path and verified the file is executable,
1589 but start-process doesn't do that for file names that are already
1590 absolute. So we double-check this here, just in case. */
1591 if (faccessat (AT_FDCWD
, cmdname
, X_OK
, AT_EACCESS
) != 0)
1593 struct gcpro gcpro1
;
1595 program
= build_string (cmdname
);
1598 openp (Vexec_path
, program
, Vexec_suffixes
, &full
, make_number (X_OK
), 0);
1605 program
= ENCODE_FILE (full
);
1606 cmdname
= SDATA (program
);
1610 char *p
= alloca (strlen (cmdname
) + 1);
1612 /* Don't change the command name we were passed by our caller
1613 (unixtodos_filename below will destructively mirror forward
1615 cmdname
= strcpy (p
, cmdname
);
1618 /* make sure argv[0] and cmdname are both in DOS format */
1619 unixtodos_filename (cmdname
);
1620 /* argv[0] was encoded by caller using ENCODE_FILE, so it is in
1621 UTF-8. All the other arguments are encoded by ENCODE_SYSTEM or
1622 some such, and are in some ANSI codepage. We need to have
1623 argv[0] encoded in ANSI codepage. */
1624 filename_to_ansi (cmdname
, cmdname_a
);
1625 /* We explicitly require that the command's file name be encodable
1626 in the current ANSI codepage, because we will be invoking it via
1628 if (_mbspbrk (cmdname_a
, "?"))
1633 /* From here on, CMDNAME is an ANSI-encoded string. */
1634 cmdname
= cmdname_a
;
1637 /* Determine whether program is a 16-bit DOS executable, or a 32-bit Windows
1638 executable that is implicitly linked to the Cygnus dll (implying it
1639 was compiled with the Cygnus GNU toolchain and hence relies on
1640 cygwin.dll to parse the command line - we use this to decide how to
1641 escape quote chars in command line args that must be quoted).
1643 Also determine whether it is a GUI app, so that we don't hide its
1644 initial window unless specifically requested. */
1645 w32_executable_type (cmdname
, &is_dos_app
, &is_cygnus_app
, &is_gui_app
);
1647 /* On Windows 95, if cmdname is a DOS app, we invoke a helper
1648 application to start it by specifying the helper app as cmdname,
1649 while leaving the real app name as argv[0]. */
1654 cmdname
= alloca (MAX_PATH
);
1655 if (egetenv ("CMDPROXY"))
1656 strcpy (cmdname
, egetenv ("CMDPROXY"));
1659 lispstpcpy (cmdname
, Vinvocation_directory
);
1660 strcat (cmdname
, "cmdproxy.exe");
1663 /* Can't use unixtodos_filename here, since that needs its file
1664 name argument encoded in UTF-8. */
1665 for (p
= cmdname
; *p
; p
= CharNextA (p
))
1670 /* we have to do some conjuring here to put argv and envp into the
1671 form CreateProcess wants... argv needs to be a space separated/null
1672 terminated list of parameters, and envp is a null
1673 separated/double-null terminated list of parameters.
1675 Additionally, zero-length args and args containing whitespace or
1676 quote chars need to be wrapped in double quotes - for this to work,
1677 embedded quotes need to be escaped as well. The aim is to ensure
1678 the child process reconstructs the argv array we start with
1679 exactly, so we treat quotes at the beginning and end of arguments
1682 The w32 GNU-based library from Cygnus doubles quotes to escape
1683 them, while MSVC uses backslash for escaping. (Actually the MSVC
1684 startup code does attempt to recognize doubled quotes and accept
1685 them, but gets it wrong and ends up requiring three quotes to get a
1686 single embedded quote!) So by default we decide whether to use
1687 quote or backslash as the escape character based on whether the
1688 binary is apparently a Cygnus compiled app.
1690 Note that using backslash to escape embedded quotes requires
1691 additional special handling if an embedded quote is already
1692 preceded by backslash, or if an arg requiring quoting ends with
1693 backslash. In such cases, the run of escape characters needs to be
1694 doubled. For consistency, we apply this special handling as long
1695 as the escape character is not quote.
1697 Since we have no idea how large argv and envp are likely to be we
1698 figure out list lengths on the fly and allocate them. */
1700 if (!NILP (Vw32_quote_process_args
))
1703 /* Override escape char by binding w32-quote-process-args to
1704 desired character, or use t for auto-selection. */
1705 if (INTEGERP (Vw32_quote_process_args
))
1706 escape_char
= XINT (Vw32_quote_process_args
);
1708 escape_char
= is_cygnus_app
? '"' : '\\';
1711 /* Cygwin apps needs quoting a bit more often. */
1712 if (escape_char
== '"')
1713 sepchars
= "\r\n\t\f '";
1721 int need_quotes
= 0;
1722 int escape_char_run
= 0;
1728 if (escape_char
== '"' && *p
== '\\')
1729 /* If it's a Cygwin app, \ needs to be escaped. */
1733 /* allow for embedded quotes to be escaped */
1736 /* handle the case where the embedded quote is already escaped */
1737 if (escape_char_run
> 0)
1739 /* To preserve the arg exactly, we need to double the
1740 preceding escape characters (plus adding one to
1741 escape the quote character itself). */
1742 arglen
+= escape_char_run
;
1745 else if (strchr (sepchars
, *p
) != NULL
)
1750 if (*p
== escape_char
&& escape_char
!= '"')
1753 escape_char_run
= 0;
1758 /* handle the case where the arg ends with an escape char - we
1759 must not let the enclosing quote be escaped. */
1760 if (escape_char_run
> 0)
1761 arglen
+= escape_char_run
;
1763 arglen
+= strlen (*targ
++) + 1;
1765 cmdline
= alloca (arglen
);
1771 int need_quotes
= 0;
1779 if ((strchr (sepchars
, *p
) != NULL
) || *p
== '"')
1784 int escape_char_run
= 0;
1790 /* last = p + strlen (p) - 1; */
1793 /* This version does not escape quotes if they occur at the
1794 beginning or end of the arg - this could lead to incorrect
1795 behavior when the arg itself represents a command line
1796 containing quoted args. I believe this was originally done
1797 as a hack to make some things work, before
1798 `w32-quote-process-args' was added. */
1801 if (*p
== '"' && p
> first
&& p
< last
)
1802 *parg
++ = escape_char
; /* escape embedded quotes */
1810 /* double preceding escape chars if any */
1811 while (escape_char_run
> 0)
1813 *parg
++ = escape_char
;
1816 /* escape all quote chars, even at beginning or end */
1817 *parg
++ = escape_char
;
1819 else if (escape_char
== '"' && *p
== '\\')
1823 if (*p
== escape_char
&& escape_char
!= '"')
1826 escape_char_run
= 0;
1828 /* double escape chars before enclosing quote */
1829 while (escape_char_run
> 0)
1831 *parg
++ = escape_char
;
1839 strcpy (parg
, *targ
);
1840 parg
+= strlen (*targ
);
1850 numenv
= 1; /* for end null */
1853 arglen
+= strlen (*targ
++) + 1;
1856 /* extra env vars... */
1857 sprintf (ppid_env_var_buffer
, "EM_PARENT_PROCESS_ID=%lu",
1858 GetCurrentProcessId ());
1859 arglen
+= strlen (ppid_env_var_buffer
) + 1;
1862 /* merge env passed in and extra env into one, and sort it. */
1863 targ
= (char **) alloca (numenv
* sizeof (char *));
1864 merge_and_sort_env (envp
, extra_env
, targ
);
1866 /* concatenate env entries. */
1867 env
= alloca (arglen
);
1871 strcpy (parg
, *targ
);
1872 parg
+= strlen (*targ
++);
1885 /* Now create the process. */
1886 if (!create_child (cmdname
, cmdline
, env
, is_gui_app
, &pid
, cp
))
1896 /* Emulate the select call
1897 Wait for available input on any of the given rfds, or timeout if
1898 a timeout is given and no input is detected
1899 wfds and efds are not supported and must be NULL.
1901 For simplicity, we detect the death of child processes here and
1902 synchronously call the SIGCHLD handler. Since it is possible for
1903 children to be created without a corresponding pipe handle from which
1904 to read output, we wait separately on the process handles as well as
1905 the char_avail events for each process pipe. We only call
1906 wait/reap_process when the process actually terminates.
1908 To reduce the number of places in which Emacs can be hung such that
1909 C-g is not able to interrupt it, we always wait on interrupt_handle
1910 (which is signaled by the input thread when C-g is detected). If we
1911 detect that we were woken up by C-g, we return -1 with errno set to
1912 EINTR as on Unix. */
1914 /* From w32console.c */
1915 extern HANDLE keyboard_handle
;
1917 /* From w32xfns.c */
1918 extern HANDLE interrupt_handle
;
1920 /* From process.c */
1921 extern int proc_buffered_char
[];
1924 sys_select (int nfds
, SELECT_TYPE
*rfds
, SELECT_TYPE
*wfds
, SELECT_TYPE
*efds
,
1925 struct timespec
*timeout
, void *ignored
)
1928 DWORD timeout_ms
, start_time
;
1931 child_process
*cp
, *cps
[MAX_CHILDREN
];
1932 HANDLE wait_hnd
[MAXDESC
+ MAX_CHILDREN
];
1933 int fdindex
[MAXDESC
]; /* mapping from wait handles back to descriptors */
1936 timeout
? (timeout
->tv_sec
* 1000 + timeout
->tv_nsec
/ 1000000) : INFINITE
;
1938 /* If the descriptor sets are NULL but timeout isn't, then just Sleep. */
1939 if (rfds
== NULL
&& wfds
== NULL
&& efds
== NULL
&& timeout
!= NULL
)
1945 /* Otherwise, we only handle rfds, so fail otherwise. */
1946 if (rfds
== NULL
|| wfds
!= NULL
|| efds
!= NULL
)
1956 /* If interrupt_handle is available and valid, always wait on it, to
1957 detect C-g (quit). */
1959 if (interrupt_handle
&& interrupt_handle
!= INVALID_HANDLE_VALUE
)
1961 wait_hnd
[0] = interrupt_handle
;
1966 /* Build a list of pipe handles to wait on. */
1967 for (i
= 0; i
< nfds
; i
++)
1968 if (FD_ISSET (i
, &orfds
))
1972 if (keyboard_handle
)
1974 /* Handle stdin specially */
1975 wait_hnd
[nh
] = keyboard_handle
;
1980 /* Check for any emacs-generated input in the queue since
1981 it won't be detected in the wait */
1982 if (detect_input_pending ())
1987 else if (noninteractive
)
1989 if (handle_file_notifications (NULL
))
1995 /* Child process and socket/comm port input. */
1999 int current_status
= cp
->status
;
2001 if (current_status
== STATUS_READ_ACKNOWLEDGED
)
2003 /* Tell reader thread which file handle to use. */
2005 /* Wake up the reader thread for this process */
2006 cp
->status
= STATUS_READ_READY
;
2007 if (!SetEvent (cp
->char_consumed
))
2008 DebPrint (("sys_select.SetEvent failed with "
2009 "%lu for fd %ld\n", GetLastError (), i
));
2012 #ifdef CHECK_INTERLOCK
2013 /* slightly crude cross-checking of interlock between threads */
2015 current_status
= cp
->status
;
2016 if (WaitForSingleObject (cp
->char_avail
, 0) == WAIT_OBJECT_0
)
2018 /* char_avail has been signaled, so status (which may
2019 have changed) should indicate read has completed
2020 but has not been acknowledged. */
2021 current_status
= cp
->status
;
2022 if (current_status
!= STATUS_READ_SUCCEEDED
2023 && current_status
!= STATUS_READ_FAILED
)
2024 DebPrint (("char_avail set, but read not completed: status %d\n",
2029 /* char_avail has not been signaled, so status should
2030 indicate that read is in progress; small possibility
2031 that read has completed but event wasn't yet signaled
2032 when we tested it (because a context switch occurred
2033 or if running on separate CPUs). */
2034 if (current_status
!= STATUS_READ_READY
2035 && current_status
!= STATUS_READ_IN_PROGRESS
2036 && current_status
!= STATUS_READ_SUCCEEDED
2037 && current_status
!= STATUS_READ_FAILED
)
2038 DebPrint (("char_avail reset, but read status is bad: %d\n",
2042 wait_hnd
[nh
] = cp
->char_avail
;
2044 if (!wait_hnd
[nh
]) emacs_abort ();
2047 DebPrint (("select waiting on child %d fd %d\n",
2048 cp
-child_procs
, i
));
2053 /* Unable to find something to wait on for this fd, skip */
2055 /* Note that this is not a fatal error, and can in fact
2056 happen in unusual circumstances. Specifically, if
2057 sys_spawnve fails, eg. because the program doesn't
2058 exist, and debug-on-error is t so Fsignal invokes a
2059 nested input loop, then the process output pipe is
2060 still included in input_wait_mask with no child_proc
2061 associated with it. (It is removed when the debugger
2062 exits the nested input loop and the error is thrown.) */
2064 DebPrint (("sys_select: fd %ld is invalid! ignoring\n", i
));
2070 /* Add handles of child processes. */
2072 for (cp
= child_procs
+ (child_proc_count
-1); cp
>= child_procs
; cp
--)
2073 /* Some child_procs might be sockets; ignore them. Also some
2074 children may have died already, but we haven't finished reading
2075 the process output; ignore them too. */
2076 if ((CHILD_ACTIVE (cp
) && cp
->procinfo
.hProcess
)
2078 || (fd_info
[cp
->fd
].flags
& FILE_SEND_SIGCHLD
) == 0
2079 || (fd_info
[cp
->fd
].flags
& FILE_AT_EOF
) != 0)
2082 wait_hnd
[nh
+ nc
] = cp
->procinfo
.hProcess
;
2087 /* Nothing to look for, so we didn't find anything */
2094 if (handle_file_notifications (NULL
))
2100 start_time
= GetTickCount ();
2102 /* Wait for input or child death to be signaled. If user input is
2103 allowed, then also accept window messages. */
2104 if (FD_ISSET (0, &orfds
))
2105 active
= MsgWaitForMultipleObjects (nh
+ nc
, wait_hnd
, FALSE
, timeout_ms
,
2108 active
= WaitForMultipleObjects (nh
+ nc
, wait_hnd
, FALSE
, timeout_ms
);
2110 if (active
== WAIT_FAILED
)
2112 DebPrint (("select.WaitForMultipleObjects (%d, %lu) failed with %lu\n",
2113 nh
+ nc
, timeout_ms
, GetLastError ()));
2114 /* don't return EBADF - this causes wait_reading_process_output to
2115 abort; WAIT_FAILED is returned when single-stepping under
2116 Windows 95 after switching thread focus in debugger, and
2117 possibly at other times. */
2121 else if (active
== WAIT_TIMEOUT
)
2125 if (handle_file_notifications (NULL
))
2130 else if (active
>= WAIT_OBJECT_0
2131 && active
< WAIT_OBJECT_0
+MAXIMUM_WAIT_OBJECTS
)
2133 active
-= WAIT_OBJECT_0
;
2135 else if (active
>= WAIT_ABANDONED_0
2136 && active
< WAIT_ABANDONED_0
+MAXIMUM_WAIT_OBJECTS
)
2138 active
-= WAIT_ABANDONED_0
;
2143 /* Loop over all handles after active (now officially documented as
2144 being the first signaled handle in the array). We do this to
2145 ensure fairness, so that all channels with data available will be
2146 processed - otherwise higher numbered channels could be starved. */
2149 if (active
== nh
+ nc
)
2151 /* There are messages in the lisp thread's queue; we must
2152 drain the queue now to ensure they are processed promptly,
2153 because if we don't do so, we will not be woken again until
2154 further messages arrive.
2156 NB. If ever we allow window message procedures to callback
2157 into lisp, we will need to ensure messages are dispatched
2158 at a safe time for lisp code to be run (*), and we may also
2159 want to provide some hooks in the dispatch loop to cater
2160 for modeless dialogs created by lisp (ie. to register
2161 window handles to pass to IsDialogMessage).
2163 (*) Note that MsgWaitForMultipleObjects above is an
2164 internal dispatch point for messages that are sent to
2165 windows created by this thread. */
2166 if (drain_message_queue ()
2167 /* If drain_message_queue returns non-zero, that means
2168 we received a WM_EMACS_FILENOTIFY message. If this
2169 is a TTY frame, we must signal the caller that keyboard
2170 input is available, so that w32_console_read_socket
2171 will be called to pick up the notifications. If we
2172 don't do that, file notifications will only work when
2173 the Emacs TTY frame has focus. */
2174 && FRAME_TERMCAP_P (SELECTED_FRAME ())
2175 /* they asked for stdin reads */
2176 && FD_ISSET (0, &orfds
)
2177 /* the stdin handle is valid */
2185 else if (active
>= nh
)
2187 cp
= cps
[active
- nh
];
2189 /* We cannot always signal SIGCHLD immediately; if we have not
2190 finished reading the process output, we must delay sending
2191 SIGCHLD until we do. */
2193 if (cp
->fd
>= 0 && (fd_info
[cp
->fd
].flags
& FILE_AT_EOF
) == 0)
2194 fd_info
[cp
->fd
].flags
|= FILE_SEND_SIGCHLD
;
2195 /* SIG_DFL for SIGCHLD is ignore */
2196 else if (sig_handlers
[SIGCHLD
] != SIG_DFL
&&
2197 sig_handlers
[SIGCHLD
] != SIG_IGN
)
2200 DebPrint (("select calling SIGCHLD handler for pid %d\n",
2203 sig_handlers
[SIGCHLD
] (SIGCHLD
);
2206 else if (fdindex
[active
] == -1)
2208 /* Quit (C-g) was detected. */
2212 else if (fdindex
[active
] == 0)
2214 /* Keyboard input available */
2220 /* must be a socket or pipe - read ahead should have
2221 completed, either succeeding or failing. */
2222 FD_SET (fdindex
[active
], rfds
);
2226 /* Even though wait_reading_process_output only reads from at most
2227 one channel, we must process all channels here so that we reap
2228 all children that have died. */
2229 while (++active
< nh
+ nc
)
2230 if (WaitForSingleObject (wait_hnd
[active
], 0) == WAIT_OBJECT_0
)
2232 } while (active
< nh
+ nc
);
2236 if (handle_file_notifications (NULL
))
2240 /* If no input has arrived and timeout hasn't expired, wait again. */
2243 DWORD elapsed
= GetTickCount () - start_time
;
2245 if (timeout_ms
> elapsed
) /* INFINITE is MAX_UINT */
2247 if (timeout_ms
!= INFINITE
)
2248 timeout_ms
-= elapsed
;
2249 goto count_children
;
2256 /* Substitute for certain kill () operations */
2258 static BOOL CALLBACK
2259 find_child_console (HWND hwnd
, LPARAM arg
)
2261 child_process
* cp
= (child_process
*) arg
;
2264 GetWindowThreadProcessId (hwnd
, &process_id
);
2265 if (process_id
== cp
->procinfo
.dwProcessId
)
2267 char window_class
[32];
2269 GetClassName (hwnd
, window_class
, sizeof (window_class
));
2270 if (strcmp (window_class
,
2271 (os_subtype
== OS_9X
)
2273 : "ConsoleWindowClass") == 0)
2283 /* Emulate 'kill', but only for other processes. */
2285 sys_kill (pid_t pid
, int sig
)
2289 int need_to_free
= 0;
2292 /* Each process is in its own process group. */
2296 /* Only handle signals that will result in the process dying */
2298 && sig
!= SIGINT
&& sig
!= SIGKILL
&& sig
!= SIGQUIT
&& sig
!= SIGHUP
)
2306 /* It will take _some_ time before PID 4 or less on Windows will
2313 proc_hand
= OpenProcess (PROCESS_QUERY_INFORMATION
, 0, pid
);
2314 if (proc_hand
== NULL
)
2316 DWORD err
= GetLastError ();
2320 case ERROR_ACCESS_DENIED
: /* existing process, but access denied */
2323 case ERROR_INVALID_PARAMETER
: /* process PID does not exist */
2329 CloseHandle (proc_hand
);
2333 cp
= find_child_pid (pid
);
2336 /* We were passed a PID of something other than our subprocess.
2337 If that is our own PID, we will send to ourself a message to
2338 close the selected frame, which does not necessarily
2339 terminates Emacs. But then we are not supposed to call
2340 sys_kill with our own PID. */
2341 proc_hand
= OpenProcess (PROCESS_TERMINATE
, 0, pid
);
2342 if (proc_hand
== NULL
)
2351 proc_hand
= cp
->procinfo
.hProcess
;
2352 pid
= cp
->procinfo
.dwProcessId
;
2354 /* Try to locate console window for process. */
2355 EnumWindows (find_child_console
, (LPARAM
) cp
);
2358 if (sig
== SIGINT
|| sig
== SIGQUIT
)
2360 if (NILP (Vw32_start_process_share_console
) && cp
&& cp
->hwnd
)
2362 BYTE control_scan_code
= (BYTE
) MapVirtualKey (VK_CONTROL
, 0);
2363 /* Fake Ctrl-C for SIGINT, and Ctrl-Break for SIGQUIT. */
2364 BYTE vk_break_code
= (sig
== SIGINT
) ? 'C' : VK_CANCEL
;
2365 BYTE break_scan_code
= (BYTE
) MapVirtualKey (vk_break_code
, 0);
2366 HWND foreground_window
;
2368 if (break_scan_code
== 0)
2370 /* Fake Ctrl-C for SIGQUIT if we can't manage Ctrl-Break. */
2371 vk_break_code
= 'C';
2372 break_scan_code
= (BYTE
) MapVirtualKey (vk_break_code
, 0);
2375 foreground_window
= GetForegroundWindow ();
2376 if (foreground_window
)
2378 /* NT 5.0, and apparently also Windows 98, will not allow
2379 a Window to be set to foreground directly without the
2380 user's involvement. The workaround is to attach
2381 ourselves to the thread that owns the foreground
2382 window, since that is the only thread that can set the
2383 foreground window. */
2384 DWORD foreground_thread
, child_thread
;
2386 GetWindowThreadProcessId (foreground_window
, NULL
);
2387 if (foreground_thread
== GetCurrentThreadId ()
2388 || !AttachThreadInput (GetCurrentThreadId (),
2389 foreground_thread
, TRUE
))
2390 foreground_thread
= 0;
2392 child_thread
= GetWindowThreadProcessId (cp
->hwnd
, NULL
);
2393 if (child_thread
== GetCurrentThreadId ()
2394 || !AttachThreadInput (GetCurrentThreadId (),
2395 child_thread
, TRUE
))
2398 /* Set the foreground window to the child. */
2399 if (SetForegroundWindow (cp
->hwnd
))
2401 /* Generate keystrokes as if user had typed Ctrl-Break or
2403 keybd_event (VK_CONTROL
, control_scan_code
, 0, 0);
2404 keybd_event (vk_break_code
, break_scan_code
,
2405 (vk_break_code
== 'C' ? 0 : KEYEVENTF_EXTENDEDKEY
), 0);
2406 keybd_event (vk_break_code
, break_scan_code
,
2407 (vk_break_code
== 'C' ? 0 : KEYEVENTF_EXTENDEDKEY
)
2408 | KEYEVENTF_KEYUP
, 0);
2409 keybd_event (VK_CONTROL
, control_scan_code
,
2410 KEYEVENTF_KEYUP
, 0);
2412 /* Sleep for a bit to give time for Emacs frame to respond
2413 to focus change events (if Emacs was active app). */
2416 SetForegroundWindow (foreground_window
);
2418 /* Detach from the foreground and child threads now that
2419 the foreground switching is over. */
2420 if (foreground_thread
)
2421 AttachThreadInput (GetCurrentThreadId (),
2422 foreground_thread
, FALSE
);
2424 AttachThreadInput (GetCurrentThreadId (),
2425 child_thread
, FALSE
);
2428 /* Ctrl-Break is NT equivalent of SIGINT. */
2429 else if (!GenerateConsoleCtrlEvent (CTRL_BREAK_EVENT
, pid
))
2431 DebPrint (("sys_kill.GenerateConsoleCtrlEvent return %d "
2432 "for pid %lu\n", GetLastError (), pid
));
2439 if (NILP (Vw32_start_process_share_console
) && cp
&& cp
->hwnd
)
2442 if (os_subtype
== OS_9X
)
2445 Another possibility is to try terminating the VDM out-right by
2446 calling the Shell VxD (id 0x17) V86 interface, function #4
2447 "SHELL_Destroy_VM", ie.
2453 First need to determine the current VM handle, and then arrange for
2454 the shellapi call to be made from the system vm (by using
2455 Switch_VM_and_callback).
2457 Could try to invoke DestroyVM through CallVxD.
2461 /* On Windows 95, posting WM_QUIT causes the 16-bit subsystem
2462 to hang when cmdproxy is used in conjunction with
2463 command.com for an interactive shell. Posting
2464 WM_CLOSE pops up a dialog that, when Yes is selected,
2465 does the same thing. TerminateProcess is also less
2466 than ideal in that subprocesses tend to stick around
2467 until the machine is shutdown, but at least it
2468 doesn't freeze the 16-bit subsystem. */
2469 PostMessage (cp
->hwnd
, WM_QUIT
, 0xff, 0);
2471 if (!TerminateProcess (proc_hand
, 0xff))
2473 DebPrint (("sys_kill.TerminateProcess returned %d "
2474 "for pid %lu\n", GetLastError (), pid
));
2481 PostMessage (cp
->hwnd
, WM_CLOSE
, 0, 0);
2483 /* Kill the process. On W32 this doesn't kill child processes
2484 so it doesn't work very well for shells which is why it's not
2485 used in every case. */
2486 else if (!TerminateProcess (proc_hand
, 0xff))
2488 DebPrint (("sys_kill.TerminateProcess returned %d "
2489 "for pid %lu\n", GetLastError (), pid
));
2496 CloseHandle (proc_hand
);
2501 /* The following two routines are used to manipulate stdin, stdout, and
2502 stderr of our child processes.
2504 Assuming that in, out, and err are *not* inheritable, we make them
2505 stdin, stdout, and stderr of the child as follows:
2507 - Save the parent's current standard handles.
2508 - Set the std handles to inheritable duplicates of the ones being passed in.
2509 (Note that _get_osfhandle() is an io.h procedure that retrieves the
2510 NT file handle for a crt file descriptor.)
2511 - Spawn the child, which inherits in, out, and err as stdin,
2512 stdout, and stderr. (see Spawnve)
2513 - Close the std handles passed to the child.
2514 - Reset the parent's standard handles to the saved handles.
2515 (see reset_standard_handles)
2516 We assume that the caller closes in, out, and err after calling us. */
2519 prepare_standard_handles (int in
, int out
, int err
, HANDLE handles
[3])
2522 HANDLE newstdin
, newstdout
, newstderr
;
2524 parent
= GetCurrentProcess ();
2526 handles
[0] = GetStdHandle (STD_INPUT_HANDLE
);
2527 handles
[1] = GetStdHandle (STD_OUTPUT_HANDLE
);
2528 handles
[2] = GetStdHandle (STD_ERROR_HANDLE
);
2530 /* make inheritable copies of the new handles */
2531 if (!DuplicateHandle (parent
,
2532 (HANDLE
) _get_osfhandle (in
),
2537 DUPLICATE_SAME_ACCESS
))
2538 report_file_error ("Duplicating input handle for child", Qnil
);
2540 if (!DuplicateHandle (parent
,
2541 (HANDLE
) _get_osfhandle (out
),
2546 DUPLICATE_SAME_ACCESS
))
2547 report_file_error ("Duplicating output handle for child", Qnil
);
2549 if (!DuplicateHandle (parent
,
2550 (HANDLE
) _get_osfhandle (err
),
2555 DUPLICATE_SAME_ACCESS
))
2556 report_file_error ("Duplicating error handle for child", Qnil
);
2558 /* and store them as our std handles */
2559 if (!SetStdHandle (STD_INPUT_HANDLE
, newstdin
))
2560 report_file_error ("Changing stdin handle", Qnil
);
2562 if (!SetStdHandle (STD_OUTPUT_HANDLE
, newstdout
))
2563 report_file_error ("Changing stdout handle", Qnil
);
2565 if (!SetStdHandle (STD_ERROR_HANDLE
, newstderr
))
2566 report_file_error ("Changing stderr handle", Qnil
);
2570 reset_standard_handles (int in
, int out
, int err
, HANDLE handles
[3])
2572 /* close the duplicated handles passed to the child */
2573 CloseHandle (GetStdHandle (STD_INPUT_HANDLE
));
2574 CloseHandle (GetStdHandle (STD_OUTPUT_HANDLE
));
2575 CloseHandle (GetStdHandle (STD_ERROR_HANDLE
));
2577 /* now restore parent's saved std handles */
2578 SetStdHandle (STD_INPUT_HANDLE
, handles
[0]);
2579 SetStdHandle (STD_OUTPUT_HANDLE
, handles
[1]);
2580 SetStdHandle (STD_ERROR_HANDLE
, handles
[2]);
2584 set_process_dir (char * dir
)
2589 /* To avoid problems with winsock implementations that work over dial-up
2590 connections causing or requiring a connection to exist while Emacs is
2591 running, Emacs no longer automatically loads winsock on startup if it
2592 is present. Instead, it will be loaded when open-network-stream is
2595 To allow full control over when winsock is loaded, we provide these
2596 two functions to dynamically load and unload winsock. This allows
2597 dial-up users to only be connected when they actually need to use
2601 extern HANDLE winsock_lib
;
2602 extern BOOL
term_winsock (void);
2603 extern BOOL
init_winsock (int load_now
);
2605 DEFUN ("w32-has-winsock", Fw32_has_winsock
, Sw32_has_winsock
, 0, 1, 0,
2606 doc
: /* Test for presence of the Windows socket library `winsock'.
2607 Returns non-nil if winsock support is present, nil otherwise.
2609 If the optional argument LOAD-NOW is non-nil, the winsock library is
2610 also loaded immediately if not already loaded. If winsock is loaded,
2611 the winsock local hostname is returned (since this may be different from
2612 the value of `system-name' and should supplant it), otherwise t is
2613 returned to indicate winsock support is present. */)
2614 (Lisp_Object load_now
)
2618 have_winsock
= init_winsock (!NILP (load_now
));
2621 if (winsock_lib
!= NULL
)
2623 /* Return new value for system-name. The best way to do this
2624 is to call init_system_name, saving and restoring the
2625 original value to avoid side-effects. */
2626 Lisp_Object orig_hostname
= Vsystem_name
;
2627 Lisp_Object hostname
;
2629 init_system_name ();
2630 hostname
= Vsystem_name
;
2631 Vsystem_name
= orig_hostname
;
2639 DEFUN ("w32-unload-winsock", Fw32_unload_winsock
, Sw32_unload_winsock
,
2641 doc
: /* Unload the Windows socket library `winsock' if loaded.
2642 This is provided to allow dial-up socket connections to be disconnected
2643 when no longer needed. Returns nil without unloading winsock if any
2644 socket connections still exist. */)
2647 return term_winsock () ? Qt
: Qnil
;
2651 /* Some miscellaneous functions that are Windows specific, but not GUI
2652 specific (ie. are applicable in terminal or batch mode as well). */
2654 DEFUN ("w32-short-file-name", Fw32_short_file_name
, Sw32_short_file_name
, 1, 1, 0,
2655 doc
: /* Return the short file name version (8.3) of the full path of FILENAME.
2656 If FILENAME does not exist, return nil.
2657 All path elements in FILENAME are converted to their short names. */)
2658 (Lisp_Object filename
)
2660 char shortname
[MAX_PATH
];
2662 CHECK_STRING (filename
);
2664 /* first expand it. */
2665 filename
= Fexpand_file_name (filename
, Qnil
);
2667 /* luckily, this returns the short version of each element in the path. */
2668 if (w32_get_short_filename (SDATA (ENCODE_FILE (filename
)),
2669 shortname
, MAX_PATH
) == 0)
2672 dostounix_filename (shortname
);
2674 /* No need to DECODE_FILE, because 8.3 names are pure ASCII. */
2675 return build_string (shortname
);
2679 DEFUN ("w32-long-file-name", Fw32_long_file_name
, Sw32_long_file_name
,
2681 doc
: /* Return the long file name version of the full path of FILENAME.
2682 If FILENAME does not exist, return nil.
2683 All path elements in FILENAME are converted to their long names. */)
2684 (Lisp_Object filename
)
2686 char longname
[ MAX_UTF8_PATH
];
2689 CHECK_STRING (filename
);
2691 if (SBYTES (filename
) == 2
2692 && *(SDATA (filename
) + 1) == ':')
2695 /* first expand it. */
2696 filename
= Fexpand_file_name (filename
, Qnil
);
2698 if (!w32_get_long_filename (SDATA (ENCODE_FILE (filename
)), longname
,
2702 dostounix_filename (longname
);
2704 /* If we were passed only a drive, make sure that a slash is not appended
2705 for consistency with directories. Allow for drive mapping via SUBST
2706 in case expand-file-name is ever changed to expand those. */
2707 if (drive_only
&& longname
[1] == ':' && longname
[2] == '/' && !longname
[3])
2710 return DECODE_FILE (build_unibyte_string (longname
));
2713 DEFUN ("w32-set-process-priority", Fw32_set_process_priority
,
2714 Sw32_set_process_priority
, 2, 2, 0,
2715 doc
: /* Set the priority of PROCESS to PRIORITY.
2716 If PROCESS is nil, the priority of Emacs is changed, otherwise the
2717 priority of the process whose pid is PROCESS is changed.
2718 PRIORITY should be one of the symbols high, normal, or low;
2719 any other symbol will be interpreted as normal.
2721 If successful, the return value is t, otherwise nil. */)
2722 (Lisp_Object process
, Lisp_Object priority
)
2724 HANDLE proc_handle
= GetCurrentProcess ();
2725 DWORD priority_class
= NORMAL_PRIORITY_CLASS
;
2726 Lisp_Object result
= Qnil
;
2728 CHECK_SYMBOL (priority
);
2730 if (!NILP (process
))
2735 CHECK_NUMBER (process
);
2737 /* Allow pid to be an internally generated one, or one obtained
2738 externally. This is necessary because real pids on Windows 95 are
2741 pid
= XINT (process
);
2742 cp
= find_child_pid (pid
);
2744 pid
= cp
->procinfo
.dwProcessId
;
2746 proc_handle
= OpenProcess (PROCESS_SET_INFORMATION
, FALSE
, pid
);
2749 if (EQ (priority
, Qhigh
))
2750 priority_class
= HIGH_PRIORITY_CLASS
;
2751 else if (EQ (priority
, Qlow
))
2752 priority_class
= IDLE_PRIORITY_CLASS
;
2754 if (proc_handle
!= NULL
)
2756 if (SetPriorityClass (proc_handle
, priority_class
))
2758 if (!NILP (process
))
2759 CloseHandle (proc_handle
);
2765 #ifdef HAVE_LANGINFO_CODESET
2766 /* Emulation of nl_langinfo. Used in fns.c:Flocale_info. */
2768 nl_langinfo (nl_item item
)
2770 /* Conversion of Posix item numbers to their Windows equivalents. */
2771 static const LCTYPE w32item
[] = {
2772 LOCALE_IDEFAULTANSICODEPAGE
,
2773 LOCALE_SDAYNAME1
, LOCALE_SDAYNAME2
, LOCALE_SDAYNAME3
,
2774 LOCALE_SDAYNAME4
, LOCALE_SDAYNAME5
, LOCALE_SDAYNAME6
, LOCALE_SDAYNAME7
,
2775 LOCALE_SMONTHNAME1
, LOCALE_SMONTHNAME2
, LOCALE_SMONTHNAME3
,
2776 LOCALE_SMONTHNAME4
, LOCALE_SMONTHNAME5
, LOCALE_SMONTHNAME6
,
2777 LOCALE_SMONTHNAME7
, LOCALE_SMONTHNAME8
, LOCALE_SMONTHNAME9
,
2778 LOCALE_SMONTHNAME10
, LOCALE_SMONTHNAME11
, LOCALE_SMONTHNAME12
2781 static char *nl_langinfo_buf
= NULL
;
2782 static int nl_langinfo_len
= 0;
2784 if (nl_langinfo_len
<= 0)
2785 nl_langinfo_buf
= xmalloc (nl_langinfo_len
= 1);
2787 if (item
< 0 || item
>= _NL_NUM
)
2788 nl_langinfo_buf
[0] = 0;
2791 LCID cloc
= GetThreadLocale ();
2792 int need_len
= GetLocaleInfo (cloc
, w32item
[item
] | LOCALE_USE_CP_ACP
,
2796 nl_langinfo_buf
[0] = 0;
2799 if (item
== CODESET
)
2801 need_len
+= 2; /* for the "cp" prefix */
2802 if (need_len
< 8) /* for the case we call GetACP */
2805 if (nl_langinfo_len
<= need_len
)
2806 nl_langinfo_buf
= xrealloc (nl_langinfo_buf
,
2807 nl_langinfo_len
= need_len
);
2808 if (!GetLocaleInfo (cloc
, w32item
[item
] | LOCALE_USE_CP_ACP
,
2809 nl_langinfo_buf
, nl_langinfo_len
))
2810 nl_langinfo_buf
[0] = 0;
2811 else if (item
== CODESET
)
2813 if (strcmp (nl_langinfo_buf
, "0") == 0 /* CP_ACP */
2814 || strcmp (nl_langinfo_buf
, "1") == 0) /* CP_OEMCP */
2815 sprintf (nl_langinfo_buf
, "cp%u", GetACP ());
2818 memmove (nl_langinfo_buf
+ 2, nl_langinfo_buf
,
2819 strlen (nl_langinfo_buf
) + 1);
2820 nl_langinfo_buf
[0] = 'c';
2821 nl_langinfo_buf
[1] = 'p';
2826 return nl_langinfo_buf
;
2828 #endif /* HAVE_LANGINFO_CODESET */
2830 DEFUN ("w32-get-locale-info", Fw32_get_locale_info
,
2831 Sw32_get_locale_info
, 1, 2, 0,
2832 doc
: /* Return information about the Windows locale LCID.
2833 By default, return a three letter locale code which encodes the default
2834 language as the first two characters, and the country or regional variant
2835 as the third letter. For example, ENU refers to `English (United States)',
2836 while ENC means `English (Canadian)'.
2838 If the optional argument LONGFORM is t, the long form of the locale
2839 name is returned, e.g. `English (United States)' instead; if LONGFORM
2840 is a number, it is interpreted as an LCTYPE constant and the corresponding
2841 locale information is returned.
2843 If LCID (a 16-bit number) is not a valid locale, the result is nil. */)
2844 (Lisp_Object lcid
, Lisp_Object longform
)
2848 char abbrev_name
[32] = { 0 };
2849 char full_name
[256] = { 0 };
2851 CHECK_NUMBER (lcid
);
2853 if (!IsValidLocale (XINT (lcid
), LCID_SUPPORTED
))
2856 if (NILP (longform
))
2858 got_abbrev
= GetLocaleInfo (XINT (lcid
),
2859 LOCALE_SABBREVLANGNAME
| LOCALE_USE_CP_ACP
,
2860 abbrev_name
, sizeof (abbrev_name
));
2862 return build_string (abbrev_name
);
2864 else if (EQ (longform
, Qt
))
2866 got_full
= GetLocaleInfo (XINT (lcid
),
2867 LOCALE_SLANGUAGE
| LOCALE_USE_CP_ACP
,
2868 full_name
, sizeof (full_name
));
2870 return DECODE_SYSTEM (build_string (full_name
));
2872 else if (NUMBERP (longform
))
2874 got_full
= GetLocaleInfo (XINT (lcid
),
2876 full_name
, sizeof (full_name
));
2877 /* GetLocaleInfo's return value includes the terminating null
2878 character, when the returned information is a string, whereas
2879 make_unibyte_string needs the string length without the
2880 terminating null. */
2882 return make_unibyte_string (full_name
, got_full
- 1);
2889 DEFUN ("w32-get-current-locale-id", Fw32_get_current_locale_id
,
2890 Sw32_get_current_locale_id
, 0, 0, 0,
2891 doc
: /* Return Windows locale id for current locale setting.
2892 This is a numerical value; use `w32-get-locale-info' to convert to a
2893 human-readable form. */)
2896 return make_number (GetThreadLocale ());
2900 int_from_hex (char * s
)
2903 static char hex
[] = "0123456789abcdefABCDEF";
2906 while (*s
&& (p
= strchr (hex
, *s
)) != NULL
)
2908 unsigned digit
= p
- hex
;
2911 val
= val
* 16 + digit
;
2917 /* We need to build a global list, since the EnumSystemLocale callback
2918 function isn't given a context pointer. */
2919 Lisp_Object Vw32_valid_locale_ids
;
2921 static BOOL CALLBACK ALIGN_STACK
2922 enum_locale_fn (LPTSTR localeNum
)
2924 DWORD id
= int_from_hex (localeNum
);
2925 Vw32_valid_locale_ids
= Fcons (make_number (id
), Vw32_valid_locale_ids
);
2929 DEFUN ("w32-get-valid-locale-ids", Fw32_get_valid_locale_ids
,
2930 Sw32_get_valid_locale_ids
, 0, 0, 0,
2931 doc
: /* Return list of all valid Windows locale ids.
2932 Each id is a numerical value; use `w32-get-locale-info' to convert to a
2933 human-readable form. */)
2936 Vw32_valid_locale_ids
= Qnil
;
2938 EnumSystemLocales (enum_locale_fn
, LCID_SUPPORTED
);
2940 Vw32_valid_locale_ids
= Fnreverse (Vw32_valid_locale_ids
);
2941 return Vw32_valid_locale_ids
;
2945 DEFUN ("w32-get-default-locale-id", Fw32_get_default_locale_id
, Sw32_get_default_locale_id
, 0, 1, 0,
2946 doc
: /* Return Windows locale id for default locale setting.
2947 By default, the system default locale setting is returned; if the optional
2948 parameter USERP is non-nil, the user default locale setting is returned.
2949 This is a numerical value; use `w32-get-locale-info' to convert to a
2950 human-readable form. */)
2954 return make_number (GetSystemDefaultLCID ());
2955 return make_number (GetUserDefaultLCID ());
2959 DEFUN ("w32-set-current-locale", Fw32_set_current_locale
, Sw32_set_current_locale
, 1, 1, 0,
2960 doc
: /* Make Windows locale LCID be the current locale setting for Emacs.
2961 If successful, the new locale id is returned, otherwise nil. */)
2964 CHECK_NUMBER (lcid
);
2966 if (!IsValidLocale (XINT (lcid
), LCID_SUPPORTED
))
2969 if (!SetThreadLocale (XINT (lcid
)))
2972 /* Need to set input thread locale if present. */
2973 if (dwWindowsThreadId
)
2974 /* Reply is not needed. */
2975 PostThreadMessage (dwWindowsThreadId
, WM_EMACS_SETLOCALE
, XINT (lcid
), 0);
2977 return make_number (GetThreadLocale ());
2981 /* We need to build a global list, since the EnumCodePages callback
2982 function isn't given a context pointer. */
2983 Lisp_Object Vw32_valid_codepages
;
2985 static BOOL CALLBACK ALIGN_STACK
2986 enum_codepage_fn (LPTSTR codepageNum
)
2988 DWORD id
= atoi (codepageNum
);
2989 Vw32_valid_codepages
= Fcons (make_number (id
), Vw32_valid_codepages
);
2993 DEFUN ("w32-get-valid-codepages", Fw32_get_valid_codepages
,
2994 Sw32_get_valid_codepages
, 0, 0, 0,
2995 doc
: /* Return list of all valid Windows codepages. */)
2998 Vw32_valid_codepages
= Qnil
;
3000 EnumSystemCodePages (enum_codepage_fn
, CP_SUPPORTED
);
3002 Vw32_valid_codepages
= Fnreverse (Vw32_valid_codepages
);
3003 return Vw32_valid_codepages
;
3007 DEFUN ("w32-get-console-codepage", Fw32_get_console_codepage
,
3008 Sw32_get_console_codepage
, 0, 0, 0,
3009 doc
: /* Return current Windows codepage for console input. */)
3012 return make_number (GetConsoleCP ());
3016 DEFUN ("w32-set-console-codepage", Fw32_set_console_codepage
,
3017 Sw32_set_console_codepage
, 1, 1, 0,
3018 doc
: /* Make Windows codepage CP be the codepage for Emacs tty keyboard input.
3019 This codepage setting affects keyboard input in tty mode.
3020 If successful, the new CP is returned, otherwise nil. */)
3025 if (!IsValidCodePage (XINT (cp
)))
3028 if (!SetConsoleCP (XINT (cp
)))
3031 return make_number (GetConsoleCP ());
3035 DEFUN ("w32-get-console-output-codepage", Fw32_get_console_output_codepage
,
3036 Sw32_get_console_output_codepage
, 0, 0, 0,
3037 doc
: /* Return current Windows codepage for console output. */)
3040 return make_number (GetConsoleOutputCP ());
3044 DEFUN ("w32-set-console-output-codepage", Fw32_set_console_output_codepage
,
3045 Sw32_set_console_output_codepage
, 1, 1, 0,
3046 doc
: /* Make Windows codepage CP be the codepage for Emacs console output.
3047 This codepage setting affects display in tty mode.
3048 If successful, the new CP is returned, otherwise nil. */)
3053 if (!IsValidCodePage (XINT (cp
)))
3056 if (!SetConsoleOutputCP (XINT (cp
)))
3059 return make_number (GetConsoleOutputCP ());
3063 DEFUN ("w32-get-codepage-charset", Fw32_get_codepage_charset
,
3064 Sw32_get_codepage_charset
, 1, 1, 0,
3065 doc
: /* Return charset ID corresponding to codepage CP.
3066 Returns nil if the codepage is not valid. */)
3073 if (!IsValidCodePage (XINT (cp
)))
3076 if (TranslateCharsetInfo ((DWORD
*) XINT (cp
), &info
, TCI_SRCCODEPAGE
))
3077 return make_number (info
.ciCharset
);
3083 DEFUN ("w32-get-valid-keyboard-layouts", Fw32_get_valid_keyboard_layouts
,
3084 Sw32_get_valid_keyboard_layouts
, 0, 0, 0,
3085 doc
: /* Return list of Windows keyboard languages and layouts.
3086 The return value is a list of pairs of language id and layout id. */)
3089 int num_layouts
= GetKeyboardLayoutList (0, NULL
);
3090 HKL
* layouts
= (HKL
*) alloca (num_layouts
* sizeof (HKL
));
3091 Lisp_Object obj
= Qnil
;
3093 if (GetKeyboardLayoutList (num_layouts
, layouts
) == num_layouts
)
3095 while (--num_layouts
>= 0)
3097 HKL kl
= layouts
[num_layouts
];
3099 obj
= Fcons (Fcons (make_number (LOWORD (kl
)),
3100 make_number (HIWORD (kl
))),
3109 DEFUN ("w32-get-keyboard-layout", Fw32_get_keyboard_layout
,
3110 Sw32_get_keyboard_layout
, 0, 0, 0,
3111 doc
: /* Return current Windows keyboard language and layout.
3112 The return value is the cons of the language id and the layout id. */)
3115 HKL kl
= GetKeyboardLayout (dwWindowsThreadId
);
3117 return Fcons (make_number (LOWORD (kl
)),
3118 make_number (HIWORD (kl
)));
3122 DEFUN ("w32-set-keyboard-layout", Fw32_set_keyboard_layout
,
3123 Sw32_set_keyboard_layout
, 1, 1, 0,
3124 doc
: /* Make LAYOUT be the current keyboard layout for Emacs.
3125 The keyboard layout setting affects interpretation of keyboard input.
3126 If successful, the new layout id is returned, otherwise nil. */)
3127 (Lisp_Object layout
)
3131 CHECK_CONS (layout
);
3132 CHECK_NUMBER_CAR (layout
);
3133 CHECK_NUMBER_CDR (layout
);
3135 kl
= (HKL
) ((XINT (XCAR (layout
)) & 0xffff)
3136 | (XINT (XCDR (layout
)) << 16));
3138 /* Synchronize layout with input thread. */
3139 if (dwWindowsThreadId
)
3141 if (PostThreadMessage (dwWindowsThreadId
, WM_EMACS_SETKEYBOARDLAYOUT
,
3145 GetMessage (&msg
, NULL
, WM_EMACS_DONE
, WM_EMACS_DONE
);
3147 if (msg
.wParam
== 0)
3151 else if (!ActivateKeyboardLayout (kl
, 0))
3154 return Fw32_get_keyboard_layout ();
3157 /* Two variables to interface between get_lcid and the EnumLocales
3158 callback function below. */
3159 #ifndef LOCALE_NAME_MAX_LENGTH
3160 # define LOCALE_NAME_MAX_LENGTH 85
3162 static LCID found_lcid
;
3163 static char lname
[3 * LOCALE_NAME_MAX_LENGTH
+ 1 + 1];
3165 /* Callback function for EnumLocales. */
3166 static BOOL CALLBACK
3167 get_lcid_callback (LPTSTR locale_num_str
)
3170 char locval
[2 * LOCALE_NAME_MAX_LENGTH
+ 1 + 1];
3171 LCID try_lcid
= strtoul (locale_num_str
, &endp
, 16);
3173 if (GetLocaleInfo (try_lcid
, LOCALE_SABBREVLANGNAME
,
3174 locval
, LOCALE_NAME_MAX_LENGTH
))
3176 /* This is for when they only specify the language, as in "ENU". */
3177 if (stricmp (locval
, lname
) == 0)
3179 found_lcid
= try_lcid
;
3182 strcat (locval
, "_");
3183 if (GetLocaleInfo (try_lcid
, LOCALE_SABBREVCTRYNAME
,
3184 locval
+ strlen (locval
), LOCALE_NAME_MAX_LENGTH
))
3186 size_t locval_len
= strlen (locval
);
3188 if (strnicmp (locval
, lname
, locval_len
) == 0
3189 && (lname
[locval_len
] == '.'
3190 || lname
[locval_len
] == '\0'))
3192 found_lcid
= try_lcid
;
3200 /* Return the Locale ID (LCID) number given the locale's name, a
3201 string, in LOCALE_NAME. This works by enumerating all the locales
3202 supported by the system, until we find one whose name matches
3205 get_lcid (const char *locale_name
)
3207 /* A simple cache. */
3208 static LCID last_lcid
;
3209 static char last_locale
[1000];
3211 /* The code below is not thread-safe, as it uses static variables.
3212 But this function is called only from the Lisp thread. */
3213 if (last_lcid
> 0 && strcmp (locale_name
, last_locale
) == 0)
3216 strncpy (lname
, locale_name
, sizeof (lname
) - 1);
3217 lname
[sizeof (lname
) - 1] = '\0';
3219 EnumSystemLocales (get_lcid_callback
, LCID_SUPPORTED
);
3222 last_lcid
= found_lcid
;
3223 strcpy (last_locale
, locale_name
);
3228 #ifndef _NSLCMPERROR
3229 # define _NSLCMPERROR INT_MAX
3231 #ifndef LINGUISTIC_IGNORECASE
3232 # define LINGUISTIC_IGNORECASE 0x00000010
3236 w32_compare_strings (const char *s1
, const char *s2
, char *locname
,
3239 LCID lcid
= GetThreadLocale ();
3240 wchar_t *string1_w
, *string2_w
;
3242 extern BOOL g_b_init_compare_string_w
;
3243 static int (WINAPI
*pCompareStringW
)(LCID
, DWORD
, LPCWSTR
, int, LPCWSTR
, int);
3248 /* The LCID machinery doesn't seem to support the "C" locale, so we
3249 need to do that by hand. */
3251 && ((locname
[0] == 'C' && (locname
[1] == '\0' || locname
[1] == '.'))
3252 || strcmp (locname
, "POSIX") == 0))
3253 return (ignore_case
? stricmp (s1
, s2
) : strcmp (s1
, s2
));
3255 if (!g_b_init_compare_string_w
)
3257 if (os_subtype
== OS_9X
)
3259 pCompareStringW
= GetProcAddress (LoadLibrary ("Unicows.dll"),
3261 if (!pCompareStringW
)
3264 /* This return value is compatible with wcscoll and
3265 other MS CRT functions. */
3266 return _NSLCMPERROR
;
3270 pCompareStringW
= CompareStringW
;
3272 g_b_init_compare_string_w
= 1;
3275 needed
= pMultiByteToWideChar (CP_UTF8
, MB_ERR_INVALID_CHARS
, s1
, -1, NULL
, 0);
3278 SAFE_NALLOCA (string1_w
, 1, needed
+ 1);
3279 pMultiByteToWideChar (CP_UTF8
, MB_ERR_INVALID_CHARS
, s1
, -1,
3285 return _NSLCMPERROR
;
3288 needed
= pMultiByteToWideChar (CP_UTF8
, MB_ERR_INVALID_CHARS
, s2
, -1, NULL
, 0);
3291 SAFE_NALLOCA (string2_w
, 1, needed
+ 1);
3292 pMultiByteToWideChar (CP_UTF8
, MB_ERR_INVALID_CHARS
, s2
, -1,
3299 return _NSLCMPERROR
;
3304 /* Convert locale name string to LCID. We don't want to use
3305 LocaleNameToLCID because (a) it is only available since
3306 Vista, and (b) it doesn't accept locale names returned by
3307 'setlocale' and 'GetLocaleInfo'. */
3308 LCID new_lcid
= get_lcid (locname
);
3313 error ("Invalid locale %s: Invalid argument", locname
);
3318 /* NORM_IGNORECASE ignores any tertiary distinction, not just
3319 case variants. LINGUISTIC_IGNORECASE is more selective, and
3320 is sensitive to the locale's language, but it is not
3321 available before Vista. */
3322 if (w32_major_version
>= 6)
3323 flags
|= LINGUISTIC_IGNORECASE
;
3325 flags
|= NORM_IGNORECASE
;
3327 /* This approximates what glibc collation functions do when the
3328 locale's codeset is UTF-8. */
3329 if (!NILP (Vw32_collate_ignore_punctuation
))
3330 flags
|= NORM_IGNORESYMBOLS
;
3331 val
= pCompareStringW (lcid
, flags
, string1_w
, -1, string2_w
, -1);
3336 return _NSLCMPERROR
;
3343 syms_of_ntproc (void)
3345 DEFSYM (Qhigh
, "high");
3346 DEFSYM (Qlow
, "low");
3348 defsubr (&Sw32_has_winsock
);
3349 defsubr (&Sw32_unload_winsock
);
3351 defsubr (&Sw32_short_file_name
);
3352 defsubr (&Sw32_long_file_name
);
3353 defsubr (&Sw32_set_process_priority
);
3354 defsubr (&Sw32_get_locale_info
);
3355 defsubr (&Sw32_get_current_locale_id
);
3356 defsubr (&Sw32_get_default_locale_id
);
3357 defsubr (&Sw32_get_valid_locale_ids
);
3358 defsubr (&Sw32_set_current_locale
);
3360 defsubr (&Sw32_get_console_codepage
);
3361 defsubr (&Sw32_set_console_codepage
);
3362 defsubr (&Sw32_get_console_output_codepage
);
3363 defsubr (&Sw32_set_console_output_codepage
);
3364 defsubr (&Sw32_get_valid_codepages
);
3365 defsubr (&Sw32_get_codepage_charset
);
3367 defsubr (&Sw32_get_valid_keyboard_layouts
);
3368 defsubr (&Sw32_get_keyboard_layout
);
3369 defsubr (&Sw32_set_keyboard_layout
);
3371 DEFVAR_LISP ("w32-quote-process-args", Vw32_quote_process_args
,
3372 doc
: /* Non-nil enables quoting of process arguments to ensure correct parsing.
3373 Because Windows does not directly pass argv arrays to child processes,
3374 programs have to reconstruct the argv array by parsing the command
3375 line string. For an argument to contain a space, it must be enclosed
3376 in double quotes or it will be parsed as multiple arguments.
3378 If the value is a character, that character will be used to escape any
3379 quote characters that appear, otherwise a suitable escape character
3380 will be chosen based on the type of the program. */);
3381 Vw32_quote_process_args
= Qt
;
3383 DEFVAR_LISP ("w32-start-process-show-window",
3384 Vw32_start_process_show_window
,
3385 doc
: /* When nil, new child processes hide their windows.
3386 When non-nil, they show their window in the method of their choice.
3387 This variable doesn't affect GUI applications, which will never be hidden. */);
3388 Vw32_start_process_show_window
= Qnil
;
3390 DEFVAR_LISP ("w32-start-process-share-console",
3391 Vw32_start_process_share_console
,
3392 doc
: /* When nil, new child processes are given a new console.
3393 When non-nil, they share the Emacs console; this has the limitation of
3394 allowing only one DOS subprocess to run at a time (whether started directly
3395 or indirectly by Emacs), and preventing Emacs from cleanly terminating the
3396 subprocess group, but may allow Emacs to interrupt a subprocess that doesn't
3397 otherwise respond to interrupts from Emacs. */);
3398 Vw32_start_process_share_console
= Qnil
;
3400 DEFVAR_LISP ("w32-start-process-inherit-error-mode",
3401 Vw32_start_process_inherit_error_mode
,
3402 doc
: /* When nil, new child processes revert to the default error mode.
3403 When non-nil, they inherit their error mode setting from Emacs, which stops
3404 them blocking when trying to access unmounted drives etc. */);
3405 Vw32_start_process_inherit_error_mode
= Qt
;
3407 DEFVAR_INT ("w32-pipe-read-delay", w32_pipe_read_delay
,
3408 doc
: /* Forced delay before reading subprocess output.
3409 This is done to improve the buffering of subprocess output, by
3410 avoiding the inefficiency of frequently reading small amounts of data.
3412 If positive, the value is the number of milliseconds to sleep before
3413 reading the subprocess output. If negative, the magnitude is the number
3414 of time slices to wait (effectively boosting the priority of the child
3415 process temporarily). A value of zero disables waiting entirely. */);
3416 w32_pipe_read_delay
= 50;
3418 DEFVAR_LISP ("w32-downcase-file-names", Vw32_downcase_file_names
,
3419 doc
: /* Non-nil means convert all-upper case file names to lower case.
3420 This applies when performing completions and file name expansion.
3421 Note that the value of this setting also affects remote file names,
3422 so you probably don't want to set to non-nil if you use case-sensitive
3423 filesystems via ange-ftp. */);
3424 Vw32_downcase_file_names
= Qnil
;
3427 DEFVAR_LISP ("w32-generate-fake-inodes", Vw32_generate_fake_inodes
,
3428 doc
: /* Non-nil means attempt to fake realistic inode values.
3429 This works by hashing the truename of files, and should detect
3430 aliasing between long and short (8.3 DOS) names, but can have
3431 false positives because of hash collisions. Note that determining
3432 the truename of a file can be slow. */);
3433 Vw32_generate_fake_inodes
= Qnil
;
3436 DEFVAR_LISP ("w32-get-true-file-attributes", Vw32_get_true_file_attributes
,
3437 doc
: /* Non-nil means determine accurate file attributes in `file-attributes'.
3438 This option controls whether to issue additional system calls to determine
3439 accurate link counts, file type, and ownership information. It is more
3440 useful for files on NTFS volumes, where hard links and file security are
3441 supported, than on volumes of the FAT family.
3443 Without these system calls, link count will always be reported as 1 and file
3444 ownership will be attributed to the current user.
3445 The default value `local' means only issue these system calls for files
3446 on local fixed drives. A value of nil means never issue them.
3447 Any other non-nil value means do this even on remote and removable drives
3448 where the performance impact may be noticeable even on modern hardware. */);
3449 Vw32_get_true_file_attributes
= Qlocal
;
3451 DEFVAR_LISP ("w32-collate-ignore-punctuation",
3452 Vw32_collate_ignore_punctuation
,
3453 doc
: /* Non-nil causes string collation functions ignore punctuation on MS-Windows.
3454 On Posix platforms, `string-collate-lessp' and `string-collate-equalp'
3455 ignore punctuation characters when they compare strings, if the
3456 locale's codeset is UTF-8, as in \"en_US.UTF-8\". Binding this option
3457 to a non-nil value will achieve a similar effect on MS-Windows, where
3458 locales with UTF-8 codeset are not supported.
3460 Note that setting this to non-nil will also ignore blanks and symbols
3461 in the strings. So do NOT use this option when comparing file names
3462 for equality, only when you need to sort them. */);
3463 Vw32_collate_ignore_punctuation
= Qnil
;
3465 staticpro (&Vw32_valid_locale_ids
);
3466 staticpro (&Vw32_valid_codepages
);
3468 /* end of w32proc.c */