|
611
|
1 ;;; win32-native.el --- Lisp routines when running on native MS Windows.
|
|
442
|
2
|
|
|
3 ;; Copyright (C) 1994 Free Software Foundation, Inc.
|
|
|
4 ;; Copyright (C) 2000 Ben Wing.
|
|
|
5
|
|
|
6 ;; Maintainer: XEmacs Development Team
|
|
|
7 ;; Keywords: mouse, dumped
|
|
|
8
|
|
|
9 ;; This file is part of XEmacs.
|
|
|
10
|
|
|
11 ;; XEmacs is free software; you can redistribute it and/or modify it
|
|
|
12 ;; under the terms of the GNU General Public License as published by
|
|
|
13 ;; the Free Software Foundation; either version 2, or (at your option)
|
|
|
14 ;; any later version.
|
|
|
15
|
|
|
16 ;; XEmacs is distributed in the hope that it will be useful, but
|
|
|
17 ;; WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
|
18 ;; MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
|
|
|
19 ;; General Public License for more details.
|
|
|
20
|
|
|
21 ;; You should have received a copy of the GNU General Public License
|
|
|
22 ;; along with XEmacs; see the file COPYING. If not, write to the
|
|
|
23 ;; Free Software Foundation, 59 Temple Place - Suite 330,
|
|
|
24 ;; Boston, MA 02111-1307, USA.
|
|
|
25
|
|
611
|
26 ;;; Synched up with: Not in FSF.
|
|
442
|
27 ;;; (FSF has stuff in w32-fns.el and term/w32-win.el.)
|
|
|
28
|
|
|
29 ;;; Commentary:
|
|
|
30
|
|
|
31 ;; This file is dumped with XEmacs for MS Windows (without cygwin).
|
|
611
|
32 ;; It is for stuff that is used specifically when `system-type' eq
|
|
|
33 ;; `windows-nt' (i.e. also applies to MinGW), and has nothing to do
|
|
|
34 ;; with the `mswindows' device type. Thus, it probably applies in
|
|
|
35 ;; non-interactive mode as well, and it DOES NOT APPLY to Cygwin.
|
|
442
|
36
|
|
611
|
37 ;; Based (originally) on NT Emacs version by Geoff Voelker
|
|
|
38 ;; (voelker@cs.washington.edu)
|
|
442
|
39 ;; Ported to XEmacs by Marc Paquette <marcpa@cam.org>
|
|
|
40 ;; Largely modified by Kirill M. Katsnelson <kkm@kis.ru>
|
|
611
|
41 ;; Rewritten from scratch by Ben Wing <ben@xemacs.org>. No code in common
|
|
|
42 ;; with FSF.
|
|
442
|
43
|
|
|
44 ;;; Code:
|
|
|
45
|
|
|
46 ;; For appending suffixes to directories and files in shell
|
|
|
47 ;; completions. This screws up cygwin users so we leave it out for
|
|
|
48 ;; now. Uncomment this if you only ever want to use cmd.
|
|
|
49
|
|
|
50 ;(defun nt-shell-mode-hook ()
|
|
|
51 ; (setq comint-completion-addsuffix '("\\" . " ")
|
|
|
52 ; comint-process-echoes t))
|
|
|
53 ;(add-hook 'shell-mode-hook 'nt-shell-mode-hook)
|
|
|
54
|
|
|
55 ;; Use ";" instead of ":" as a path separator (from files.el).
|
|
|
56 (setq path-separator ";")
|
|
|
57
|
|
|
58 ;; Set the grep regexp to match entries with drive letters.
|
|
776
|
59 (defvar grep-regexp-alist)
|
|
442
|
60 (setq grep-regexp-alist
|
|
|
61 '(("^\\(\\([a-zA-Z]:\\)?[^:( \t\n]+\\)[:( \t]+\\([0-9]+\\)[:) \t]" 1 3)))
|
|
|
62
|
|
611
|
63 (defvar mswindows-system-shells '("cmd" "cmd.exe" "command" "command.com"
|
|
|
64 "4nt" "4nt.exe" "4dos" "4dos.exe"
|
|
|
65 "ndos" "ndos.exe")
|
|
|
66 "List of strings recognized as Windows NT/9X system shells.
|
|
|
67 These are shells with native semantics, e.g. they use `/c', not '-c',
|
|
|
68 to pass a command in.")
|
|
|
69
|
|
|
70 (defun mswindows-system-shell-p (shell-name)
|
|
|
71 (member (downcase (file-name-nondirectory shell-name))
|
|
|
72 mswindows-system-shells))
|
|
|
73
|
|
|
74 (defun init-mswindows-at-startup ()
|
|
|
75 ;; shell-file-name is initialized in the C code (callproc.c) from
|
|
|
76 ;; SHELL or COMSPEC.
|
|
|
77 ;; #### If only shell-command-switch could be a function. But there
|
|
|
78 ;; is code littered around that uses it.
|
|
|
79 ;; #### Maybe we should set a symbol-value handler on `shell-file-name'
|
|
|
80 ;; that automatically sets shell-command-switch?
|
|
|
81 (if (mswindows-system-shell-p shell-file-name)
|
|
|
82 (setq shell-command-switch "/c")))
|
|
|
83
|
|
442
|
84 ;;----------------------------------------------------------------------
|
|
|
85 ;; Quoting process args
|
|
|
86 ;;--------------------
|
|
|
87
|
|
|
88 (defvar debug-mswindows-process-command-lines nil
|
|
|
89 "If non-nil, output debug information about the command lines constructed.
|
|
|
90 This can be useful if you are getting process errors where the arguments
|
|
|
91 to the process appear to be getting passed incorrectly.")
|
|
|
92
|
|
|
93 ;; properly quotify one arg for the vc runtime argv constructor.
|
|
|
94 (defun mswindows-quote-one-vc-runtime-arg (arg &optional quote-shell)
|
|
|
95 ;; we mess with any arg with whitespace, quotes, or globbing chars in it.
|
|
|
96 ;; we also include shell metachars if asked.
|
|
|
97 ;; note that \ is NOT included! it's perfectly OK to include an
|
|
|
98 ;; arg like c:\ or c:\foo.
|
|
611
|
99 (cond ((equal arg "") "\"\"")
|
|
|
100 ((string-match
|
|
|
101 (if quote-shell "[ \t\n\r\f*?\"<>|&^%]" "[ \t\n\r\f*?\"]")
|
|
|
102 arg)
|
|
|
103 ;; handle nested quotes, possibly preceded by backslashes
|
|
|
104 (setq arg (replace-in-string arg "\\([\\]*\\)\"" "\\1\\1\\\\\""))
|
|
|
105 ;; handle trailing backslashes
|
|
|
106 (setq arg (replace-in-string arg "\\([\\]+\\)$" "\\1\\1"))
|
|
|
107 (concat "\"" arg "\""))
|
|
|
108 (t arg)))
|
|
442
|
109
|
|
|
110 (defun mswindows-quote-one-simple-arg (arg &optional quote-shell)
|
|
|
111 ;; just put double quotes around args with spaces (and maybe shell
|
|
|
112 ;; metachars).
|
|
611
|
113 (cond ((equal arg "") "\"\"")
|
|
|
114 ((string-match
|
|
|
115 (if quote-shell "[ \t\n\r\f*?\"<>|&^%]" "[ \t\n\r\f*?]")
|
|
|
116 arg)
|
|
|
117 (concat "\"" arg "\""))
|
|
|
118 (t arg)))
|
|
442
|
119
|
|
|
120 (defun mswindows-quote-one-command-arg (arg)
|
|
|
121 ;; quote an arg to get it past COMMAND.COM/CMD.EXE: need to quote shell
|
|
|
122 ;; metachars with ^.
|
|
611
|
123 (cond ((equal arg "") "\"\"")
|
|
|
124 (t (replace-in-string "[<>|&^%]" "^\\1" arg))))
|
|
442
|
125
|
|
|
126 (defun mswindows-construct-verbatim-command-line (program args)
|
|
|
127 (mapconcat #'identity args " "))
|
|
|
128
|
|
|
129 ;; for use with either standard VC++ compiled programs or Cygwin programs,
|
|
|
130 ;; which emulate the same behavior.
|
|
|
131 (defun mswindows-construct-vc-runtime-command-line (program args)
|
|
|
132 (mapconcat #'mswindows-quote-one-vc-runtime-arg args " "))
|
|
|
133
|
|
|
134 ;; note: for pulling apart an arg:
|
|
|
135 ;; each arg consists of either
|
|
|
136
|
|
|
137 ;; something surrounded by single quotes
|
|
|
138
|
|
|
139 ;; or
|
|
|
140
|
|
|
141 ;; one or more of
|
|
|
142
|
|
|
143 ;; 1. a non-ws, non-" char
|
|
|
144 ;; 2. a section of double-quoted text
|
|
|
145 ;; 3. a section of double-quoted text with end-of-string instead of the final
|
|
|
146 ;; quote.
|
|
|
147
|
|
|
148 ;; 2 and 3 get handled together.
|
|
|
149
|
|
|
150 ;; quoted text is one of
|
|
|
151 ;;
|
|
|
152 ;; 1. quote + even number of backslashes + quote, or
|
|
|
153 ;; 2. quote + non-greedy anything + non-backslash + even number of
|
|
|
154 ;; backslashes + quote.
|
|
|
155
|
|
|
156 ;; we need to separate the two because we unfortunately have no non-greedy
|
|
|
157 ;; ? operator. (urk! we actually do, but it wasn't documented.) --ben
|
|
|
158
|
|
|
159 ;; if you want to mess around, keep this test case in mind:
|
|
|
160
|
|
|
161 ;; this string
|
|
|
162
|
|
|
163 ;; " as'f 'FOO BAR' '' \"\" \"asdf \\ \\\" \\\\\\\" asdfasdf\\\\\" foo\" "
|
|
|
164
|
|
|
165 ;; should tokenize into this:
|
|
|
166
|
|
|
167 ;; (" " "as'f" " " "'FOO BAR' " "'' " "\"\"" " " "\"asdf \\ \\\" \\\\\\\" asdfasdf\\\\\"" " " "foo" "\" ")
|
|
|
168
|
|
|
169 ;; this regexp actually separates the arg into individual args, like a
|
|
|
170 ;; shell (such as sh) does, but using vc-runtime rules. it's easy to
|
|
|
171 ;; derive the tokenizing regexp from it, and that's exactly what i did.
|
|
|
172 ;; but oh was it hard to get this first regexp right. --ben
|
|
|
173 ;(defvar mswindows-match-one-cmd-exe-arg-regexp
|
|
|
174 ; (concat
|
|
|
175 ; "^\\("
|
|
|
176 ; "'\\([\\]*\\)\\2'" "\\|"
|
|
|
177 ; "'.*?[^\\]\\(\\([\\]*\\)\\4'\\)" "\\|"
|
|
|
178 ; "\\("
|
|
|
179 ; "[^ \t\n\r\f\v\"]" "\\|"
|
|
|
180 ; "\"\\([\\]*\\)\\6\"" "\\|"
|
|
|
181 ; "\".*?[^\\]\\(\\([\\]*\\)\\8\"\\|$\\)"
|
|
|
182 ; "\\)+"
|
|
|
183 ; "\\)"
|
|
|
184 ; "\\([ \t\n\r\f\v]+\\|$\\)"))
|
|
|
185
|
|
|
186 (defvar mswindows-match-one-cmd-exe-token-regexp
|
|
|
187 (concat
|
|
|
188 "^\\("
|
|
|
189 "[ \t\n\r\f\v]+" "\\|"
|
|
|
190 "'\\([\\]*\\)\\2'" "\\([ \t\n\r\f\v]+\\|$\\)" "\\|"
|
|
|
191 "'.*?[^\\]\\(\\([\\]*\\)\\5'\\)" "\\([ \t\n\r\f\v]+\\|$\\)" "\\|"
|
|
|
192 "[^ \t\n\r\f\v\"]+" "\\|"
|
|
|
193 "\"\\([\\]*\\)\\7\"" "\\|"
|
|
|
194 "\".*?[^\\]\\(\\([\\]*\\)\\9\"\\|$\\)"
|
|
|
195 "\\)"))
|
|
|
196
|
|
|
197 (defun mswindows-construct-command-command-line (program args)
|
|
|
198 ;; for use with COMMAND.COM and CMD.EXE:
|
|
|
199 ;; for each arg, tokenize it into quoted and non-quoted sections;
|
|
|
200 ;; then quote all the shell meta-chars with ^; then put everything
|
|
|
201 ;; back together. the truly hard part is the tokenizing -- typically
|
|
|
202 ;; we get a single argument (the command to execute) and we have to
|
|
|
203 ;; worry about quotes that are backslash-quoted and such.
|
|
|
204 (mapconcat
|
|
|
205 #'(lambda (arg)
|
|
|
206 (mapconcat
|
|
|
207 #'(lambda (part)
|
|
|
208 (if (string-match "^'" part)
|
|
|
209 (replace-in-string part "\\([<>|^&%]\\)" "^\\1")
|
|
|
210 part))
|
|
|
211 (let (parts)
|
|
|
212 (while (and (> (length arg) 0)
|
|
|
213 (string-match
|
|
|
214 mswindows-match-one-cmd-exe-token-regexp
|
|
|
215 arg))
|
|
|
216 (push (match-string 0 arg) parts)
|
|
|
217 (setq arg (substring arg (match-end 0))))
|
|
|
218 (if (> (length arg) 0)
|
|
|
219 (push arg parts))
|
|
|
220 (nreverse parts))
|
|
|
221 ""))
|
|
|
222 args " "))
|
|
|
223
|
|
|
224 (defvar mswindows-construct-process-command-line-alist
|
|
611
|
225 '(
|
|
|
226 ;; at one point (pre-1.0), this was required for Cygwin bash.
|
|
|
227 ;; evidently, Cygwin changed its arg handling to work just like
|
|
|
228 ;; any standard VC program, so we no longer need it.
|
|
|
229 ;;("[\\/].?.?sh\\." . mswindows-construct-verbatim-command-line)
|
|
442
|
230 ("[\\/]command\\.com$" . mswindows-construct-command-command-line)
|
|
|
231 ("[\\/]cmd\\.exe$" . mswindows-construct-command-command-line)
|
|
|
232 ("" . mswindows-construct-vc-runtime-command-line))
|
|
|
233 "An alist for determining proper argument quoting given executable
|
|
|
234 file name. Car of each cons should be a string, a regexp against
|
|
|
235 which the file name is matched. Matching is case-insensitive but does
|
|
|
236 include the directory, so you should begin your regexp with [\\\\/] if
|
|
|
237 you don't want the directory to matter. Alternatively, the car can be
|
|
|
238 a function of one arg, which is called with the executable's name and
|
|
|
239 should return t if this entry should be processed. Cdr is a function
|
|
|
240 symbol, which is called with two args, the executable name and a list
|
|
|
241 of the args passed to it. It should return a string, which includes
|
|
|
242 the executable's args (but not the executable name itself) properly
|
|
|
243 quoted and pasted together. The list is matched in order, and the
|
|
|
244 first matching entry specifies how the processing will happen.")
|
|
|
245
|
|
|
246 (defun mswindows-construct-process-command-line (args)
|
|
|
247 ;;Properly quote process ARGS for executing (car ARGS).
|
|
|
248 ;;Called from the C code.
|
|
|
249 (let ((fname (car args))
|
|
|
250 (alist mswindows-construct-process-command-line-alist)
|
|
|
251 (case-fold-search t)
|
|
|
252 (return-me nil)
|
|
|
253 (assoc nil))
|
|
|
254 (while (and alist
|
|
|
255 (null return-me))
|
|
|
256 (setq assoc (pop alist))
|
|
|
257 (if (if (stringp (car assoc))
|
|
|
258 (string-match (car assoc) fname)
|
|
|
259 (funcall (car assoc) fname))
|
|
|
260 (setq return-me (cdr assoc))))
|
|
|
261 (let* ((called-fun (or return-me
|
|
|
262 #'mswindows-construct-vc-runtime-command-line))
|
|
|
263 (retval
|
|
|
264 (let ((str (funcall called-fun fname (cdr args)))
|
|
|
265 (quoted-fname (mswindows-quote-one-simple-arg fname)))
|
|
|
266 (if (and str (> (length str) 0))
|
|
|
267 (concat quoted-fname " " str)
|
|
|
268 quoted-fname))))
|
|
|
269 (when debug-mswindows-process-command-lines
|
|
|
270 (debug-print "mswindows-construct-process-command-line called:\n")
|
|
|
271 (debug-print "received args: \n%s"
|
|
|
272 (let ((n -1))
|
|
|
273 (mapconcat #'(lambda (arg)
|
|
|
274 (incf n)
|
|
|
275 (format " %d %s\n" n arg))
|
|
|
276 args
|
|
|
277 "")))
|
|
|
278 (debug-print "called fun %s\n" called-fun)
|
|
|
279 (debug-print "resulting command line: %s\n" retval))
|
|
|
280 retval)))
|
|
|
281
|
|
|
282 ;;; win32-native.el ends here
|
