1 /* Process support for GNU Emacs on the Microsoft W32 API.
2 Copyright (C) 1992, 1995 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 2, or (at your option)
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; see the file COPYING. If not, write to
18 the Free Software Foundation, Inc., 59 Temple Place - Suite 330,
19 Boston, MA 02111-1307, USA.
21 Drew Bliss Oct 14, 1993
22 Adapted from alarm.c by Tim Fleehart
32 /* must include CRT headers *before* config.h */
50 /* Control whether spawnve quotes arguments as necessary to ensure
51 correct parsing by child process. Because not all uses of spawnve
52 are careful about constructing argv arrays, we make this behaviour
53 conditional (off by default). */
54 Lisp_Object Vw32_quote_process_args
;
56 /* Control whether create_child causes the process' window to be
57 hidden. The default is nil. */
58 Lisp_Object Vw32_start_process_show_window
;
60 /* Control whether create_child causes the process to inherit Emacs'
61 console window, or be given a new one of its own. The default is
62 nil, to allow multiple DOS programs to run on Win95. Having separate
63 consoles also allows Emacs to cleanly terminate process groups. */
64 Lisp_Object Vw32_start_process_share_console
;
66 /* Time to sleep before reading from a subprocess output pipe - this
67 avoids the inefficiency of frequently reading small amounts of data.
68 This is primarily necessary for handling DOS processes on Windows 95,
69 but is useful for W32 processes on both Windows 95 and NT as well. */
70 Lisp_Object Vw32_pipe_read_delay
;
72 /* Control conversion of upper case file names to lower case.
73 nil means no, t means yes. */
74 Lisp_Object Vw32_downcase_file_names
;
76 /* Control whether stat() attempts to generate fake but hopefully
77 "accurate" inode values, by hashing the absolute truenames of files.
78 This should detect aliasing between long and short names, but still
79 allows the possibility of hash collisions. */
80 Lisp_Object Vw32_generate_fake_inodes
;
82 /* Control whether stat() attempts to determine file type and link count
83 exactly, at the expense of slower operation. Since true hard links
84 are supported on NTFS volumes, this is only relevant on NT. */
85 Lisp_Object Vw32_get_true_file_attributes
;
87 Lisp_Object Qhigh
, Qlow
;
89 #ifndef SYS_SIGLIST_DECLARED
90 extern char *sys_siglist
[];
94 void _DebPrint (const char *fmt
, ...)
100 vsprintf (buf
, fmt
, args
);
102 OutputDebugString (buf
);
106 typedef void (_CALLBACK_
*signal_handler
)(int);
108 /* Signal handlers...SIG_DFL == 0 so this is initialized correctly. */
109 static signal_handler sig_handlers
[NSIG
];
111 /* Fake signal implementation to record the SIGCHLD handler. */
113 sys_signal (int sig
, signal_handler handler
)
122 old
= sig_handlers
[sig
];
123 sig_handlers
[sig
] = handler
;
127 /* Defined in <process.h> which conflicts with the local copy */
130 /* Child process management list. */
131 int child_proc_count
= 0;
132 child_process child_procs
[ MAX_CHILDREN
];
133 child_process
*dead_child
= NULL
;
135 DWORD WINAPI
reader_thread (void *arg
);
137 /* Find an unused process slot. */
144 for (cp
= child_procs
+(child_proc_count
-1); cp
>= child_procs
; cp
--)
145 if (!CHILD_ACTIVE (cp
))
147 if (child_proc_count
== MAX_CHILDREN
)
149 cp
= &child_procs
[child_proc_count
++];
152 memset (cp
, 0, sizeof(*cp
));
155 cp
->procinfo
.hProcess
= NULL
;
156 cp
->status
= STATUS_READ_ERROR
;
158 /* use manual reset event so that select() will function properly */
159 cp
->char_avail
= CreateEvent (NULL
, TRUE
, FALSE
, NULL
);
162 cp
->char_consumed
= CreateEvent (NULL
, FALSE
, FALSE
, NULL
);
163 if (cp
->char_consumed
)
165 cp
->thrd
= CreateThread (NULL
, 1024, reader_thread
, cp
, 0, &id
);
175 delete_child (child_process
*cp
)
179 /* Should not be deleting a child that is still needed. */
180 for (i
= 0; i
< MAXDESC
; i
++)
181 if (fd_info
[i
].cp
== cp
)
184 if (!CHILD_ACTIVE (cp
))
187 /* reap thread if necessary */
192 if (GetExitCodeThread (cp
->thrd
, &rc
) && rc
== STILL_ACTIVE
)
194 /* let the thread exit cleanly if possible */
195 cp
->status
= STATUS_READ_ERROR
;
196 SetEvent (cp
->char_consumed
);
197 if (WaitForSingleObject (cp
->thrd
, 1000) != WAIT_OBJECT_0
)
199 DebPrint (("delete_child.WaitForSingleObject (thread) failed "
200 "with %lu for fd %ld\n", GetLastError (), cp
->fd
));
201 TerminateThread (cp
->thrd
, 0);
204 CloseHandle (cp
->thrd
);
209 CloseHandle (cp
->char_avail
);
210 cp
->char_avail
= NULL
;
212 if (cp
->char_consumed
)
214 CloseHandle (cp
->char_consumed
);
215 cp
->char_consumed
= NULL
;
218 /* update child_proc_count (highest numbered slot in use plus one) */
219 if (cp
== child_procs
+ child_proc_count
- 1)
221 for (i
= child_proc_count
-1; i
>= 0; i
--)
222 if (CHILD_ACTIVE (&child_procs
[i
]))
224 child_proc_count
= i
+ 1;
229 child_proc_count
= 0;
232 /* Find a child by pid. */
233 static child_process
*
234 find_child_pid (DWORD pid
)
238 for (cp
= child_procs
+(child_proc_count
-1); cp
>= child_procs
; cp
--)
239 if (CHILD_ACTIVE (cp
) && pid
== cp
->pid
)
245 /* Thread proc for child process and socket reader threads. Each thread
246 is normally blocked until woken by select() to check for input by
247 reading one char. When the read completes, char_avail is signalled
248 to wake up the select emulator and the thread blocks itself again. */
250 reader_thread (void *arg
)
255 cp
= (child_process
*)arg
;
257 /* We have to wait for the go-ahead before we can start */
259 || WaitForSingleObject (cp
->char_consumed
, INFINITE
) != WAIT_OBJECT_0
)
266 rc
= _sys_read_ahead (cp
->fd
);
268 /* The name char_avail is a misnomer - it really just means the
269 read-ahead has completed, whether successfully or not. */
270 if (!SetEvent (cp
->char_avail
))
272 DebPrint (("reader_thread.SetEvent failed with %lu for fd %ld\n",
273 GetLastError (), cp
->fd
));
277 if (rc
== STATUS_READ_ERROR
)
280 /* If the read died, the child has died so let the thread die */
281 if (rc
== STATUS_READ_FAILED
)
284 /* Wait until our input is acknowledged before reading again */
285 if (WaitForSingleObject (cp
->char_consumed
, INFINITE
) != WAIT_OBJECT_0
)
287 DebPrint (("reader_thread.WaitForSingleObject failed with "
288 "%lu for fd %ld\n", GetLastError (), cp
->fd
));
295 /* To avoid Emacs changing directory, we just record here the directory
296 the new process should start in. This is set just before calling
297 sys_spawnve, and is not generally valid at any other time. */
298 static char * process_dir
;
301 create_child (char *exe
, char *cmdline
, char *env
,
302 int * pPid
, child_process
*cp
)
305 SECURITY_ATTRIBUTES sec_attrs
;
306 SECURITY_DESCRIPTOR sec_desc
;
307 char dir
[ MAXPATHLEN
];
309 if (cp
== NULL
) abort ();
311 memset (&start
, 0, sizeof (start
));
312 start
.cb
= sizeof (start
);
315 if (NILP (Vw32_start_process_show_window
))
316 start
.dwFlags
= STARTF_USESTDHANDLES
| STARTF_USESHOWWINDOW
;
318 start
.dwFlags
= STARTF_USESTDHANDLES
;
319 start
.wShowWindow
= SW_HIDE
;
321 start
.hStdInput
= GetStdHandle (STD_INPUT_HANDLE
);
322 start
.hStdOutput
= GetStdHandle (STD_OUTPUT_HANDLE
);
323 start
.hStdError
= GetStdHandle (STD_ERROR_HANDLE
);
324 #endif /* HAVE_NTGUI */
326 /* Explicitly specify no security */
327 if (!InitializeSecurityDescriptor (&sec_desc
, SECURITY_DESCRIPTOR_REVISION
))
329 if (!SetSecurityDescriptorDacl (&sec_desc
, TRUE
, NULL
, FALSE
))
331 sec_attrs
.nLength
= sizeof (sec_attrs
);
332 sec_attrs
.lpSecurityDescriptor
= &sec_desc
;
333 sec_attrs
.bInheritHandle
= FALSE
;
335 strcpy (dir
, process_dir
);
336 unixtodos_filename (dir
);
338 if (!CreateProcess (exe
, cmdline
, &sec_attrs
, NULL
, TRUE
,
339 (!NILP (Vw32_start_process_share_console
)
340 ? CREATE_NEW_PROCESS_GROUP
341 : CREATE_NEW_CONSOLE
),
343 &start
, &cp
->procinfo
))
346 cp
->pid
= (int) cp
->procinfo
.dwProcessId
;
348 /* Hack for Windows 95, which assigns large (ie negative) pids */
352 /* pid must fit in a Lisp_Int */
353 cp
->pid
= (cp
->pid
& VALMASK
);
360 DebPrint (("create_child.CreateProcess failed: %ld\n", GetLastError()););
364 /* create_child doesn't know what emacs' file handle will be for waiting
365 on output from the child, so we need to make this additional call
366 to register the handle with the process
367 This way the select emulator knows how to match file handles with
368 entries in child_procs. */
370 register_child (int pid
, int fd
)
374 cp
= find_child_pid (pid
);
377 DebPrint (("register_child unable to find pid %lu\n", pid
));
382 DebPrint (("register_child registered fd %d with pid %lu\n", fd
, pid
));
387 /* thread is initially blocked until select is called; set status so
388 that select will release thread */
389 cp
->status
= STATUS_READ_ACKNOWLEDGED
;
391 /* attach child_process to fd_info */
392 if (fd_info
[fd
].cp
!= NULL
)
394 DebPrint (("register_child: fd_info[%d] apparently in use!\n", fd
));
401 /* When a process dies its pipe will break so the reader thread will
402 signal failure to the select emulator.
403 The select emulator then calls this routine to clean up.
404 Since the thread signaled failure we can assume it is exiting. */
406 reap_subprocess (child_process
*cp
)
408 if (cp
->procinfo
.hProcess
)
410 /* Reap the process */
412 /* Process should have already died before we are called. */
413 if (WaitForSingleObject (cp
->procinfo
.hProcess
, 0) != WAIT_OBJECT_0
)
414 DebPrint (("reap_subprocess: child fpr fd %d has not died yet!", cp
->fd
));
416 CloseHandle (cp
->procinfo
.hProcess
);
417 cp
->procinfo
.hProcess
= NULL
;
418 CloseHandle (cp
->procinfo
.hThread
);
419 cp
->procinfo
.hThread
= NULL
;
422 /* For asynchronous children, the child_proc resources will be freed
423 when the last pipe read descriptor is closed; for synchronous
424 children, we must explicitly free the resources now because
425 register_child has not been called. */
430 /* Wait for any of our existing child processes to die
431 When it does, close its handle
432 Return the pid and fill in the status if non-NULL. */
435 sys_wait (int *status
)
437 DWORD active
, retval
;
440 child_process
*cp
, *cps
[MAX_CHILDREN
];
441 HANDLE wait_hnd
[MAX_CHILDREN
];
444 if (dead_child
!= NULL
)
446 /* We want to wait for a specific child */
447 wait_hnd
[nh
] = dead_child
->procinfo
.hProcess
;
448 cps
[nh
] = dead_child
;
449 if (!wait_hnd
[nh
]) abort ();
456 for (cp
= child_procs
+(child_proc_count
-1); cp
>= child_procs
; cp
--)
457 /* some child_procs might be sockets; ignore them */
458 if (CHILD_ACTIVE (cp
) && cp
->procinfo
.hProcess
)
460 wait_hnd
[nh
] = cp
->procinfo
.hProcess
;
468 /* Nothing to wait on, so fail */
475 /* Check for quit about once a second. */
477 active
= WaitForMultipleObjects (nh
, wait_hnd
, FALSE
, 1000);
478 } while (active
== WAIT_TIMEOUT
);
480 if (active
== WAIT_FAILED
)
485 else if (active
>= WAIT_OBJECT_0
486 && active
< WAIT_OBJECT_0
+MAXIMUM_WAIT_OBJECTS
)
488 active
-= WAIT_OBJECT_0
;
490 else if (active
>= WAIT_ABANDONED_0
491 && active
< WAIT_ABANDONED_0
+MAXIMUM_WAIT_OBJECTS
)
493 active
-= WAIT_ABANDONED_0
;
499 if (!GetExitCodeProcess (wait_hnd
[active
], &retval
))
501 DebPrint (("Wait.GetExitCodeProcess failed with %lu\n",
505 if (retval
== STILL_ACTIVE
)
507 /* Should never happen */
508 DebPrint (("Wait.WaitForMultipleObjects returned an active process\n"));
513 /* Massage the exit code from the process to match the format expected
514 by the WIFSTOPPED et al macros in syswait.h. Only WIFSIGNALED and
515 WIFEXITED are supported; WIFSTOPPED doesn't make sense under NT. */
517 if (retval
== STATUS_CONTROL_C_EXIT
)
525 DebPrint (("Wait signaled with process pid %d\n", cp
->pid
));
532 else if (synch_process_alive
)
534 synch_process_alive
= 0;
536 /* Report the status of the synchronous process. */
537 if (WIFEXITED (retval
))
538 synch_process_retcode
= WRETCODE (retval
);
539 else if (WIFSIGNALED (retval
))
541 int code
= WTERMSIG (retval
);
546 /* Suppress warning if the table has const char *. */
547 signame
= (char *) sys_siglist
[code
];
552 synch_process_death
= signame
;
555 reap_subprocess (cp
);
558 reap_subprocess (cp
);
564 w32_executable_type (char * filename
, int * is_dos_app
, int * is_cygnus_app
)
566 file_data executable
;
569 /* Default values in case we can't tell for sure. */
571 *is_cygnus_app
= FALSE
;
573 if (!open_input_file (&executable
, filename
))
576 p
= strrchr (filename
, '.');
578 /* We can only identify DOS .com programs from the extension. */
579 if (p
&& stricmp (p
, ".com") == 0)
581 else if (p
&& (stricmp (p
, ".bat") == 0
582 || stricmp (p
, ".cmd") == 0))
584 /* A DOS shell script - it appears that CreateProcess is happy to
585 accept this (somewhat surprisingly); presumably it looks at
586 COMSPEC to determine what executable to actually invoke.
587 Therefore, we have to do the same here as well. */
588 /* Actually, I think it uses the program association for that
589 extension, which is defined in the registry. */
590 p
= egetenv ("COMSPEC");
592 w32_executable_type (p
, is_dos_app
, is_cygnus_app
);
596 /* Look for DOS .exe signature - if found, we must also check that
597 it isn't really a 16- or 32-bit Windows exe, since both formats
598 start with a DOS program stub. Note that 16-bit Windows
599 executables use the OS/2 1.x format. */
601 IMAGE_DOS_HEADER
* dos_header
;
602 IMAGE_NT_HEADERS
* nt_header
;
604 dos_header
= (PIMAGE_DOS_HEADER
) executable
.file_base
;
605 if (dos_header
->e_magic
!= IMAGE_DOS_SIGNATURE
)
608 nt_header
= (PIMAGE_NT_HEADERS
) ((char *) dos_header
+ dos_header
->e_lfanew
);
610 if ((char *) nt_header
> (char *) dos_header
+ executable
.size
)
612 /* Some dos headers (pkunzip) have bogus e_lfanew fields. */
615 else if (nt_header
->Signature
!= IMAGE_NT_SIGNATURE
616 && LOWORD (nt_header
->Signature
) != IMAGE_OS2_SIGNATURE
)
620 else if (nt_header
->Signature
== IMAGE_NT_SIGNATURE
)
622 /* Look for cygwin.dll in DLL import list. */
623 IMAGE_DATA_DIRECTORY import_dir
=
624 nt_header
->OptionalHeader
.DataDirectory
[IMAGE_DIRECTORY_ENTRY_IMPORT
];
625 IMAGE_IMPORT_DESCRIPTOR
* imports
;
626 IMAGE_SECTION_HEADER
* section
;
628 section
= rva_to_section (import_dir
.VirtualAddress
, nt_header
);
629 imports
= RVA_TO_PTR (import_dir
.VirtualAddress
, section
, executable
);
631 for ( ; imports
->Name
; imports
++)
633 char * dllname
= RVA_TO_PTR (imports
->Name
, section
, executable
);
635 if (strcmp (dllname
, "cygwin.dll") == 0)
637 *is_cygnus_app
= TRUE
;
645 close_file_data (&executable
);
649 compare_env (const char **strp1
, const char **strp2
)
651 const char *str1
= *strp1
, *str2
= *strp2
;
653 while (*str1
&& *str2
&& *str1
!= '=' && *str2
!= '=')
655 if (tolower (*str1
) > tolower (*str2
))
657 else if (tolower (*str1
) < tolower (*str2
))
662 if (*str1
== '=' && *str2
== '=')
664 else if (*str1
== '=')
671 merge_and_sort_env (char **envp1
, char **envp2
, char **new_envp
)
687 qsort (new_envp
, num
, sizeof (char *), compare_env
);
692 /* When a new child process is created we need to register it in our list,
693 so intercept spawn requests. */
695 sys_spawnve (int mode
, char *cmdname
, char **argv
, char **envp
)
697 Lisp_Object program
, full
;
698 char *cmdline
, *env
, *parg
, **targ
;
702 int is_dos_app
, is_cygnus_app
;
705 /* We pass our process ID to our children by setting up an environment
706 variable in their environment. */
707 char ppid_env_var_buffer
[64];
708 char *extra_env
[] = {ppid_env_var_buffer
, NULL
};
710 /* We don't care about the other modes */
711 if (mode
!= _P_NOWAIT
)
717 /* Handle executable names without an executable suffix. */
718 program
= make_string (cmdname
, strlen (cmdname
));
719 if (NILP (Ffile_executable_p (program
)))
725 openp (Vexec_path
, program
, EXEC_SUFFIXES
, &full
, 1);
735 /* make sure argv[0] and cmdname are both in DOS format */
736 cmdname
= XSTRING (program
)->data
;
737 unixtodos_filename (cmdname
);
740 /* Determine whether program is a 16-bit DOS executable, or a w32
741 executable that is implicitly linked to the Cygnus dll (implying it
742 was compiled with the Cygnus GNU toolchain and hence relies on
743 cygwin.dll to parse the command line - we use this to decide how to
744 escape quote chars in command line args that must be quoted). */
745 w32_executable_type (cmdname
, &is_dos_app
, &is_cygnus_app
);
747 /* On Windows 95, if cmdname is a DOS app, we invoke a helper
748 application to start it by specifying the helper app as cmdname,
749 while leaving the real app name as argv[0]. */
752 cmdname
= alloca (MAXPATHLEN
);
753 if (egetenv ("CMDPROXY"))
754 strcpy (cmdname
, egetenv ("CMDPROXY"));
757 strcpy (cmdname
, XSTRING (Vinvocation_directory
)->data
);
758 strcat (cmdname
, "cmdproxy.exe");
760 unixtodos_filename (cmdname
);
763 /* we have to do some conjuring here to put argv and envp into the
764 form CreateProcess wants... argv needs to be a space separated/null
765 terminated list of parameters, and envp is a null
766 separated/double-null terminated list of parameters.
768 Additionally, zero-length args and args containing whitespace or
769 quote chars need to be wrapped in double quotes - for this to work,
770 embedded quotes need to be escaped as well. The aim is to ensure
771 the child process reconstructs the argv array we start with
772 exactly, so we treat quotes at the beginning and end of arguments
775 The w32 GNU-based library from Cygnus doubles quotes to escape
776 them, while MSVC uses backslash for escaping. (Actually the MSVC
777 startup code does attempt to recognise doubled quotes and accept
778 them, but gets it wrong and ends up requiring three quotes to get a
779 single embedded quote!) So by default we decide whether to use
780 quote or backslash as the escape character based on whether the
781 binary is apparently a Cygnus compiled app.
783 Note that using backslash to escape embedded quotes requires
784 additional special handling if an embedded quote is already
785 preceeded by backslash, or if an arg requiring quoting ends with
786 backslash. In such cases, the run of escape characters needs to be
787 doubled. For consistency, we apply this special handling as long
788 as the escape character is not quote.
790 Since we have no idea how large argv and envp are likely to be we
791 figure out list lengths on the fly and allocate them. */
793 if (!NILP (Vw32_quote_process_args
))
796 /* Override escape char by binding w32-quote-process-args to
797 desired character, or use t for auto-selection. */
798 if (INTEGERP (Vw32_quote_process_args
))
799 escape_char
= XINT (Vw32_quote_process_args
);
801 escape_char
= is_cygnus_app
? '"' : '\\';
811 int escape_char_run
= 0;
819 /* allow for embedded quotes to be escaped */
822 /* handle the case where the embedded quote is already escaped */
823 if (escape_char_run
> 0)
825 /* To preserve the arg exactly, we need to double the
826 preceding escape characters (plus adding one to
827 escape the quote character itself). */
828 arglen
+= escape_char_run
;
831 else if (*p
== ' ' || *p
== '\t')
836 if (*p
== escape_char
&& escape_char
!= '"')
844 /* handle the case where the arg ends with an escape char - we
845 must not let the enclosing quote be escaped. */
846 if (escape_char_run
> 0)
847 arglen
+= escape_char_run
;
849 arglen
+= strlen (*targ
++) + 1;
851 cmdline
= alloca (arglen
);
865 if (*p
== ' ' || *p
== '\t' || *p
== '"')
870 int escape_char_run
= 0;
876 last
= p
+ strlen (p
) - 1;
879 /* This version does not escape quotes if they occur at the
880 beginning or end of the arg - this could lead to incorrect
881 behaviour when the arg itself represents a command line
882 containing quoted args. I believe this was originally done
883 as a hack to make some things work, before
884 `w32-quote-process-args' was added. */
887 if (*p
== '"' && p
> first
&& p
< last
)
888 *parg
++ = escape_char
; /* escape embedded quotes */
896 /* double preceding escape chars if any */
897 while (escape_char_run
> 0)
899 *parg
++ = escape_char
;
902 /* escape all quote chars, even at beginning or end */
903 *parg
++ = escape_char
;
907 if (*p
== escape_char
&& escape_char
!= '"')
912 /* double escape chars before enclosing quote */
913 while (escape_char_run
> 0)
915 *parg
++ = escape_char
;
923 strcpy (parg
, *targ
);
924 parg
+= strlen (*targ
);
934 numenv
= 1; /* for end null */
937 arglen
+= strlen (*targ
++) + 1;
940 /* extra env vars... */
941 sprintf (ppid_env_var_buffer
, "__PARENT_PROCESS_ID=%d",
942 GetCurrentProcessId ());
943 arglen
+= strlen (ppid_env_var_buffer
) + 1;
946 /* merge env passed in and extra env into one, and sort it. */
947 targ
= (char **) alloca (numenv
* sizeof (char *));
948 merge_and_sort_env (envp
, extra_env
, targ
);
950 /* concatenate env entries. */
951 env
= alloca (arglen
);
955 strcpy (parg
, *targ
);
956 parg
+= strlen (*targ
++);
969 /* Now create the process. */
970 if (!create_child (cmdname
, cmdline
, env
, &pid
, cp
))
980 /* Emulate the select call
981 Wait for available input on any of the given rfds, or timeout if
982 a timeout is given and no input is detected
983 wfds and efds are not supported and must be NULL.
985 For simplicity, we detect the death of child processes here and
986 synchronously call the SIGCHLD handler. Since it is possible for
987 children to be created without a corresponding pipe handle from which
988 to read output, we wait separately on the process handles as well as
989 the char_avail events for each process pipe. We only call
990 wait/reap_process when the process actually terminates.
992 To reduce the number of places in which Emacs can be hung such that
993 C-g is not able to interrupt it, we always wait on interrupt_handle
994 (which is signalled by the input thread when C-g is detected). If we
995 detect that we were woken up by C-g, we return -1 with errno set to
999 extern HANDLE keyboard_handle
;
1001 /* From w32xfns.c */
1002 extern HANDLE interrupt_handle
;
1004 /* From process.c */
1005 extern int proc_buffered_char
[];
1008 sys_select (int nfds
, SELECT_TYPE
*rfds
, SELECT_TYPE
*wfds
, SELECT_TYPE
*efds
,
1009 EMACS_TIME
*timeout
)
1012 DWORD timeout_ms
, start_time
;
1015 child_process
*cp
, *cps
[MAX_CHILDREN
];
1016 HANDLE wait_hnd
[MAXDESC
+ MAX_CHILDREN
];
1017 int fdindex
[MAXDESC
]; /* mapping from wait handles back to descriptors */
1019 timeout_ms
= timeout
? (timeout
->tv_sec
* 1000 + timeout
->tv_usec
/ 1000) : INFINITE
;
1021 /* If the descriptor sets are NULL but timeout isn't, then just Sleep. */
1022 if (rfds
== NULL
&& wfds
== NULL
&& efds
== NULL
&& timeout
!= NULL
)
1028 /* Otherwise, we only handle rfds, so fail otherwise. */
1029 if (rfds
== NULL
|| wfds
!= NULL
|| efds
!= NULL
)
1039 /* Always wait on interrupt_handle, to detect C-g (quit). */
1040 wait_hnd
[0] = interrupt_handle
;
1043 /* Build a list of pipe handles to wait on. */
1045 for (i
= 0; i
< nfds
; i
++)
1046 if (FD_ISSET (i
, &orfds
))
1050 if (keyboard_handle
)
1052 /* Handle stdin specially */
1053 wait_hnd
[nh
] = keyboard_handle
;
1058 /* Check for any emacs-generated input in the queue since
1059 it won't be detected in the wait */
1060 if (detect_input_pending ())
1068 /* Child process and socket input */
1072 int current_status
= cp
->status
;
1074 if (current_status
== STATUS_READ_ACKNOWLEDGED
)
1076 /* Tell reader thread which file handle to use. */
1078 /* Wake up the reader thread for this process */
1079 cp
->status
= STATUS_READ_READY
;
1080 if (!SetEvent (cp
->char_consumed
))
1081 DebPrint (("nt_select.SetEvent failed with "
1082 "%lu for fd %ld\n", GetLastError (), i
));
1085 #ifdef CHECK_INTERLOCK
1086 /* slightly crude cross-checking of interlock between threads */
1088 current_status
= cp
->status
;
1089 if (WaitForSingleObject (cp
->char_avail
, 0) == WAIT_OBJECT_0
)
1091 /* char_avail has been signalled, so status (which may
1092 have changed) should indicate read has completed
1093 but has not been acknowledged. */
1094 current_status
= cp
->status
;
1095 if (current_status
!= STATUS_READ_SUCCEEDED
1096 && current_status
!= STATUS_READ_FAILED
)
1097 DebPrint (("char_avail set, but read not completed: status %d\n",
1102 /* char_avail has not been signalled, so status should
1103 indicate that read is in progress; small possibility
1104 that read has completed but event wasn't yet signalled
1105 when we tested it (because a context switch occurred
1106 or if running on separate CPUs). */
1107 if (current_status
!= STATUS_READ_READY
1108 && current_status
!= STATUS_READ_IN_PROGRESS
1109 && current_status
!= STATUS_READ_SUCCEEDED
1110 && current_status
!= STATUS_READ_FAILED
)
1111 DebPrint (("char_avail reset, but read status is bad: %d\n",
1115 wait_hnd
[nh
] = cp
->char_avail
;
1117 if (!wait_hnd
[nh
]) abort ();
1120 DebPrint (("select waiting on child %d fd %d\n",
1121 cp
-child_procs
, i
));
1126 /* Unable to find something to wait on for this fd, skip */
1128 /* Note that this is not a fatal error, and can in fact
1129 happen in unusual circumstances. Specifically, if
1130 sys_spawnve fails, eg. because the program doesn't
1131 exist, and debug-on-error is t so Fsignal invokes a
1132 nested input loop, then the process output pipe is
1133 still included in input_wait_mask with no child_proc
1134 associated with it. (It is removed when the debugger
1135 exits the nested input loop and the error is thrown.) */
1137 DebPrint (("sys_select: fd %ld is invalid! ignoring\n", i
));
1143 /* Add handles of child processes. */
1145 for (cp
= child_procs
+(child_proc_count
-1); cp
>= child_procs
; cp
--)
1146 /* Some child_procs might be sockets; ignore them. Also some
1147 children may have died already, but we haven't finished reading
1148 the process output; ignore them too. */
1149 if (CHILD_ACTIVE (cp
) && cp
->procinfo
.hProcess
1151 || (fd_info
[cp
->fd
].flags
& FILE_SEND_SIGCHLD
) == 0
1152 || (fd_info
[cp
->fd
].flags
& FILE_AT_EOF
) != 0)
1155 wait_hnd
[nh
+ nc
] = cp
->procinfo
.hProcess
;
1160 /* Nothing to look for, so we didn't find anything */
1168 /* Wait for input or child death to be signalled. */
1169 start_time
= GetTickCount ();
1170 active
= WaitForMultipleObjects (nh
+ nc
, wait_hnd
, FALSE
, timeout_ms
);
1172 if (active
== WAIT_FAILED
)
1174 DebPrint (("select.WaitForMultipleObjects (%d, %lu) failed with %lu\n",
1175 nh
+ nc
, timeout_ms
, GetLastError ()));
1176 /* don't return EBADF - this causes wait_reading_process_input to
1177 abort; WAIT_FAILED is returned when single-stepping under
1178 Windows 95 after switching thread focus in debugger, and
1179 possibly at other times. */
1183 else if (active
== WAIT_TIMEOUT
)
1187 else if (active
>= WAIT_OBJECT_0
1188 && active
< WAIT_OBJECT_0
+MAXIMUM_WAIT_OBJECTS
)
1190 active
-= WAIT_OBJECT_0
;
1192 else if (active
>= WAIT_ABANDONED_0
1193 && active
< WAIT_ABANDONED_0
+MAXIMUM_WAIT_OBJECTS
)
1195 active
-= WAIT_ABANDONED_0
;
1200 /* Loop over all handles after active (now officially documented as
1201 being the first signalled handle in the array). We do this to
1202 ensure fairness, so that all channels with data available will be
1203 processed - otherwise higher numbered channels could be starved. */
1208 cp
= cps
[active
- nh
];
1210 /* We cannot always signal SIGCHLD immediately; if we have not
1211 finished reading the process output, we must delay sending
1212 SIGCHLD until we do. */
1214 if (cp
->fd
>= 0 && (fd_info
[cp
->fd
].flags
& FILE_AT_EOF
) == 0)
1215 fd_info
[cp
->fd
].flags
|= FILE_SEND_SIGCHLD
;
1216 /* SIG_DFL for SIGCHLD is ignore */
1217 else if (sig_handlers
[SIGCHLD
] != SIG_DFL
&&
1218 sig_handlers
[SIGCHLD
] != SIG_IGN
)
1221 DebPrint (("select calling SIGCHLD handler for pid %d\n",
1225 sig_handlers
[SIGCHLD
] (SIGCHLD
);
1229 else if (fdindex
[active
] == -1)
1231 /* Quit (C-g) was detected. */
1235 else if (fdindex
[active
] == 0)
1237 /* Keyboard input available */
1243 /* must be a socket or pipe - read ahead should have
1244 completed, either succeeding or failing. */
1245 FD_SET (fdindex
[active
], rfds
);
1249 /* Even though wait_reading_process_output only reads from at most
1250 one channel, we must process all channels here so that we reap
1251 all children that have died. */
1252 while (++active
< nh
+ nc
)
1253 if (WaitForSingleObject (wait_hnd
[active
], 0) == WAIT_OBJECT_0
)
1255 } while (active
< nh
+ nc
);
1257 /* If no input has arrived and timeout hasn't expired, wait again. */
1260 DWORD elapsed
= GetTickCount () - start_time
;
1262 if (timeout_ms
> elapsed
) /* INFINITE is MAX_UINT */
1264 if (timeout_ms
!= INFINITE
)
1265 timeout_ms
-= elapsed
;
1266 goto count_children
;
1273 /* Substitute for certain kill () operations */
1275 static BOOL CALLBACK
1276 find_child_console (HWND hwnd
, child_process
* cp
)
1281 thread_id
= GetWindowThreadProcessId (hwnd
, &process_id
);
1282 if (process_id
== cp
->procinfo
.dwProcessId
)
1284 char window_class
[32];
1286 GetClassName (hwnd
, window_class
, sizeof (window_class
));
1287 if (strcmp (window_class
,
1288 (os_subtype
== OS_WIN95
)
1290 : "ConsoleWindowClass") == 0)
1301 sys_kill (int pid
, int sig
)
1305 int need_to_free
= 0;
1308 /* Only handle signals that will result in the process dying */
1309 if (sig
!= SIGINT
&& sig
!= SIGKILL
&& sig
!= SIGQUIT
&& sig
!= SIGHUP
)
1315 cp
= find_child_pid (pid
);
1318 proc_hand
= OpenProcess (PROCESS_TERMINATE
, 0, pid
);
1319 if (proc_hand
== NULL
)
1328 proc_hand
= cp
->procinfo
.hProcess
;
1329 pid
= cp
->procinfo
.dwProcessId
;
1331 /* Try to locate console window for process. */
1332 EnumWindows (find_child_console
, (LPARAM
) cp
);
1337 if (NILP (Vw32_start_process_share_console
) && cp
&& cp
->hwnd
)
1339 BYTE control_scan_code
= (BYTE
) MapVirtualKey (VK_CONTROL
, 0);
1340 BYTE vk_break_code
= VK_CANCEL
;
1341 BYTE break_scan_code
= (BYTE
) MapVirtualKey (vk_break_code
, 0);
1342 HWND foreground_window
;
1344 if (break_scan_code
== 0)
1346 /* Fake Ctrl-C if we can't manage Ctrl-Break. */
1347 vk_break_code
= 'C';
1348 break_scan_code
= (BYTE
) MapVirtualKey (vk_break_code
, 0);
1351 foreground_window
= GetForegroundWindow ();
1352 if (foreground_window
&& SetForegroundWindow (cp
->hwnd
))
1354 /* Generate keystrokes as if user had typed Ctrl-Break or Ctrl-C. */
1355 keybd_event (VK_CONTROL
, control_scan_code
, 0, 0);
1356 keybd_event (vk_break_code
, break_scan_code
, 0, 0);
1357 keybd_event (vk_break_code
, break_scan_code
, KEYEVENTF_KEYUP
, 0);
1358 keybd_event (VK_CONTROL
, control_scan_code
, KEYEVENTF_KEYUP
, 0);
1360 /* Sleep for a bit to give time for Emacs frame to respond
1361 to focus change events (if Emacs was active app). */
1364 SetForegroundWindow (foreground_window
);
1367 /* Ctrl-Break is NT equivalent of SIGINT. */
1368 else if (!GenerateConsoleCtrlEvent (CTRL_BREAK_EVENT
, pid
))
1370 DebPrint (("sys_kill.GenerateConsoleCtrlEvent return %d "
1371 "for pid %lu\n", GetLastError (), pid
));
1378 if (NILP (Vw32_start_process_share_console
) && cp
&& cp
->hwnd
)
1381 if (os_subtype
== OS_WIN95
)
1384 Another possibility is to try terminating the VDM out-right by
1385 calling the Shell VxD (id 0x17) V86 interface, function #4
1386 "SHELL_Destroy_VM", ie.
1392 First need to determine the current VM handle, and then arrange for
1393 the shellapi call to be made from the system vm (by using
1394 Switch_VM_and_callback).
1396 Could try to invoke DestroyVM through CallVxD.
1400 /* On Win95, posting WM_QUIT causes the 16-bit subsystem
1401 to hang when cmdproxy is used in conjunction with
1402 command.com for an interactive shell. Posting
1403 WM_CLOSE pops up a dialog that, when Yes is selected,
1404 does the same thing. TerminateProcess is also less
1405 than ideal in that subprocesses tend to stick around
1406 until the machine is shutdown, but at least it
1407 doesn't freeze the 16-bit subsystem. */
1408 PostMessage (cp
->hwnd
, WM_QUIT
, 0xff, 0);
1410 if (!TerminateProcess (proc_hand
, 0xff))
1412 DebPrint (("sys_kill.TerminateProcess returned %d "
1413 "for pid %lu\n", GetLastError (), pid
));
1420 PostMessage (cp
->hwnd
, WM_CLOSE
, 0, 0);
1422 /* Kill the process. On W32 this doesn't kill child processes
1423 so it doesn't work very well for shells which is why it's not
1424 used in every case. */
1425 else if (!TerminateProcess (proc_hand
, 0xff))
1427 DebPrint (("sys_kill.TerminateProcess returned %d "
1428 "for pid %lu\n", GetLastError (), pid
));
1435 CloseHandle (proc_hand
);
1440 /* extern int report_file_error (char *, Lisp_Object); */
1442 /* The following two routines are used to manipulate stdin, stdout, and
1443 stderr of our child processes.
1445 Assuming that in, out, and err are *not* inheritable, we make them
1446 stdin, stdout, and stderr of the child as follows:
1448 - Save the parent's current standard handles.
1449 - Set the std handles to inheritable duplicates of the ones being passed in.
1450 (Note that _get_osfhandle() is an io.h procedure that retrieves the
1451 NT file handle for a crt file descriptor.)
1452 - Spawn the child, which inherits in, out, and err as stdin,
1453 stdout, and stderr. (see Spawnve)
1454 - Close the std handles passed to the child.
1455 - Reset the parent's standard handles to the saved handles.
1456 (see reset_standard_handles)
1457 We assume that the caller closes in, out, and err after calling us. */
1460 prepare_standard_handles (int in
, int out
, int err
, HANDLE handles
[3])
1463 HANDLE newstdin
, newstdout
, newstderr
;
1465 parent
= GetCurrentProcess ();
1467 handles
[0] = GetStdHandle (STD_INPUT_HANDLE
);
1468 handles
[1] = GetStdHandle (STD_OUTPUT_HANDLE
);
1469 handles
[2] = GetStdHandle (STD_ERROR_HANDLE
);
1471 /* make inheritable copies of the new handles */
1472 if (!DuplicateHandle (parent
,
1473 (HANDLE
) _get_osfhandle (in
),
1478 DUPLICATE_SAME_ACCESS
))
1479 report_file_error ("Duplicating input handle for child", Qnil
);
1481 if (!DuplicateHandle (parent
,
1482 (HANDLE
) _get_osfhandle (out
),
1487 DUPLICATE_SAME_ACCESS
))
1488 report_file_error ("Duplicating output handle for child", Qnil
);
1490 if (!DuplicateHandle (parent
,
1491 (HANDLE
) _get_osfhandle (err
),
1496 DUPLICATE_SAME_ACCESS
))
1497 report_file_error ("Duplicating error handle for child", Qnil
);
1499 /* and store them as our std handles */
1500 if (!SetStdHandle (STD_INPUT_HANDLE
, newstdin
))
1501 report_file_error ("Changing stdin handle", Qnil
);
1503 if (!SetStdHandle (STD_OUTPUT_HANDLE
, newstdout
))
1504 report_file_error ("Changing stdout handle", Qnil
);
1506 if (!SetStdHandle (STD_ERROR_HANDLE
, newstderr
))
1507 report_file_error ("Changing stderr handle", Qnil
);
1511 reset_standard_handles (int in
, int out
, int err
, HANDLE handles
[3])
1513 /* close the duplicated handles passed to the child */
1514 CloseHandle (GetStdHandle (STD_INPUT_HANDLE
));
1515 CloseHandle (GetStdHandle (STD_OUTPUT_HANDLE
));
1516 CloseHandle (GetStdHandle (STD_ERROR_HANDLE
));
1518 /* now restore parent's saved std handles */
1519 SetStdHandle (STD_INPUT_HANDLE
, handles
[0]);
1520 SetStdHandle (STD_OUTPUT_HANDLE
, handles
[1]);
1521 SetStdHandle (STD_ERROR_HANDLE
, handles
[2]);
1525 set_process_dir (char * dir
)
1532 /* To avoid problems with winsock implementations that work over dial-up
1533 connections causing or requiring a connection to exist while Emacs is
1534 running, Emacs no longer automatically loads winsock on startup if it
1535 is present. Instead, it will be loaded when open-network-stream is
1538 To allow full control over when winsock is loaded, we provide these
1539 two functions to dynamically load and unload winsock. This allows
1540 dial-up users to only be connected when they actually need to use
1544 extern HANDLE winsock_lib
;
1545 extern BOOL
term_winsock (void);
1546 extern BOOL
init_winsock (int load_now
);
1548 extern Lisp_Object Vsystem_name
;
1550 DEFUN ("w32-has-winsock", Fw32_has_winsock
, Sw32_has_winsock
, 0, 1, 0,
1551 "Test for presence of the Windows socket library `winsock'.\n\
1552 Returns non-nil if winsock support is present, nil otherwise.\n\
1554 If the optional argument LOAD-NOW is non-nil, the winsock library is\n\
1555 also loaded immediately if not already loaded. If winsock is loaded,\n\
1556 the winsock local hostname is returned (since this may be different from\n\
1557 the value of `system-name' and should supplant it), otherwise t is\n\
1558 returned to indicate winsock support is present.")
1560 Lisp_Object load_now
;
1564 have_winsock
= init_winsock (!NILP (load_now
));
1567 if (winsock_lib
!= NULL
)
1569 /* Return new value for system-name. The best way to do this
1570 is to call init_system_name, saving and restoring the
1571 original value to avoid side-effects. */
1572 Lisp_Object orig_hostname
= Vsystem_name
;
1573 Lisp_Object hostname
;
1575 init_system_name ();
1576 hostname
= Vsystem_name
;
1577 Vsystem_name
= orig_hostname
;
1585 DEFUN ("w32-unload-winsock", Fw32_unload_winsock
, Sw32_unload_winsock
,
1587 "Unload the Windows socket library `winsock' if loaded.\n\
1588 This is provided to allow dial-up socket connections to be disconnected\n\
1589 when no longer needed. Returns nil without unloading winsock if any\n\
1590 socket connections still exist.")
1593 return term_winsock () ? Qt
: Qnil
;
1596 #endif /* HAVE_SOCKETS */
1599 /* Some miscellaneous functions that are Windows specific, but not GUI
1600 specific (ie. are applicable in terminal or batch mode as well). */
1602 /* lifted from fileio.c */
1603 #define CORRECT_DIR_SEPS(s) \
1604 do { if ('/' == DIRECTORY_SEP) dostounix_filename (s); \
1605 else unixtodos_filename (s); \
1608 DEFUN ("w32-short-file-name", Fw32_short_file_name
, Sw32_short_file_name
, 1, 1, 0,
1609 "Return the short file name version (8.3) of the full path of FILENAME.\n\
1610 If FILENAME does not exist, return nil.\n\
1611 All path elements in FILENAME are converted to their short names.")
1613 Lisp_Object filename
;
1615 char shortname
[MAX_PATH
];
1617 CHECK_STRING (filename
, 0);
1619 /* first expand it. */
1620 filename
= Fexpand_file_name (filename
, Qnil
);
1622 /* luckily, this returns the short version of each element in the path. */
1623 if (GetShortPathName (XSTRING (filename
)->data
, shortname
, MAX_PATH
) == 0)
1626 CORRECT_DIR_SEPS (shortname
);
1628 return build_string (shortname
);
1632 DEFUN ("w32-long-file-name", Fw32_long_file_name
, Sw32_long_file_name
,
1634 "Return the long file name version of the full path of FILENAME.\n\
1635 If FILENAME does not exist, return nil.\n\
1636 All path elements in FILENAME are converted to their long names.")
1638 Lisp_Object filename
;
1640 char longname
[ MAX_PATH
];
1642 CHECK_STRING (filename
, 0);
1644 /* first expand it. */
1645 filename
= Fexpand_file_name (filename
, Qnil
);
1647 if (!w32_get_long_filename (XSTRING (filename
)->data
, longname
, MAX_PATH
))
1650 CORRECT_DIR_SEPS (longname
);
1652 return build_string (longname
);
1655 DEFUN ("w32-set-process-priority", Fw32_set_process_priority
, Sw32_set_process_priority
,
1657 "Set the priority of PROCESS to PRIORITY.\n\
1658 If PROCESS is nil, the priority of Emacs is changed, otherwise the\n\
1659 priority of the process whose pid is PROCESS is changed.\n\
1660 PRIORITY should be one of the symbols high, normal, or low;\n\
1661 any other symbol will be interpreted as normal.\n\
1663 If successful, the return value is t, otherwise nil.")
1665 Lisp_Object process
, priority
;
1667 HANDLE proc_handle
= GetCurrentProcess ();
1668 DWORD priority_class
= NORMAL_PRIORITY_CLASS
;
1669 Lisp_Object result
= Qnil
;
1671 CHECK_SYMBOL (priority
, 0);
1673 if (!NILP (process
))
1678 CHECK_NUMBER (process
, 0);
1680 /* Allow pid to be an internally generated one, or one obtained
1681 externally. This is necessary because real pids on Win95 are
1684 pid
= XINT (process
);
1685 cp
= find_child_pid (pid
);
1687 pid
= cp
->procinfo
.dwProcessId
;
1689 proc_handle
= OpenProcess (PROCESS_SET_INFORMATION
, FALSE
, pid
);
1692 if (EQ (priority
, Qhigh
))
1693 priority_class
= HIGH_PRIORITY_CLASS
;
1694 else if (EQ (priority
, Qlow
))
1695 priority_class
= IDLE_PRIORITY_CLASS
;
1697 if (proc_handle
!= NULL
)
1699 if (SetPriorityClass (proc_handle
, priority_class
))
1701 if (!NILP (process
))
1702 CloseHandle (proc_handle
);
1709 DEFUN ("w32-get-locale-info", Fw32_get_locale_info
, Sw32_get_locale_info
, 1, 2, 0,
1710 "Return information about the Windows locale LCID.\n\
1711 By default, return a three letter locale code which encodes the default\n\
1712 language as the first two characters, and the country or regionial variant\n\
1713 as the third letter. For example, ENU refers to `English (United States)',\n\
1714 while ENC means `English (Canadian)'.\n\
1716 If the optional argument LONGFORM is non-nil, the long form of the locale\n\
1717 name is returned, e.g. `English (United States)' instead.\n\
1719 If LCID (a 16-bit number) is not a valid locale, the result is nil.")
1721 Lisp_Object lcid
, longform
;
1725 char abbrev_name
[32] = { 0 };
1726 char full_name
[256] = { 0 };
1728 CHECK_NUMBER (lcid
, 0);
1730 if (!IsValidLocale (XINT (lcid
), LCID_SUPPORTED
))
1733 if (NILP (longform
))
1735 got_abbrev
= GetLocaleInfo (XINT (lcid
),
1736 LOCALE_SABBREVLANGNAME
| LOCALE_USE_CP_ACP
,
1737 abbrev_name
, sizeof (abbrev_name
));
1739 return build_string (abbrev_name
);
1743 got_full
= GetLocaleInfo (XINT (lcid
),
1744 LOCALE_SLANGUAGE
| LOCALE_USE_CP_ACP
,
1745 full_name
, sizeof (full_name
));
1747 return build_string (full_name
);
1754 DEFUN ("w32-get-current-locale-id", Fw32_get_current_locale_id
, Sw32_get_current_locale_id
, 0, 0, 0,
1755 "Return Windows locale id for current locale setting.\n\
1756 This is a numerical value; use `w32-get-locale-info' to convert to a\n\
1757 human-readable form.")
1760 return make_number (GetThreadLocale ());
1763 DWORD
int_from_hex (char * s
)
1766 static char hex
[] = "0123456789abcdefABCDEF";
1769 while (*s
&& (p
= strchr(hex
, *s
)) != NULL
)
1771 unsigned digit
= p
- hex
;
1774 val
= val
* 16 + digit
;
1780 /* We need to build a global list, since the EnumSystemLocale callback
1781 function isn't given a context pointer. */
1782 Lisp_Object Vw32_valid_locale_ids
;
1784 BOOL CALLBACK
enum_locale_fn (LPTSTR localeNum
)
1786 DWORD id
= int_from_hex (localeNum
);
1787 Vw32_valid_locale_ids
= Fcons (make_number (id
), Vw32_valid_locale_ids
);
1791 DEFUN ("w32-get-valid-locale-ids", Fw32_get_valid_locale_ids
, Sw32_get_valid_locale_ids
, 0, 0, 0,
1792 "Return list of all valid Windows locale ids.\n\
1793 Each id is a numerical value; use `w32-get-locale-info' to convert to a\n\
1794 human-readable form.")
1797 Vw32_valid_locale_ids
= Qnil
;
1799 EnumSystemLocales (enum_locale_fn
, LCID_SUPPORTED
);
1801 Vw32_valid_locale_ids
= Fnreverse (Vw32_valid_locale_ids
);
1802 return Vw32_valid_locale_ids
;
1806 DEFUN ("w32-get-default-locale-id", Fw32_get_default_locale_id
, Sw32_get_default_locale_id
, 0, 1, 0,
1807 "Return Windows locale id for default locale setting.\n\
1808 By default, the system default locale setting is returned; if the optional\n\
1809 parameter USERP is non-nil, the user default locale setting is returned.\n\
1810 This is a numerical value; use `w32-get-locale-info' to convert to a\n\
1811 human-readable form.")
1816 return make_number (GetSystemDefaultLCID ());
1817 return make_number (GetUserDefaultLCID ());
1821 DEFUN ("w32-set-current-locale", Fw32_set_current_locale
, Sw32_set_current_locale
, 1, 1, 0,
1822 "Make Windows locale LCID be the current locale setting for Emacs.\n\
1823 If successful, the new locale id is returned, otherwise nil.")
1827 CHECK_NUMBER (lcid
, 0);
1829 if (!IsValidLocale (XINT (lcid
), LCID_SUPPORTED
))
1832 if (!SetThreadLocale (XINT (lcid
)))
1835 /* Need to set input thread locale if present. */
1836 if (dwWindowsThreadId
)
1837 /* Reply is not needed. */
1838 PostThreadMessage (dwWindowsThreadId
, WM_EMACS_SETLOCALE
, XINT (lcid
), 0);
1840 return make_number (GetThreadLocale ());
1846 Qhigh
= intern ("high");
1847 Qlow
= intern ("low");
1850 defsubr (&Sw32_has_winsock
);
1851 defsubr (&Sw32_unload_winsock
);
1853 defsubr (&Sw32_short_file_name
);
1854 defsubr (&Sw32_long_file_name
);
1855 defsubr (&Sw32_set_process_priority
);
1856 defsubr (&Sw32_get_locale_info
);
1857 defsubr (&Sw32_get_current_locale_id
);
1858 defsubr (&Sw32_get_default_locale_id
);
1859 defsubr (&Sw32_get_valid_locale_ids
);
1860 defsubr (&Sw32_set_current_locale
);
1862 DEFVAR_LISP ("w32-quote-process-args", &Vw32_quote_process_args
,
1863 "Non-nil enables quoting of process arguments to ensure correct parsing.\n\
1864 Because Windows does not directly pass argv arrays to child processes,\n\
1865 programs have to reconstruct the argv array by parsing the command\n\
1866 line string. For an argument to contain a space, it must be enclosed\n\
1867 in double quotes or it will be parsed as multiple arguments.\n\
1869 If the value is a character, that character will be used to escape any\n\
1870 quote characters that appear, otherwise a suitable escape character\n\
1871 will be chosen based on the type of the program.");
1872 Vw32_quote_process_args
= Qt
;
1874 DEFVAR_LISP ("w32-start-process-show-window",
1875 &Vw32_start_process_show_window
,
1876 "When nil, processes started via start-process hide their windows.\n\
1877 When non-nil, they show their window in the method of their choice.");
1878 Vw32_start_process_show_window
= Qnil
;
1880 DEFVAR_LISP ("w32-start-process-share-console",
1881 &Vw32_start_process_share_console
,
1882 "When nil, processes started via start-process are given a new console.\n\
1883 When non-nil, they share the Emacs console; this has the limitation of\n\
1884 allowing only only DOS subprocess to run at a time (whether started directly\n\
1885 or indirectly by Emacs), and preventing Emacs from cleanly terminating the\n\
1886 subprocess group, but may allow Emacs to interrupt a subprocess that doesn't\n\
1887 otherwise respond to interrupts from Emacs.");
1888 Vw32_start_process_share_console
= Qnil
;
1890 DEFVAR_INT ("w32-pipe-read-delay", &Vw32_pipe_read_delay
,
1891 "Forced delay before reading subprocess output.\n\
1892 This is done to improve the buffering of subprocess output, by\n\
1893 avoiding the inefficiency of frequently reading small amounts of data.\n\
1895 If positive, the value is the number of milliseconds to sleep before\n\
1896 reading the subprocess output. If negative, the magnitude is the number\n\
1897 of time slices to wait (effectively boosting the priority of the child\n\
1898 process temporarily). A value of zero disables waiting entirely.");
1899 Vw32_pipe_read_delay
= 50;
1901 DEFVAR_LISP ("w32-downcase-file-names", &Vw32_downcase_file_names
,
1902 "Non-nil means convert all-upper case file names to lower case.\n\
1903 This applies when performing completions and file name expansion.");
1904 Vw32_downcase_file_names
= Qnil
;
1907 DEFVAR_LISP ("w32-generate-fake-inodes", &Vw32_generate_fake_inodes
,
1908 "Non-nil means attempt to fake realistic inode values.\n\
1909 This works by hashing the truename of files, and should detect \n\
1910 aliasing between long and short (8.3 DOS) names, but can have\n\
1911 false positives because of hash collisions. Note that determing\n\
1912 the truename of a file can be slow.");
1913 Vw32_generate_fake_inodes
= Qnil
;
1916 DEFVAR_LISP ("w32-get-true-file-attributes", &Vw32_get_true_file_attributes
,
1917 "Non-nil means determine accurate link count in file-attributes.\n\
1918 This option slows down file-attributes noticeably, so is disabled by\n\
1919 default. Note that it is only useful for files on NTFS volumes,\n\
1920 where hard links are supported.");
1921 Vw32_get_true_file_attributes
= Qnil
;
1923 /* end of ntproc.c */