1 /* Process support for GNU Emacs on the Microsoft Windows API.
2 Copyright (C) 1992, 1995, 1999-2012 Free Software Foundation, Inc.
4 This file is part of GNU Emacs.
6 GNU Emacs is free software: you can redistribute it and/or modify
7 it under the terms of the GNU General Public License as published by
8 the Free Software Foundation, either version 3 of the License, or
9 (at your option) any later version.
11 GNU Emacs is distributed in the hope that it will be useful,
12 but WITHOUT ANY WARRANTY; without even the implied warranty of
13 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14 GNU General Public License for more details.
16 You should have received a copy of the GNU General Public License
17 along with GNU Emacs. If not, see <http://www.gnu.org/licenses/>. */
20 Drew Bliss Oct 14, 1993
21 Adapted from alarm.c by Tim Fleehart
32 /* must include CRT headers *before* config.h */
43 /* This definition is missing from mingw32 headers. */
44 extern BOOL WINAPI
IsValidLocale (LCID
, DWORD
);
47 #ifdef HAVE_LANGINFO_CODESET
58 #include "syssignal.h"
60 #include "dispextern.h" /* for xstrcasecmp */
63 #define RVA_TO_PTR(var,section,filedata) \
64 ((void *)((section)->PointerToRawData \
65 + ((DWORD)(var) - (section)->VirtualAddress) \
66 + (filedata).file_base))
68 Lisp_Object Qhigh
, Qlow
;
72 _DebPrint (const char *fmt
, ...)
78 vsprintf (buf
, fmt
, args
);
80 OutputDebugString (buf
);
84 typedef void (_CALLBACK_
*signal_handler
) (int);
86 /* Signal handlers...SIG_DFL == 0 so this is initialized correctly. */
87 static signal_handler sig_handlers
[NSIG
];
89 /* Fake signal implementation to record the SIGCHLD handler. */
91 sys_signal (int sig
, signal_handler handler
)
100 old
= sig_handlers
[sig
];
101 sig_handlers
[sig
] = handler
;
105 /* Emulate sigaction. */
107 sigaction (int sig
, const struct sigaction
*act
, struct sigaction
*oact
)
116 old
= sig_handlers
[sig
];
118 sig_handlers
[sig
] = act
->sa_handler
;
121 oact
->sa_handler
= old
;
123 oact
->sa_mask
= empty_mask
;
128 /* Defined in <process.h> which conflicts with the local copy */
131 /* Child process management list. */
132 int child_proc_count
= 0;
133 child_process child_procs
[ MAX_CHILDREN
];
134 child_process
*dead_child
= NULL
;
136 static DWORD WINAPI
reader_thread (void *arg
);
138 /* Find an unused process slot. */
145 for (cp
= child_procs
+ (child_proc_count
-1); cp
>= child_procs
; cp
--)
146 if (!CHILD_ACTIVE (cp
))
148 if (child_proc_count
== MAX_CHILDREN
)
150 cp
= &child_procs
[child_proc_count
++];
153 memset (cp
, 0, sizeof (*cp
));
156 cp
->procinfo
.hProcess
= NULL
;
157 cp
->status
= STATUS_READ_ERROR
;
159 /* use manual reset event so that select() will function properly */
160 cp
->char_avail
= CreateEvent (NULL
, TRUE
, FALSE
, NULL
);
163 cp
->char_consumed
= CreateEvent (NULL
, FALSE
, FALSE
, NULL
);
164 if (cp
->char_consumed
)
166 /* The 0x00010000 flag is STACK_SIZE_PARAM_IS_A_RESERVATION.
167 It means that the 64K stack we are requesting in the 2nd
168 argument is how much memory should be reserved for the
169 stack. If we don't use this flag, the memory requested
170 by the 2nd argument is the amount actually _committed_,
171 but Windows reserves 8MB of memory for each thread's
172 stack. (The 8MB figure comes from the -stack
173 command-line argument we pass to the linker when building
174 Emacs, but that's because we need a large stack for
175 Emacs's main thread.) Since we request 2GB of reserved
176 memory at startup (see w32heap.c), which is close to the
177 maximum memory available for a 32-bit process on Windows,
178 the 8MB reservation for each thread causes failures in
179 starting subprocesses, because we create a thread running
180 reader_thread for each subprocess. As 8MB of stack is
181 way too much for reader_thread, forcing Windows to
182 reserve less wins the day. */
183 cp
->thrd
= CreateThread (NULL
, 64 * 1024, reader_thread
, cp
,
194 delete_child (child_process
*cp
)
198 /* Should not be deleting a child that is still needed. */
199 for (i
= 0; i
< MAXDESC
; i
++)
200 if (fd_info
[i
].cp
== cp
)
203 if (!CHILD_ACTIVE (cp
))
206 /* reap thread if necessary */
211 if (GetExitCodeThread (cp
->thrd
, &rc
) && rc
== STILL_ACTIVE
)
213 /* let the thread exit cleanly if possible */
214 cp
->status
= STATUS_READ_ERROR
;
215 SetEvent (cp
->char_consumed
);
217 /* We used to forcibly terminate the thread here, but it
218 is normally unnecessary, and in abnormal cases, the worst that
219 will happen is we have an extra idle thread hanging around
220 waiting for the zombie process. */
221 if (WaitForSingleObject (cp
->thrd
, 1000) != WAIT_OBJECT_0
)
223 DebPrint (("delete_child.WaitForSingleObject (thread) failed "
224 "with %lu for fd %ld\n", GetLastError (), cp
->fd
));
225 TerminateThread (cp
->thrd
, 0);
229 CloseHandle (cp
->thrd
);
234 CloseHandle (cp
->char_avail
);
235 cp
->char_avail
= NULL
;
237 if (cp
->char_consumed
)
239 CloseHandle (cp
->char_consumed
);
240 cp
->char_consumed
= NULL
;
243 /* update child_proc_count (highest numbered slot in use plus one) */
244 if (cp
== child_procs
+ child_proc_count
- 1)
246 for (i
= child_proc_count
-1; i
>= 0; i
--)
247 if (CHILD_ACTIVE (&child_procs
[i
]))
249 child_proc_count
= i
+ 1;
254 child_proc_count
= 0;
257 /* Find a child by pid. */
258 static child_process
*
259 find_child_pid (DWORD pid
)
263 for (cp
= child_procs
+ (child_proc_count
-1); cp
>= child_procs
; cp
--)
264 if (CHILD_ACTIVE (cp
) && pid
== cp
->pid
)
270 /* Thread proc for child process and socket reader threads. Each thread
271 is normally blocked until woken by select() to check for input by
272 reading one char. When the read completes, char_avail is signaled
273 to wake up the select emulator and the thread blocks itself again. */
275 reader_thread (void *arg
)
280 cp
= (child_process
*)arg
;
282 /* We have to wait for the go-ahead before we can start */
284 || WaitForSingleObject (cp
->char_consumed
, INFINITE
) != WAIT_OBJECT_0
292 if (fd_info
[cp
->fd
].flags
& FILE_LISTEN
)
293 rc
= _sys_wait_accept (cp
->fd
);
295 rc
= _sys_read_ahead (cp
->fd
);
297 /* The name char_avail is a misnomer - it really just means the
298 read-ahead has completed, whether successfully or not. */
299 if (!SetEvent (cp
->char_avail
))
301 DebPrint (("reader_thread.SetEvent failed with %lu for fd %ld\n",
302 GetLastError (), cp
->fd
));
306 if (rc
== STATUS_READ_ERROR
)
309 /* If the read died, the child has died so let the thread die */
310 if (rc
== STATUS_READ_FAILED
)
313 /* Wait until our input is acknowledged before reading again */
314 if (WaitForSingleObject (cp
->char_consumed
, INFINITE
) != WAIT_OBJECT_0
)
316 DebPrint (("reader_thread.WaitForSingleObject failed with "
317 "%lu for fd %ld\n", GetLastError (), cp
->fd
));
324 /* To avoid Emacs changing directory, we just record here the directory
325 the new process should start in. This is set just before calling
326 sys_spawnve, and is not generally valid at any other time. */
327 static char * process_dir
;
330 create_child (char *exe
, char *cmdline
, char *env
, int is_gui_app
,
331 int * pPid
, child_process
*cp
)
334 SECURITY_ATTRIBUTES sec_attrs
;
336 SECURITY_DESCRIPTOR sec_desc
;
339 char dir
[ MAXPATHLEN
];
341 if (cp
== NULL
) emacs_abort ();
343 memset (&start
, 0, sizeof (start
));
344 start
.cb
= sizeof (start
);
347 if (NILP (Vw32_start_process_show_window
) && !is_gui_app
)
348 start
.dwFlags
= STARTF_USESTDHANDLES
| STARTF_USESHOWWINDOW
;
350 start
.dwFlags
= STARTF_USESTDHANDLES
;
351 start
.wShowWindow
= SW_HIDE
;
353 start
.hStdInput
= GetStdHandle (STD_INPUT_HANDLE
);
354 start
.hStdOutput
= GetStdHandle (STD_OUTPUT_HANDLE
);
355 start
.hStdError
= GetStdHandle (STD_ERROR_HANDLE
);
356 #endif /* HAVE_NTGUI */
359 /* Explicitly specify no security */
360 if (!InitializeSecurityDescriptor (&sec_desc
, SECURITY_DESCRIPTOR_REVISION
))
362 if (!SetSecurityDescriptorDacl (&sec_desc
, TRUE
, NULL
, FALSE
))
365 sec_attrs
.nLength
= sizeof (sec_attrs
);
366 sec_attrs
.lpSecurityDescriptor
= NULL
/* &sec_desc */;
367 sec_attrs
.bInheritHandle
= FALSE
;
369 strcpy (dir
, process_dir
);
370 unixtodos_filename (dir
);
372 flags
= (!NILP (Vw32_start_process_share_console
)
373 ? CREATE_NEW_PROCESS_GROUP
374 : CREATE_NEW_CONSOLE
);
375 if (NILP (Vw32_start_process_inherit_error_mode
))
376 flags
|= CREATE_DEFAULT_ERROR_MODE
;
377 if (!CreateProcess (exe
, cmdline
, &sec_attrs
, NULL
, TRUE
,
378 flags
, env
, dir
, &start
, &cp
->procinfo
))
381 cp
->pid
= (int) cp
->procinfo
.dwProcessId
;
383 /* Hack for Windows 95, which assigns large (ie negative) pids */
387 /* pid must fit in a Lisp_Int */
388 cp
->pid
= cp
->pid
& INTMASK
;
395 DebPrint (("create_child.CreateProcess failed: %ld\n", GetLastError ()););
399 /* create_child doesn't know what emacs' file handle will be for waiting
400 on output from the child, so we need to make this additional call
401 to register the handle with the process
402 This way the select emulator knows how to match file handles with
403 entries in child_procs. */
405 register_child (int pid
, int fd
)
409 cp
= find_child_pid (pid
);
412 DebPrint (("register_child unable to find pid %lu\n", pid
));
417 DebPrint (("register_child registered fd %d with pid %lu\n", fd
, pid
));
422 /* thread is initially blocked until select is called; set status so
423 that select will release thread */
424 cp
->status
= STATUS_READ_ACKNOWLEDGED
;
426 /* attach child_process to fd_info */
427 if (fd_info
[fd
].cp
!= NULL
)
429 DebPrint (("register_child: fd_info[%d] apparently in use!\n", fd
));
436 /* When a process dies its pipe will break so the reader thread will
437 signal failure to the select emulator.
438 The select emulator then calls this routine to clean up.
439 Since the thread signaled failure we can assume it is exiting. */
441 reap_subprocess (child_process
*cp
)
443 if (cp
->procinfo
.hProcess
)
445 /* Reap the process */
447 /* Process should have already died before we are called. */
448 if (WaitForSingleObject (cp
->procinfo
.hProcess
, 0) != WAIT_OBJECT_0
)
449 DebPrint (("reap_subprocess: child fpr fd %d has not died yet!", cp
->fd
));
451 CloseHandle (cp
->procinfo
.hProcess
);
452 cp
->procinfo
.hProcess
= NULL
;
453 CloseHandle (cp
->procinfo
.hThread
);
454 cp
->procinfo
.hThread
= NULL
;
457 /* For asynchronous children, the child_proc resources will be freed
458 when the last pipe read descriptor is closed; for synchronous
459 children, we must explicitly free the resources now because
460 register_child has not been called. */
465 /* Wait for any of our existing child processes to die
466 When it does, close its handle
467 Return the pid and fill in the status if non-NULL. */
470 sys_wait (int *status
)
472 DWORD active
, retval
;
475 child_process
*cp
, *cps
[MAX_CHILDREN
];
476 HANDLE wait_hnd
[MAX_CHILDREN
];
479 if (dead_child
!= NULL
)
481 /* We want to wait for a specific child */
482 wait_hnd
[nh
] = dead_child
->procinfo
.hProcess
;
483 cps
[nh
] = dead_child
;
484 if (!wait_hnd
[nh
]) emacs_abort ();
491 for (cp
= child_procs
+ (child_proc_count
-1); cp
>= child_procs
; cp
--)
492 /* some child_procs might be sockets; ignore them */
493 if (CHILD_ACTIVE (cp
) && cp
->procinfo
.hProcess
494 && (cp
->fd
< 0 || (fd_info
[cp
->fd
].flags
& FILE_AT_EOF
) != 0))
496 wait_hnd
[nh
] = cp
->procinfo
.hProcess
;
504 /* Nothing to wait on, so fail */
511 /* Check for quit about once a second. */
513 active
= WaitForMultipleObjects (nh
, wait_hnd
, FALSE
, 1000);
514 } while (active
== WAIT_TIMEOUT
);
516 if (active
== WAIT_FAILED
)
521 else if (active
>= WAIT_OBJECT_0
522 && active
< WAIT_OBJECT_0
+MAXIMUM_WAIT_OBJECTS
)
524 active
-= WAIT_OBJECT_0
;
526 else if (active
>= WAIT_ABANDONED_0
527 && active
< WAIT_ABANDONED_0
+MAXIMUM_WAIT_OBJECTS
)
529 active
-= WAIT_ABANDONED_0
;
535 if (!GetExitCodeProcess (wait_hnd
[active
], &retval
))
537 DebPrint (("Wait.GetExitCodeProcess failed with %lu\n",
541 if (retval
== STILL_ACTIVE
)
543 /* Should never happen */
544 DebPrint (("Wait.WaitForMultipleObjects returned an active process\n"));
549 /* Massage the exit code from the process to match the format expected
550 by the WIFSTOPPED et al macros in syswait.h. Only WIFSIGNALED and
551 WIFEXITED are supported; WIFSTOPPED doesn't make sense under NT. */
553 if (retval
== STATUS_CONTROL_C_EXIT
)
561 DebPrint (("Wait signaled with process pid %d\n", cp
->pid
));
568 else if (synch_process_alive
)
570 synch_process_alive
= 0;
572 /* Report the status of the synchronous process. */
573 if (WIFEXITED (retval
))
574 synch_process_retcode
= WEXITSTATUS (retval
);
575 else if (WIFSIGNALED (retval
))
577 int code
= WTERMSIG (retval
);
580 synchronize_system_messages_locale ();
581 signame
= strsignal (code
);
586 synch_process_death
= signame
;
589 reap_subprocess (cp
);
592 reap_subprocess (cp
);
597 /* Old versions of w32api headers don't have separate 32-bit and
598 64-bit defines, but the one they have matches the 32-bit variety. */
599 #ifndef IMAGE_NT_OPTIONAL_HDR32_MAGIC
600 # define IMAGE_NT_OPTIONAL_HDR32_MAGIC IMAGE_NT_OPTIONAL_HDR_MAGIC
601 # define IMAGE_OPTIONAL_HEADER32 IMAGE_OPTIONAL_HEADER
605 w32_executable_type (char * filename
,
610 file_data executable
;
613 /* Default values in case we can't tell for sure. */
615 *is_cygnus_app
= FALSE
;
618 if (!open_input_file (&executable
, filename
))
621 p
= strrchr (filename
, '.');
623 /* We can only identify DOS .com programs from the extension. */
624 if (p
&& xstrcasecmp (p
, ".com") == 0)
626 else if (p
&& (xstrcasecmp (p
, ".bat") == 0
627 || xstrcasecmp (p
, ".cmd") == 0))
629 /* A DOS shell script - it appears that CreateProcess is happy to
630 accept this (somewhat surprisingly); presumably it looks at
631 COMSPEC to determine what executable to actually invoke.
632 Therefore, we have to do the same here as well. */
633 /* Actually, I think it uses the program association for that
634 extension, which is defined in the registry. */
635 p
= egetenv ("COMSPEC");
637 w32_executable_type (p
, is_dos_app
, is_cygnus_app
, is_gui_app
);
641 /* Look for DOS .exe signature - if found, we must also check that
642 it isn't really a 16- or 32-bit Windows exe, since both formats
643 start with a DOS program stub. Note that 16-bit Windows
644 executables use the OS/2 1.x format. */
646 IMAGE_DOS_HEADER
* dos_header
;
647 IMAGE_NT_HEADERS
* nt_header
;
649 dos_header
= (PIMAGE_DOS_HEADER
) executable
.file_base
;
650 if (dos_header
->e_magic
!= IMAGE_DOS_SIGNATURE
)
653 nt_header
= (PIMAGE_NT_HEADERS
) ((char *) dos_header
+ dos_header
->e_lfanew
);
655 if ((char *) nt_header
> (char *) dos_header
+ executable
.size
)
657 /* Some dos headers (pkunzip) have bogus e_lfanew fields. */
660 else if (nt_header
->Signature
!= IMAGE_NT_SIGNATURE
661 && LOWORD (nt_header
->Signature
) != IMAGE_OS2_SIGNATURE
)
665 else if (nt_header
->Signature
== IMAGE_NT_SIGNATURE
)
667 IMAGE_DATA_DIRECTORY
*data_dir
= NULL
;
668 if (nt_header
->OptionalHeader
.Magic
== IMAGE_NT_OPTIONAL_HDR32_MAGIC
)
670 /* Ensure we are using the 32 bit structure. */
671 IMAGE_OPTIONAL_HEADER32
*opt
672 = (IMAGE_OPTIONAL_HEADER32
*) &(nt_header
->OptionalHeader
);
673 data_dir
= opt
->DataDirectory
;
674 *is_gui_app
= (opt
->Subsystem
== IMAGE_SUBSYSTEM_WINDOWS_GUI
);
676 /* MingW 3.12 has the required 64 bit structs, but in case older
677 versions don't, only check 64 bit exes if we know how. */
678 #ifdef IMAGE_NT_OPTIONAL_HDR64_MAGIC
679 else if (nt_header
->OptionalHeader
.Magic
680 == IMAGE_NT_OPTIONAL_HDR64_MAGIC
)
682 IMAGE_OPTIONAL_HEADER64
*opt
683 = (IMAGE_OPTIONAL_HEADER64
*) &(nt_header
->OptionalHeader
);
684 data_dir
= opt
->DataDirectory
;
685 *is_gui_app
= (opt
->Subsystem
== IMAGE_SUBSYSTEM_WINDOWS_GUI
);
690 /* Look for cygwin.dll in DLL import list. */
691 IMAGE_DATA_DIRECTORY import_dir
=
692 data_dir
[IMAGE_DIRECTORY_ENTRY_IMPORT
];
693 IMAGE_IMPORT_DESCRIPTOR
* imports
;
694 IMAGE_SECTION_HEADER
* section
;
696 section
= rva_to_section (import_dir
.VirtualAddress
, nt_header
);
697 imports
= RVA_TO_PTR (import_dir
.VirtualAddress
, section
,
700 for ( ; imports
->Name
; imports
++)
702 char * dllname
= RVA_TO_PTR (imports
->Name
, section
,
705 /* The exact name of the cygwin dll has changed with
706 various releases, but hopefully this will be reasonably
708 if (strncmp (dllname
, "cygwin", 6) == 0)
710 *is_cygnus_app
= TRUE
;
719 close_file_data (&executable
);
723 compare_env (const void *strp1
, const void *strp2
)
725 const char *str1
= *(const char **)strp1
, *str2
= *(const char **)strp2
;
727 while (*str1
&& *str2
&& *str1
!= '=' && *str2
!= '=')
729 /* Sort order in command.com/cmd.exe is based on uppercasing
730 names, so do the same here. */
731 if (toupper (*str1
) > toupper (*str2
))
733 else if (toupper (*str1
) < toupper (*str2
))
738 if (*str1
== '=' && *str2
== '=')
740 else if (*str1
== '=')
747 merge_and_sort_env (char **envp1
, char **envp2
, char **new_envp
)
763 qsort (new_envp
, num
, sizeof (char *), compare_env
);
768 /* When a new child process is created we need to register it in our list,
769 so intercept spawn requests. */
771 sys_spawnve (int mode
, char *cmdname
, char **argv
, char **envp
)
773 Lisp_Object program
, full
;
774 char *cmdline
, *env
, *parg
, **targ
;
778 int is_dos_app
, is_cygnus_app
, is_gui_app
;
781 /* We pass our process ID to our children by setting up an environment
782 variable in their environment. */
783 char ppid_env_var_buffer
[64];
784 char *extra_env
[] = {ppid_env_var_buffer
, NULL
};
785 /* These are the characters that cause an argument to need quoting.
786 Arguments with whitespace characters need quoting to prevent the
787 argument being split into two or more. Arguments with wildcards
788 are also quoted, for consistency with posix platforms, where wildcards
789 are not expanded if we run the program directly without a shell.
790 Some extra whitespace characters need quoting in Cygwin programs,
791 so this list is conditionally modified below. */
792 char *sepchars
= " \t*?";
794 /* We don't care about the other modes */
795 if (mode
!= _P_NOWAIT
)
801 /* Handle executable names without an executable suffix. */
802 program
= build_string (cmdname
);
803 if (NILP (Ffile_executable_p (program
)))
809 openp (Vexec_path
, program
, Vexec_suffixes
, &full
, make_number (X_OK
));
819 /* make sure argv[0] and cmdname are both in DOS format */
820 cmdname
= SDATA (program
);
821 unixtodos_filename (cmdname
);
824 /* Determine whether program is a 16-bit DOS executable, or a 32-bit Windows
825 executable that is implicitly linked to the Cygnus dll (implying it
826 was compiled with the Cygnus GNU toolchain and hence relies on
827 cygwin.dll to parse the command line - we use this to decide how to
828 escape quote chars in command line args that must be quoted).
830 Also determine whether it is a GUI app, so that we don't hide its
831 initial window unless specifically requested. */
832 w32_executable_type (cmdname
, &is_dos_app
, &is_cygnus_app
, &is_gui_app
);
834 /* On Windows 95, if cmdname is a DOS app, we invoke a helper
835 application to start it by specifying the helper app as cmdname,
836 while leaving the real app name as argv[0]. */
839 cmdname
= alloca (MAXPATHLEN
);
840 if (egetenv ("CMDPROXY"))
841 strcpy (cmdname
, egetenv ("CMDPROXY"));
844 strcpy (cmdname
, SDATA (Vinvocation_directory
));
845 strcat (cmdname
, "cmdproxy.exe");
847 unixtodos_filename (cmdname
);
850 /* we have to do some conjuring here to put argv and envp into the
851 form CreateProcess wants... argv needs to be a space separated/null
852 terminated list of parameters, and envp is a null
853 separated/double-null terminated list of parameters.
855 Additionally, zero-length args and args containing whitespace or
856 quote chars need to be wrapped in double quotes - for this to work,
857 embedded quotes need to be escaped as well. The aim is to ensure
858 the child process reconstructs the argv array we start with
859 exactly, so we treat quotes at the beginning and end of arguments
862 The w32 GNU-based library from Cygnus doubles quotes to escape
863 them, while MSVC uses backslash for escaping. (Actually the MSVC
864 startup code does attempt to recognize doubled quotes and accept
865 them, but gets it wrong and ends up requiring three quotes to get a
866 single embedded quote!) So by default we decide whether to use
867 quote or backslash as the escape character based on whether the
868 binary is apparently a Cygnus compiled app.
870 Note that using backslash to escape embedded quotes requires
871 additional special handling if an embedded quote is already
872 preceded by backslash, or if an arg requiring quoting ends with
873 backslash. In such cases, the run of escape characters needs to be
874 doubled. For consistency, we apply this special handling as long
875 as the escape character is not quote.
877 Since we have no idea how large argv and envp are likely to be we
878 figure out list lengths on the fly and allocate them. */
880 if (!NILP (Vw32_quote_process_args
))
883 /* Override escape char by binding w32-quote-process-args to
884 desired character, or use t for auto-selection. */
885 if (INTEGERP (Vw32_quote_process_args
))
886 escape_char
= XINT (Vw32_quote_process_args
);
888 escape_char
= is_cygnus_app
? '"' : '\\';
891 /* Cygwin apps needs quoting a bit more often. */
892 if (escape_char
== '"')
893 sepchars
= "\r\n\t\f '";
902 int escape_char_run
= 0;
908 if (escape_char
== '"' && *p
== '\\')
909 /* If it's a Cygwin app, \ needs to be escaped. */
913 /* allow for embedded quotes to be escaped */
916 /* handle the case where the embedded quote is already escaped */
917 if (escape_char_run
> 0)
919 /* To preserve the arg exactly, we need to double the
920 preceding escape characters (plus adding one to
921 escape the quote character itself). */
922 arglen
+= escape_char_run
;
925 else if (strchr (sepchars
, *p
) != NULL
)
930 if (*p
== escape_char
&& escape_char
!= '"')
938 /* handle the case where the arg ends with an escape char - we
939 must not let the enclosing quote be escaped. */
940 if (escape_char_run
> 0)
941 arglen
+= escape_char_run
;
943 arglen
+= strlen (*targ
++) + 1;
945 cmdline
= alloca (arglen
);
959 if ((strchr (sepchars
, *p
) != NULL
) || *p
== '"')
964 int escape_char_run
= 0;
970 last
= p
+ strlen (p
) - 1;
973 /* This version does not escape quotes if they occur at the
974 beginning or end of the arg - this could lead to incorrect
975 behavior when the arg itself represents a command line
976 containing quoted args. I believe this was originally done
977 as a hack to make some things work, before
978 `w32-quote-process-args' was added. */
981 if (*p
== '"' && p
> first
&& p
< last
)
982 *parg
++ = escape_char
; /* escape embedded quotes */
990 /* double preceding escape chars if any */
991 while (escape_char_run
> 0)
993 *parg
++ = escape_char
;
996 /* escape all quote chars, even at beginning or end */
997 *parg
++ = escape_char
;
999 else if (escape_char
== '"' && *p
== '\\')
1003 if (*p
== escape_char
&& escape_char
!= '"')
1006 escape_char_run
= 0;
1008 /* double escape chars before enclosing quote */
1009 while (escape_char_run
> 0)
1011 *parg
++ = escape_char
;
1019 strcpy (parg
, *targ
);
1020 parg
+= strlen (*targ
);
1030 numenv
= 1; /* for end null */
1033 arglen
+= strlen (*targ
++) + 1;
1036 /* extra env vars... */
1037 sprintf (ppid_env_var_buffer
, "EM_PARENT_PROCESS_ID=%d",
1038 GetCurrentProcessId ());
1039 arglen
+= strlen (ppid_env_var_buffer
) + 1;
1042 /* merge env passed in and extra env into one, and sort it. */
1043 targ
= (char **) alloca (numenv
* sizeof (char *));
1044 merge_and_sort_env (envp
, extra_env
, targ
);
1046 /* concatenate env entries. */
1047 env
= alloca (arglen
);
1051 strcpy (parg
, *targ
);
1052 parg
+= strlen (*targ
++);
1065 /* Now create the process. */
1066 if (!create_child (cmdname
, cmdline
, env
, is_gui_app
, &pid
, cp
))
1076 /* Emulate the select call
1077 Wait for available input on any of the given rfds, or timeout if
1078 a timeout is given and no input is detected
1079 wfds and efds are not supported and must be NULL.
1081 For simplicity, we detect the death of child processes here and
1082 synchronously call the SIGCHLD handler. Since it is possible for
1083 children to be created without a corresponding pipe handle from which
1084 to read output, we wait separately on the process handles as well as
1085 the char_avail events for each process pipe. We only call
1086 wait/reap_process when the process actually terminates.
1088 To reduce the number of places in which Emacs can be hung such that
1089 C-g is not able to interrupt it, we always wait on interrupt_handle
1090 (which is signaled by the input thread when C-g is detected). If we
1091 detect that we were woken up by C-g, we return -1 with errno set to
1092 EINTR as on Unix. */
1094 /* From w32console.c */
1095 extern HANDLE keyboard_handle
;
1097 /* From w32xfns.c */
1098 extern HANDLE interrupt_handle
;
1100 /* From process.c */
1101 extern int proc_buffered_char
[];
1104 sys_select (int nfds
, SELECT_TYPE
*rfds
, SELECT_TYPE
*wfds
, SELECT_TYPE
*efds
,
1105 EMACS_TIME
*timeout
, void *ignored
)
1108 DWORD timeout_ms
, start_time
;
1111 child_process
*cp
, *cps
[MAX_CHILDREN
];
1112 HANDLE wait_hnd
[MAXDESC
+ MAX_CHILDREN
];
1113 int fdindex
[MAXDESC
]; /* mapping from wait handles back to descriptors */
1116 timeout
? (timeout
->tv_sec
* 1000 + timeout
->tv_nsec
/ 1000000) : INFINITE
;
1118 /* If the descriptor sets are NULL but timeout isn't, then just Sleep. */
1119 if (rfds
== NULL
&& wfds
== NULL
&& efds
== NULL
&& timeout
!= NULL
)
1125 /* Otherwise, we only handle rfds, so fail otherwise. */
1126 if (rfds
== NULL
|| wfds
!= NULL
|| efds
!= NULL
)
1136 /* Always wait on interrupt_handle, to detect C-g (quit). */
1137 wait_hnd
[0] = interrupt_handle
;
1140 /* Build a list of pipe handles to wait on. */
1142 for (i
= 0; i
< nfds
; i
++)
1143 if (FD_ISSET (i
, &orfds
))
1147 if (keyboard_handle
)
1149 /* Handle stdin specially */
1150 wait_hnd
[nh
] = keyboard_handle
;
1155 /* Check for any emacs-generated input in the queue since
1156 it won't be detected in the wait */
1157 if (detect_input_pending ())
1165 /* Child process and socket input */
1169 int current_status
= cp
->status
;
1171 if (current_status
== STATUS_READ_ACKNOWLEDGED
)
1173 /* Tell reader thread which file handle to use. */
1175 /* Wake up the reader thread for this process */
1176 cp
->status
= STATUS_READ_READY
;
1177 if (!SetEvent (cp
->char_consumed
))
1178 DebPrint (("nt_select.SetEvent failed with "
1179 "%lu for fd %ld\n", GetLastError (), i
));
1182 #ifdef CHECK_INTERLOCK
1183 /* slightly crude cross-checking of interlock between threads */
1185 current_status
= cp
->status
;
1186 if (WaitForSingleObject (cp
->char_avail
, 0) == WAIT_OBJECT_0
)
1188 /* char_avail has been signaled, so status (which may
1189 have changed) should indicate read has completed
1190 but has not been acknowledged. */
1191 current_status
= cp
->status
;
1192 if (current_status
!= STATUS_READ_SUCCEEDED
1193 && current_status
!= STATUS_READ_FAILED
)
1194 DebPrint (("char_avail set, but read not completed: status %d\n",
1199 /* char_avail has not been signaled, so status should
1200 indicate that read is in progress; small possibility
1201 that read has completed but event wasn't yet signaled
1202 when we tested it (because a context switch occurred
1203 or if running on separate CPUs). */
1204 if (current_status
!= STATUS_READ_READY
1205 && current_status
!= STATUS_READ_IN_PROGRESS
1206 && current_status
!= STATUS_READ_SUCCEEDED
1207 && current_status
!= STATUS_READ_FAILED
)
1208 DebPrint (("char_avail reset, but read status is bad: %d\n",
1212 wait_hnd
[nh
] = cp
->char_avail
;
1214 if (!wait_hnd
[nh
]) emacs_abort ();
1217 DebPrint (("select waiting on child %d fd %d\n",
1218 cp
-child_procs
, i
));
1223 /* Unable to find something to wait on for this fd, skip */
1225 /* Note that this is not a fatal error, and can in fact
1226 happen in unusual circumstances. Specifically, if
1227 sys_spawnve fails, eg. because the program doesn't
1228 exist, and debug-on-error is t so Fsignal invokes a
1229 nested input loop, then the process output pipe is
1230 still included in input_wait_mask with no child_proc
1231 associated with it. (It is removed when the debugger
1232 exits the nested input loop and the error is thrown.) */
1234 DebPrint (("sys_select: fd %ld is invalid! ignoring\n", i
));
1240 /* Add handles of child processes. */
1242 for (cp
= child_procs
+ (child_proc_count
-1); cp
>= child_procs
; cp
--)
1243 /* Some child_procs might be sockets; ignore them. Also some
1244 children may have died already, but we haven't finished reading
1245 the process output; ignore them too. */
1246 if (CHILD_ACTIVE (cp
) && cp
->procinfo
.hProcess
1248 || (fd_info
[cp
->fd
].flags
& FILE_SEND_SIGCHLD
) == 0
1249 || (fd_info
[cp
->fd
].flags
& FILE_AT_EOF
) != 0)
1252 wait_hnd
[nh
+ nc
] = cp
->procinfo
.hProcess
;
1257 /* Nothing to look for, so we didn't find anything */
1265 start_time
= GetTickCount ();
1267 /* Wait for input or child death to be signaled. If user input is
1268 allowed, then also accept window messages. */
1269 if (FD_ISSET (0, &orfds
))
1270 active
= MsgWaitForMultipleObjects (nh
+ nc
, wait_hnd
, FALSE
, timeout_ms
,
1273 active
= WaitForMultipleObjects (nh
+ nc
, wait_hnd
, FALSE
, timeout_ms
);
1275 if (active
== WAIT_FAILED
)
1277 DebPrint (("select.WaitForMultipleObjects (%d, %lu) failed with %lu\n",
1278 nh
+ nc
, timeout_ms
, GetLastError ()));
1279 /* don't return EBADF - this causes wait_reading_process_output to
1280 abort; WAIT_FAILED is returned when single-stepping under
1281 Windows 95 after switching thread focus in debugger, and
1282 possibly at other times. */
1286 else if (active
== WAIT_TIMEOUT
)
1290 else if (active
>= WAIT_OBJECT_0
1291 && active
< WAIT_OBJECT_0
+MAXIMUM_WAIT_OBJECTS
)
1293 active
-= WAIT_OBJECT_0
;
1295 else if (active
>= WAIT_ABANDONED_0
1296 && active
< WAIT_ABANDONED_0
+MAXIMUM_WAIT_OBJECTS
)
1298 active
-= WAIT_ABANDONED_0
;
1303 /* Loop over all handles after active (now officially documented as
1304 being the first signaled handle in the array). We do this to
1305 ensure fairness, so that all channels with data available will be
1306 processed - otherwise higher numbered channels could be starved. */
1309 if (active
== nh
+ nc
)
1311 /* There are messages in the lisp thread's queue; we must
1312 drain the queue now to ensure they are processed promptly,
1313 because if we don't do so, we will not be woken again until
1314 further messages arrive.
1316 NB. If ever we allow window message procedures to callback
1317 into lisp, we will need to ensure messages are dispatched
1318 at a safe time for lisp code to be run (*), and we may also
1319 want to provide some hooks in the dispatch loop to cater
1320 for modeless dialogs created by lisp (ie. to register
1321 window handles to pass to IsDialogMessage).
1323 (*) Note that MsgWaitForMultipleObjects above is an
1324 internal dispatch point for messages that are sent to
1325 windows created by this thread. */
1326 drain_message_queue ();
1328 else if (active
>= nh
)
1330 cp
= cps
[active
- nh
];
1332 /* We cannot always signal SIGCHLD immediately; if we have not
1333 finished reading the process output, we must delay sending
1334 SIGCHLD until we do. */
1336 if (cp
->fd
>= 0 && (fd_info
[cp
->fd
].flags
& FILE_AT_EOF
) == 0)
1337 fd_info
[cp
->fd
].flags
|= FILE_SEND_SIGCHLD
;
1338 /* SIG_DFL for SIGCHLD is ignore */
1339 else if (sig_handlers
[SIGCHLD
] != SIG_DFL
&&
1340 sig_handlers
[SIGCHLD
] != SIG_IGN
)
1343 DebPrint (("select calling SIGCHLD handler for pid %d\n",
1347 sig_handlers
[SIGCHLD
] (SIGCHLD
);
1351 else if (fdindex
[active
] == -1)
1353 /* Quit (C-g) was detected. */
1357 else if (fdindex
[active
] == 0)
1359 /* Keyboard input available */
1365 /* must be a socket or pipe - read ahead should have
1366 completed, either succeeding or failing. */
1367 FD_SET (fdindex
[active
], rfds
);
1371 /* Even though wait_reading_process_output only reads from at most
1372 one channel, we must process all channels here so that we reap
1373 all children that have died. */
1374 while (++active
< nh
+ nc
)
1375 if (WaitForSingleObject (wait_hnd
[active
], 0) == WAIT_OBJECT_0
)
1377 } while (active
< nh
+ nc
);
1379 /* If no input has arrived and timeout hasn't expired, wait again. */
1382 DWORD elapsed
= GetTickCount () - start_time
;
1384 if (timeout_ms
> elapsed
) /* INFINITE is MAX_UINT */
1386 if (timeout_ms
!= INFINITE
)
1387 timeout_ms
-= elapsed
;
1388 goto count_children
;
1395 /* Substitute for certain kill () operations */
1397 static BOOL CALLBACK
1398 find_child_console (HWND hwnd
, LPARAM arg
)
1400 child_process
* cp
= (child_process
*) arg
;
1404 thread_id
= GetWindowThreadProcessId (hwnd
, &process_id
);
1405 if (process_id
== cp
->procinfo
.dwProcessId
)
1407 char window_class
[32];
1409 GetClassName (hwnd
, window_class
, sizeof (window_class
));
1410 if (strcmp (window_class
,
1411 (os_subtype
== OS_9X
)
1413 : "ConsoleWindowClass") == 0)
1424 sys_kill (int pid
, int sig
)
1428 int need_to_free
= 0;
1431 if (pid
== getpid () && sig
== SIGABRT
)
1434 /* Only handle signals that will result in the process dying */
1435 if (sig
!= SIGINT
&& sig
!= SIGKILL
&& sig
!= SIGQUIT
&& sig
!= SIGHUP
)
1441 cp
= find_child_pid (pid
);
1444 proc_hand
= OpenProcess (PROCESS_TERMINATE
, 0, pid
);
1445 if (proc_hand
== NULL
)
1454 proc_hand
= cp
->procinfo
.hProcess
;
1455 pid
= cp
->procinfo
.dwProcessId
;
1457 /* Try to locate console window for process. */
1458 EnumWindows (find_child_console
, (LPARAM
) cp
);
1461 if (sig
== SIGINT
|| sig
== SIGQUIT
)
1463 if (NILP (Vw32_start_process_share_console
) && cp
&& cp
->hwnd
)
1465 BYTE control_scan_code
= (BYTE
) MapVirtualKey (VK_CONTROL
, 0);
1466 /* Fake Ctrl-C for SIGINT, and Ctrl-Break for SIGQUIT. */
1467 BYTE vk_break_code
= (sig
== SIGINT
) ? 'C' : VK_CANCEL
;
1468 BYTE break_scan_code
= (BYTE
) MapVirtualKey (vk_break_code
, 0);
1469 HWND foreground_window
;
1471 if (break_scan_code
== 0)
1473 /* Fake Ctrl-C for SIGQUIT if we can't manage Ctrl-Break. */
1474 vk_break_code
= 'C';
1475 break_scan_code
= (BYTE
) MapVirtualKey (vk_break_code
, 0);
1478 foreground_window
= GetForegroundWindow ();
1479 if (foreground_window
)
1481 /* NT 5.0, and apparently also Windows 98, will not allow
1482 a Window to be set to foreground directly without the
1483 user's involvement. The workaround is to attach
1484 ourselves to the thread that owns the foreground
1485 window, since that is the only thread that can set the
1486 foreground window. */
1487 DWORD foreground_thread
, child_thread
;
1489 GetWindowThreadProcessId (foreground_window
, NULL
);
1490 if (foreground_thread
== GetCurrentThreadId ()
1491 || !AttachThreadInput (GetCurrentThreadId (),
1492 foreground_thread
, TRUE
))
1493 foreground_thread
= 0;
1495 child_thread
= GetWindowThreadProcessId (cp
->hwnd
, NULL
);
1496 if (child_thread
== GetCurrentThreadId ()
1497 || !AttachThreadInput (GetCurrentThreadId (),
1498 child_thread
, TRUE
))
1501 /* Set the foreground window to the child. */
1502 if (SetForegroundWindow (cp
->hwnd
))
1504 /* Generate keystrokes as if user had typed Ctrl-Break or
1506 keybd_event (VK_CONTROL
, control_scan_code
, 0, 0);
1507 keybd_event (vk_break_code
, break_scan_code
,
1508 (vk_break_code
== 'C' ? 0 : KEYEVENTF_EXTENDEDKEY
), 0);
1509 keybd_event (vk_break_code
, break_scan_code
,
1510 (vk_break_code
== 'C' ? 0 : KEYEVENTF_EXTENDEDKEY
)
1511 | KEYEVENTF_KEYUP
, 0);
1512 keybd_event (VK_CONTROL
, control_scan_code
,
1513 KEYEVENTF_KEYUP
, 0);
1515 /* Sleep for a bit to give time for Emacs frame to respond
1516 to focus change events (if Emacs was active app). */
1519 SetForegroundWindow (foreground_window
);
1521 /* Detach from the foreground and child threads now that
1522 the foreground switching is over. */
1523 if (foreground_thread
)
1524 AttachThreadInput (GetCurrentThreadId (),
1525 foreground_thread
, FALSE
);
1527 AttachThreadInput (GetCurrentThreadId (),
1528 child_thread
, FALSE
);
1531 /* Ctrl-Break is NT equivalent of SIGINT. */
1532 else if (!GenerateConsoleCtrlEvent (CTRL_BREAK_EVENT
, pid
))
1534 DebPrint (("sys_kill.GenerateConsoleCtrlEvent return %d "
1535 "for pid %lu\n", GetLastError (), pid
));
1542 if (NILP (Vw32_start_process_share_console
) && cp
&& cp
->hwnd
)
1545 if (os_subtype
== OS_9X
)
1548 Another possibility is to try terminating the VDM out-right by
1549 calling the Shell VxD (id 0x17) V86 interface, function #4
1550 "SHELL_Destroy_VM", ie.
1556 First need to determine the current VM handle, and then arrange for
1557 the shellapi call to be made from the system vm (by using
1558 Switch_VM_and_callback).
1560 Could try to invoke DestroyVM through CallVxD.
1564 /* On Windows 95, posting WM_QUIT causes the 16-bit subsystem
1565 to hang when cmdproxy is used in conjunction with
1566 command.com for an interactive shell. Posting
1567 WM_CLOSE pops up a dialog that, when Yes is selected,
1568 does the same thing. TerminateProcess is also less
1569 than ideal in that subprocesses tend to stick around
1570 until the machine is shutdown, but at least it
1571 doesn't freeze the 16-bit subsystem. */
1572 PostMessage (cp
->hwnd
, WM_QUIT
, 0xff, 0);
1574 if (!TerminateProcess (proc_hand
, 0xff))
1576 DebPrint (("sys_kill.TerminateProcess returned %d "
1577 "for pid %lu\n", GetLastError (), pid
));
1584 PostMessage (cp
->hwnd
, WM_CLOSE
, 0, 0);
1586 /* Kill the process. On W32 this doesn't kill child processes
1587 so it doesn't work very well for shells which is why it's not
1588 used in every case. */
1589 else if (!TerminateProcess (proc_hand
, 0xff))
1591 DebPrint (("sys_kill.TerminateProcess returned %d "
1592 "for pid %lu\n", GetLastError (), pid
));
1599 CloseHandle (proc_hand
);
1604 /* The following two routines are used to manipulate stdin, stdout, and
1605 stderr of our child processes.
1607 Assuming that in, out, and err are *not* inheritable, we make them
1608 stdin, stdout, and stderr of the child as follows:
1610 - Save the parent's current standard handles.
1611 - Set the std handles to inheritable duplicates of the ones being passed in.
1612 (Note that _get_osfhandle() is an io.h procedure that retrieves the
1613 NT file handle for a crt file descriptor.)
1614 - Spawn the child, which inherits in, out, and err as stdin,
1615 stdout, and stderr. (see Spawnve)
1616 - Close the std handles passed to the child.
1617 - Reset the parent's standard handles to the saved handles.
1618 (see reset_standard_handles)
1619 We assume that the caller closes in, out, and err after calling us. */
1622 prepare_standard_handles (int in
, int out
, int err
, HANDLE handles
[3])
1625 HANDLE newstdin
, newstdout
, newstderr
;
1627 parent
= GetCurrentProcess ();
1629 handles
[0] = GetStdHandle (STD_INPUT_HANDLE
);
1630 handles
[1] = GetStdHandle (STD_OUTPUT_HANDLE
);
1631 handles
[2] = GetStdHandle (STD_ERROR_HANDLE
);
1633 /* make inheritable copies of the new handles */
1634 if (!DuplicateHandle (parent
,
1635 (HANDLE
) _get_osfhandle (in
),
1640 DUPLICATE_SAME_ACCESS
))
1641 report_file_error ("Duplicating input handle for child", Qnil
);
1643 if (!DuplicateHandle (parent
,
1644 (HANDLE
) _get_osfhandle (out
),
1649 DUPLICATE_SAME_ACCESS
))
1650 report_file_error ("Duplicating output handle for child", Qnil
);
1652 if (!DuplicateHandle (parent
,
1653 (HANDLE
) _get_osfhandle (err
),
1658 DUPLICATE_SAME_ACCESS
))
1659 report_file_error ("Duplicating error handle for child", Qnil
);
1661 /* and store them as our std handles */
1662 if (!SetStdHandle (STD_INPUT_HANDLE
, newstdin
))
1663 report_file_error ("Changing stdin handle", Qnil
);
1665 if (!SetStdHandle (STD_OUTPUT_HANDLE
, newstdout
))
1666 report_file_error ("Changing stdout handle", Qnil
);
1668 if (!SetStdHandle (STD_ERROR_HANDLE
, newstderr
))
1669 report_file_error ("Changing stderr handle", Qnil
);
1673 reset_standard_handles (int in
, int out
, int err
, HANDLE handles
[3])
1675 /* close the duplicated handles passed to the child */
1676 CloseHandle (GetStdHandle (STD_INPUT_HANDLE
));
1677 CloseHandle (GetStdHandle (STD_OUTPUT_HANDLE
));
1678 CloseHandle (GetStdHandle (STD_ERROR_HANDLE
));
1680 /* now restore parent's saved std handles */
1681 SetStdHandle (STD_INPUT_HANDLE
, handles
[0]);
1682 SetStdHandle (STD_OUTPUT_HANDLE
, handles
[1]);
1683 SetStdHandle (STD_ERROR_HANDLE
, handles
[2]);
1687 set_process_dir (char * dir
)
1692 /* To avoid problems with winsock implementations that work over dial-up
1693 connections causing or requiring a connection to exist while Emacs is
1694 running, Emacs no longer automatically loads winsock on startup if it
1695 is present. Instead, it will be loaded when open-network-stream is
1698 To allow full control over when winsock is loaded, we provide these
1699 two functions to dynamically load and unload winsock. This allows
1700 dial-up users to only be connected when they actually need to use
1704 extern HANDLE winsock_lib
;
1705 extern BOOL
term_winsock (void);
1706 extern BOOL
init_winsock (int load_now
);
1708 DEFUN ("w32-has-winsock", Fw32_has_winsock
, Sw32_has_winsock
, 0, 1, 0,
1709 doc
: /* Test for presence of the Windows socket library `winsock'.
1710 Returns non-nil if winsock support is present, nil otherwise.
1712 If the optional argument LOAD-NOW is non-nil, the winsock library is
1713 also loaded immediately if not already loaded. If winsock is loaded,
1714 the winsock local hostname is returned (since this may be different from
1715 the value of `system-name' and should supplant it), otherwise t is
1716 returned to indicate winsock support is present. */)
1717 (Lisp_Object load_now
)
1721 have_winsock
= init_winsock (!NILP (load_now
));
1724 if (winsock_lib
!= NULL
)
1726 /* Return new value for system-name. The best way to do this
1727 is to call init_system_name, saving and restoring the
1728 original value to avoid side-effects. */
1729 Lisp_Object orig_hostname
= Vsystem_name
;
1730 Lisp_Object hostname
;
1732 init_system_name ();
1733 hostname
= Vsystem_name
;
1734 Vsystem_name
= orig_hostname
;
1742 DEFUN ("w32-unload-winsock", Fw32_unload_winsock
, Sw32_unload_winsock
,
1744 doc
: /* Unload the Windows socket library `winsock' if loaded.
1745 This is provided to allow dial-up socket connections to be disconnected
1746 when no longer needed. Returns nil without unloading winsock if any
1747 socket connections still exist. */)
1750 return term_winsock () ? Qt
: Qnil
;
1754 /* Some miscellaneous functions that are Windows specific, but not GUI
1755 specific (ie. are applicable in terminal or batch mode as well). */
1757 DEFUN ("w32-short-file-name", Fw32_short_file_name
, Sw32_short_file_name
, 1, 1, 0,
1758 doc
: /* Return the short file name version (8.3) of the full path of FILENAME.
1759 If FILENAME does not exist, return nil.
1760 All path elements in FILENAME are converted to their short names. */)
1761 (Lisp_Object filename
)
1763 char shortname
[MAX_PATH
];
1765 CHECK_STRING (filename
);
1767 /* first expand it. */
1768 filename
= Fexpand_file_name (filename
, Qnil
);
1770 /* luckily, this returns the short version of each element in the path. */
1771 if (GetShortPathName (SDATA (ENCODE_FILE (filename
)), shortname
, MAX_PATH
) == 0)
1774 dostounix_filename (shortname
);
1776 return build_string (shortname
);
1780 DEFUN ("w32-long-file-name", Fw32_long_file_name
, Sw32_long_file_name
,
1782 doc
: /* Return the long file name version of the full path of FILENAME.
1783 If FILENAME does not exist, return nil.
1784 All path elements in FILENAME are converted to their long names. */)
1785 (Lisp_Object filename
)
1787 char longname
[ MAX_PATH
];
1790 CHECK_STRING (filename
);
1792 if (SBYTES (filename
) == 2
1793 && *(SDATA (filename
) + 1) == ':')
1796 /* first expand it. */
1797 filename
= Fexpand_file_name (filename
, Qnil
);
1799 if (!w32_get_long_filename (SDATA (ENCODE_FILE (filename
)), longname
, MAX_PATH
))
1802 dostounix_filename (longname
);
1804 /* If we were passed only a drive, make sure that a slash is not appended
1805 for consistency with directories. Allow for drive mapping via SUBST
1806 in case expand-file-name is ever changed to expand those. */
1807 if (drive_only
&& longname
[1] == ':' && longname
[2] == '/' && !longname
[3])
1810 return DECODE_FILE (build_string (longname
));
1813 DEFUN ("w32-set-process-priority", Fw32_set_process_priority
,
1814 Sw32_set_process_priority
, 2, 2, 0,
1815 doc
: /* Set the priority of PROCESS to PRIORITY.
1816 If PROCESS is nil, the priority of Emacs is changed, otherwise the
1817 priority of the process whose pid is PROCESS is changed.
1818 PRIORITY should be one of the symbols high, normal, or low;
1819 any other symbol will be interpreted as normal.
1821 If successful, the return value is t, otherwise nil. */)
1822 (Lisp_Object process
, Lisp_Object priority
)
1824 HANDLE proc_handle
= GetCurrentProcess ();
1825 DWORD priority_class
= NORMAL_PRIORITY_CLASS
;
1826 Lisp_Object result
= Qnil
;
1828 CHECK_SYMBOL (priority
);
1830 if (!NILP (process
))
1835 CHECK_NUMBER (process
);
1837 /* Allow pid to be an internally generated one, or one obtained
1838 externally. This is necessary because real pids on Windows 95 are
1841 pid
= XINT (process
);
1842 cp
= find_child_pid (pid
);
1844 pid
= cp
->procinfo
.dwProcessId
;
1846 proc_handle
= OpenProcess (PROCESS_SET_INFORMATION
, FALSE
, pid
);
1849 if (EQ (priority
, Qhigh
))
1850 priority_class
= HIGH_PRIORITY_CLASS
;
1851 else if (EQ (priority
, Qlow
))
1852 priority_class
= IDLE_PRIORITY_CLASS
;
1854 if (proc_handle
!= NULL
)
1856 if (SetPriorityClass (proc_handle
, priority_class
))
1858 if (!NILP (process
))
1859 CloseHandle (proc_handle
);
1865 #ifdef HAVE_LANGINFO_CODESET
1866 /* Emulation of nl_langinfo. Used in fns.c:Flocale_info. */
1868 nl_langinfo (nl_item item
)
1870 /* Conversion of Posix item numbers to their Windows equivalents. */
1871 static const LCTYPE w32item
[] = {
1872 LOCALE_IDEFAULTANSICODEPAGE
,
1873 LOCALE_SDAYNAME1
, LOCALE_SDAYNAME2
, LOCALE_SDAYNAME3
,
1874 LOCALE_SDAYNAME4
, LOCALE_SDAYNAME5
, LOCALE_SDAYNAME6
, LOCALE_SDAYNAME7
,
1875 LOCALE_SMONTHNAME1
, LOCALE_SMONTHNAME2
, LOCALE_SMONTHNAME3
,
1876 LOCALE_SMONTHNAME4
, LOCALE_SMONTHNAME5
, LOCALE_SMONTHNAME6
,
1877 LOCALE_SMONTHNAME7
, LOCALE_SMONTHNAME8
, LOCALE_SMONTHNAME9
,
1878 LOCALE_SMONTHNAME10
, LOCALE_SMONTHNAME11
, LOCALE_SMONTHNAME12
1881 static char *nl_langinfo_buf
= NULL
;
1882 static int nl_langinfo_len
= 0;
1884 if (nl_langinfo_len
<= 0)
1885 nl_langinfo_buf
= xmalloc (nl_langinfo_len
= 1);
1887 if (item
< 0 || item
>= _NL_NUM
)
1888 nl_langinfo_buf
[0] = 0;
1891 LCID cloc
= GetThreadLocale ();
1892 int need_len
= GetLocaleInfo (cloc
, w32item
[item
] | LOCALE_USE_CP_ACP
,
1896 nl_langinfo_buf
[0] = 0;
1899 if (item
== CODESET
)
1901 need_len
+= 2; /* for the "cp" prefix */
1902 if (need_len
< 8) /* for the case we call GetACP */
1905 if (nl_langinfo_len
<= need_len
)
1906 nl_langinfo_buf
= xrealloc (nl_langinfo_buf
,
1907 nl_langinfo_len
= need_len
);
1908 if (!GetLocaleInfo (cloc
, w32item
[item
] | LOCALE_USE_CP_ACP
,
1909 nl_langinfo_buf
, nl_langinfo_len
))
1910 nl_langinfo_buf
[0] = 0;
1911 else if (item
== CODESET
)
1913 if (strcmp (nl_langinfo_buf
, "0") == 0 /* CP_ACP */
1914 || strcmp (nl_langinfo_buf
, "1") == 0) /* CP_OEMCP */
1915 sprintf (nl_langinfo_buf
, "cp%u", GetACP ());
1918 memmove (nl_langinfo_buf
+ 2, nl_langinfo_buf
,
1919 strlen (nl_langinfo_buf
) + 1);
1920 nl_langinfo_buf
[0] = 'c';
1921 nl_langinfo_buf
[1] = 'p';
1926 return nl_langinfo_buf
;
1928 #endif /* HAVE_LANGINFO_CODESET */
1930 DEFUN ("w32-get-locale-info", Fw32_get_locale_info
,
1931 Sw32_get_locale_info
, 1, 2, 0,
1932 doc
: /* Return information about the Windows locale LCID.
1933 By default, return a three letter locale code which encodes the default
1934 language as the first two characters, and the country or regional variant
1935 as the third letter. For example, ENU refers to `English (United States)',
1936 while ENC means `English (Canadian)'.
1938 If the optional argument LONGFORM is t, the long form of the locale
1939 name is returned, e.g. `English (United States)' instead; if LONGFORM
1940 is a number, it is interpreted as an LCTYPE constant and the corresponding
1941 locale information is returned.
1943 If LCID (a 16-bit number) is not a valid locale, the result is nil. */)
1944 (Lisp_Object lcid
, Lisp_Object longform
)
1948 char abbrev_name
[32] = { 0 };
1949 char full_name
[256] = { 0 };
1951 CHECK_NUMBER (lcid
);
1953 if (!IsValidLocale (XINT (lcid
), LCID_SUPPORTED
))
1956 if (NILP (longform
))
1958 got_abbrev
= GetLocaleInfo (XINT (lcid
),
1959 LOCALE_SABBREVLANGNAME
| LOCALE_USE_CP_ACP
,
1960 abbrev_name
, sizeof (abbrev_name
));
1962 return build_string (abbrev_name
);
1964 else if (EQ (longform
, Qt
))
1966 got_full
= GetLocaleInfo (XINT (lcid
),
1967 LOCALE_SLANGUAGE
| LOCALE_USE_CP_ACP
,
1968 full_name
, sizeof (full_name
));
1970 return DECODE_SYSTEM (build_string (full_name
));
1972 else if (NUMBERP (longform
))
1974 got_full
= GetLocaleInfo (XINT (lcid
),
1976 full_name
, sizeof (full_name
));
1977 /* GetLocaleInfo's return value includes the terminating null
1978 character, when the returned information is a string, whereas
1979 make_unibyte_string needs the string length without the
1980 terminating null. */
1982 return make_unibyte_string (full_name
, got_full
- 1);
1989 DEFUN ("w32-get-current-locale-id", Fw32_get_current_locale_id
,
1990 Sw32_get_current_locale_id
, 0, 0, 0,
1991 doc
: /* Return Windows locale id for current locale setting.
1992 This is a numerical value; use `w32-get-locale-info' to convert to a
1993 human-readable form. */)
1996 return make_number (GetThreadLocale ());
2000 int_from_hex (char * s
)
2003 static char hex
[] = "0123456789abcdefABCDEF";
2006 while (*s
&& (p
= strchr (hex
, *s
)) != NULL
)
2008 unsigned digit
= p
- hex
;
2011 val
= val
* 16 + digit
;
2017 /* We need to build a global list, since the EnumSystemLocale callback
2018 function isn't given a context pointer. */
2019 Lisp_Object Vw32_valid_locale_ids
;
2021 static BOOL CALLBACK
2022 enum_locale_fn (LPTSTR localeNum
)
2024 DWORD id
= int_from_hex (localeNum
);
2025 Vw32_valid_locale_ids
= Fcons (make_number (id
), Vw32_valid_locale_ids
);
2029 DEFUN ("w32-get-valid-locale-ids", Fw32_get_valid_locale_ids
,
2030 Sw32_get_valid_locale_ids
, 0, 0, 0,
2031 doc
: /* Return list of all valid Windows locale ids.
2032 Each id is a numerical value; use `w32-get-locale-info' to convert to a
2033 human-readable form. */)
2036 Vw32_valid_locale_ids
= Qnil
;
2038 EnumSystemLocales (enum_locale_fn
, LCID_SUPPORTED
);
2040 Vw32_valid_locale_ids
= Fnreverse (Vw32_valid_locale_ids
);
2041 return Vw32_valid_locale_ids
;
2045 DEFUN ("w32-get-default-locale-id", Fw32_get_default_locale_id
, Sw32_get_default_locale_id
, 0, 1, 0,
2046 doc
: /* Return Windows locale id for default locale setting.
2047 By default, the system default locale setting is returned; if the optional
2048 parameter USERP is non-nil, the user default locale setting is returned.
2049 This is a numerical value; use `w32-get-locale-info' to convert to a
2050 human-readable form. */)
2054 return make_number (GetSystemDefaultLCID ());
2055 return make_number (GetUserDefaultLCID ());
2059 DEFUN ("w32-set-current-locale", Fw32_set_current_locale
, Sw32_set_current_locale
, 1, 1, 0,
2060 doc
: /* Make Windows locale LCID be the current locale setting for Emacs.
2061 If successful, the new locale id is returned, otherwise nil. */)
2064 CHECK_NUMBER (lcid
);
2066 if (!IsValidLocale (XINT (lcid
), LCID_SUPPORTED
))
2069 if (!SetThreadLocale (XINT (lcid
)))
2072 /* Need to set input thread locale if present. */
2073 if (dwWindowsThreadId
)
2074 /* Reply is not needed. */
2075 PostThreadMessage (dwWindowsThreadId
, WM_EMACS_SETLOCALE
, XINT (lcid
), 0);
2077 return make_number (GetThreadLocale ());
2081 /* We need to build a global list, since the EnumCodePages callback
2082 function isn't given a context pointer. */
2083 Lisp_Object Vw32_valid_codepages
;
2085 static BOOL CALLBACK
2086 enum_codepage_fn (LPTSTR codepageNum
)
2088 DWORD id
= atoi (codepageNum
);
2089 Vw32_valid_codepages
= Fcons (make_number (id
), Vw32_valid_codepages
);
2093 DEFUN ("w32-get-valid-codepages", Fw32_get_valid_codepages
,
2094 Sw32_get_valid_codepages
, 0, 0, 0,
2095 doc
: /* Return list of all valid Windows codepages. */)
2098 Vw32_valid_codepages
= Qnil
;
2100 EnumSystemCodePages (enum_codepage_fn
, CP_SUPPORTED
);
2102 Vw32_valid_codepages
= Fnreverse (Vw32_valid_codepages
);
2103 return Vw32_valid_codepages
;
2107 DEFUN ("w32-get-console-codepage", Fw32_get_console_codepage
,
2108 Sw32_get_console_codepage
, 0, 0, 0,
2109 doc
: /* Return current Windows codepage for console input. */)
2112 return make_number (GetConsoleCP ());
2116 DEFUN ("w32-set-console-codepage", Fw32_set_console_codepage
,
2117 Sw32_set_console_codepage
, 1, 1, 0,
2118 doc
: /* Make Windows codepage CP be the codepage for Emacs tty keyboard input.
2119 This codepage setting affects keyboard input in tty mode.
2120 If successful, the new CP is returned, otherwise nil. */)
2125 if (!IsValidCodePage (XINT (cp
)))
2128 if (!SetConsoleCP (XINT (cp
)))
2131 return make_number (GetConsoleCP ());
2135 DEFUN ("w32-get-console-output-codepage", Fw32_get_console_output_codepage
,
2136 Sw32_get_console_output_codepage
, 0, 0, 0,
2137 doc
: /* Return current Windows codepage for console output. */)
2140 return make_number (GetConsoleOutputCP ());
2144 DEFUN ("w32-set-console-output-codepage", Fw32_set_console_output_codepage
,
2145 Sw32_set_console_output_codepage
, 1, 1, 0,
2146 doc
: /* Make Windows codepage CP be the codepage for Emacs console output.
2147 This codepage setting affects display in tty mode.
2148 If successful, the new CP is returned, otherwise nil. */)
2153 if (!IsValidCodePage (XINT (cp
)))
2156 if (!SetConsoleOutputCP (XINT (cp
)))
2159 return make_number (GetConsoleOutputCP ());
2163 DEFUN ("w32-get-codepage-charset", Fw32_get_codepage_charset
,
2164 Sw32_get_codepage_charset
, 1, 1, 0,
2165 doc
: /* Return charset ID corresponding to codepage CP.
2166 Returns nil if the codepage is not valid. */)
2173 if (!IsValidCodePage (XINT (cp
)))
2176 if (TranslateCharsetInfo ((DWORD
*) XINT (cp
), &info
, TCI_SRCCODEPAGE
))
2177 return make_number (info
.ciCharset
);
2183 DEFUN ("w32-get-valid-keyboard-layouts", Fw32_get_valid_keyboard_layouts
,
2184 Sw32_get_valid_keyboard_layouts
, 0, 0, 0,
2185 doc
: /* Return list of Windows keyboard languages and layouts.
2186 The return value is a list of pairs of language id and layout id. */)
2189 int num_layouts
= GetKeyboardLayoutList (0, NULL
);
2190 HKL
* layouts
= (HKL
*) alloca (num_layouts
* sizeof (HKL
));
2191 Lisp_Object obj
= Qnil
;
2193 if (GetKeyboardLayoutList (num_layouts
, layouts
) == num_layouts
)
2195 while (--num_layouts
>= 0)
2197 DWORD kl
= (DWORD
) layouts
[num_layouts
];
2199 obj
= Fcons (Fcons (make_number (kl
& 0xffff),
2200 make_number ((kl
>> 16) & 0xffff)),
2209 DEFUN ("w32-get-keyboard-layout", Fw32_get_keyboard_layout
,
2210 Sw32_get_keyboard_layout
, 0, 0, 0,
2211 doc
: /* Return current Windows keyboard language and layout.
2212 The return value is the cons of the language id and the layout id. */)
2215 DWORD kl
= (DWORD
) GetKeyboardLayout (dwWindowsThreadId
);
2217 return Fcons (make_number (kl
& 0xffff),
2218 make_number ((kl
>> 16) & 0xffff));
2222 DEFUN ("w32-set-keyboard-layout", Fw32_set_keyboard_layout
,
2223 Sw32_set_keyboard_layout
, 1, 1, 0,
2224 doc
: /* Make LAYOUT be the current keyboard layout for Emacs.
2225 The keyboard layout setting affects interpretation of keyboard input.
2226 If successful, the new layout id is returned, otherwise nil. */)
2227 (Lisp_Object layout
)
2231 CHECK_CONS (layout
);
2232 CHECK_NUMBER_CAR (layout
);
2233 CHECK_NUMBER_CDR (layout
);
2235 kl
= (XINT (XCAR (layout
)) & 0xffff)
2236 | (XINT (XCDR (layout
)) << 16);
2238 /* Synchronize layout with input thread. */
2239 if (dwWindowsThreadId
)
2241 if (PostThreadMessage (dwWindowsThreadId
, WM_EMACS_SETKEYBOARDLAYOUT
,
2245 GetMessage (&msg
, NULL
, WM_EMACS_DONE
, WM_EMACS_DONE
);
2247 if (msg
.wParam
== 0)
2251 else if (!ActivateKeyboardLayout ((HKL
) kl
, 0))
2254 return Fw32_get_keyboard_layout ();
2259 syms_of_ntproc (void)
2261 DEFSYM (Qhigh
, "high");
2262 DEFSYM (Qlow
, "low");
2264 defsubr (&Sw32_has_winsock
);
2265 defsubr (&Sw32_unload_winsock
);
2267 defsubr (&Sw32_short_file_name
);
2268 defsubr (&Sw32_long_file_name
);
2269 defsubr (&Sw32_set_process_priority
);
2270 defsubr (&Sw32_get_locale_info
);
2271 defsubr (&Sw32_get_current_locale_id
);
2272 defsubr (&Sw32_get_default_locale_id
);
2273 defsubr (&Sw32_get_valid_locale_ids
);
2274 defsubr (&Sw32_set_current_locale
);
2276 defsubr (&Sw32_get_console_codepage
);
2277 defsubr (&Sw32_set_console_codepage
);
2278 defsubr (&Sw32_get_console_output_codepage
);
2279 defsubr (&Sw32_set_console_output_codepage
);
2280 defsubr (&Sw32_get_valid_codepages
);
2281 defsubr (&Sw32_get_codepage_charset
);
2283 defsubr (&Sw32_get_valid_keyboard_layouts
);
2284 defsubr (&Sw32_get_keyboard_layout
);
2285 defsubr (&Sw32_set_keyboard_layout
);
2287 DEFVAR_LISP ("w32-quote-process-args", Vw32_quote_process_args
,
2288 doc
: /* Non-nil enables quoting of process arguments to ensure correct parsing.
2289 Because Windows does not directly pass argv arrays to child processes,
2290 programs have to reconstruct the argv array by parsing the command
2291 line string. For an argument to contain a space, it must be enclosed
2292 in double quotes or it will be parsed as multiple arguments.
2294 If the value is a character, that character will be used to escape any
2295 quote characters that appear, otherwise a suitable escape character
2296 will be chosen based on the type of the program. */);
2297 Vw32_quote_process_args
= Qt
;
2299 DEFVAR_LISP ("w32-start-process-show-window",
2300 Vw32_start_process_show_window
,
2301 doc
: /* When nil, new child processes hide their windows.
2302 When non-nil, they show their window in the method of their choice.
2303 This variable doesn't affect GUI applications, which will never be hidden. */);
2304 Vw32_start_process_show_window
= Qnil
;
2306 DEFVAR_LISP ("w32-start-process-share-console",
2307 Vw32_start_process_share_console
,
2308 doc
: /* When nil, new child processes are given a new console.
2309 When non-nil, they share the Emacs console; this has the limitation of
2310 allowing only one DOS subprocess to run at a time (whether started directly
2311 or indirectly by Emacs), and preventing Emacs from cleanly terminating the
2312 subprocess group, but may allow Emacs to interrupt a subprocess that doesn't
2313 otherwise respond to interrupts from Emacs. */);
2314 Vw32_start_process_share_console
= Qnil
;
2316 DEFVAR_LISP ("w32-start-process-inherit-error-mode",
2317 Vw32_start_process_inherit_error_mode
,
2318 doc
: /* When nil, new child processes revert to the default error mode.
2319 When non-nil, they inherit their error mode setting from Emacs, which stops
2320 them blocking when trying to access unmounted drives etc. */);
2321 Vw32_start_process_inherit_error_mode
= Qt
;
2323 DEFVAR_INT ("w32-pipe-read-delay", w32_pipe_read_delay
,
2324 doc
: /* Forced delay before reading subprocess output.
2325 This is done to improve the buffering of subprocess output, by
2326 avoiding the inefficiency of frequently reading small amounts of data.
2328 If positive, the value is the number of milliseconds to sleep before
2329 reading the subprocess output. If negative, the magnitude is the number
2330 of time slices to wait (effectively boosting the priority of the child
2331 process temporarily). A value of zero disables waiting entirely. */);
2332 w32_pipe_read_delay
= 50;
2334 DEFVAR_LISP ("w32-downcase-file-names", Vw32_downcase_file_names
,
2335 doc
: /* Non-nil means convert all-upper case file names to lower case.
2336 This applies when performing completions and file name expansion.
2337 Note that the value of this setting also affects remote file names,
2338 so you probably don't want to set to non-nil if you use case-sensitive
2339 filesystems via ange-ftp. */);
2340 Vw32_downcase_file_names
= Qnil
;
2343 DEFVAR_LISP ("w32-generate-fake-inodes", Vw32_generate_fake_inodes
,
2344 doc
: /* Non-nil means attempt to fake realistic inode values.
2345 This works by hashing the truename of files, and should detect
2346 aliasing between long and short (8.3 DOS) names, but can have
2347 false positives because of hash collisions. Note that determining
2348 the truename of a file can be slow. */);
2349 Vw32_generate_fake_inodes
= Qnil
;
2352 DEFVAR_LISP ("w32-get-true-file-attributes", Vw32_get_true_file_attributes
,
2353 doc
: /* Non-nil means determine accurate file attributes in `file-attributes'.
2354 This option controls whether to issue additional system calls to determine
2355 accurate link counts, file type, and ownership information. It is more
2356 useful for files on NTFS volumes, where hard links and file security are
2357 supported, than on volumes of the FAT family.
2359 Without these system calls, link count will always be reported as 1 and file
2360 ownership will be attributed to the current user.
2361 The default value `local' means only issue these system calls for files
2362 on local fixed drives. A value of nil means never issue them.
2363 Any other non-nil value means do this even on remote and removable drives
2364 where the performance impact may be noticeable even on modern hardware. */);
2365 Vw32_get_true_file_attributes
= Qlocal
;
2367 staticpro (&Vw32_valid_locale_ids
);
2368 staticpro (&Vw32_valid_codepages
);
2370 /* end of w32proc.c */