[bpt/emacs.git] / lisp / eshell / esh-ext.el

;;; esh-ext.el --- commands external to Eshell  -*- lexical-binding:t -*-

;; Copyright (C) 1999-2014 Free Software Foundation, Inc.

;; Author: John Wiegley <johnw@gnu.org>

;; This file is part of GNU Emacs.

;; GNU Emacs is free software: you can redistribute it and/or modify
;; it under the terms of the GNU General Public License as published by
;; the Free Software Foundation, either version 3 of the License, or
;; (at your option) any later version.

;; GNU Emacs is distributed in the hope that it will be useful,
;; but WITHOUT ANY WARRANTY; without even the implied warranty of
;; MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
;; GNU General Public License for more details.

;; You should have received a copy of the GNU General Public License
;; along with GNU Emacs.  If not, see <http://www.gnu.org/licenses/>.

;;; Commentary:

;; To force a command to invoked external, either provide an explicit
;; pathname for the command argument, or prefix the command name with
;; an asterix character.  Example:
;;
;;   grep        ; make invoke `grep' Lisp function, or `eshell/grep'
;;   /bin/grep   ; will definitely invoke /bin/grep
;;   *grep        ; will also invoke /bin/grep

;;; Code:

(provide 'esh-ext)

(require 'esh-util)

(eval-when-compile
  (require 'cl-lib)
  (require 'esh-io)
  (require 'esh-cmd))
(require 'esh-opt)

(defgroup eshell-ext nil
  "External commands are invoked when operating system executables are
loaded into memory, thus beginning a new process."
  :tag "External commands"
  :group 'eshell)

;;; User Variables:

(defcustom eshell-ext-load-hook nil
  "A hook that gets run when `eshell-ext' is loaded."
  :version "24.1"			; removed eshell-ext-initialize
  :type 'hook
  :group 'eshell-ext)

(defcustom eshell-binary-suffixes exec-suffixes
  "A list of suffixes used when searching for executable files."
  :type '(repeat string)
  :group 'eshell-ext)

(defcustom eshell-force-execution nil
  "If non-nil, try to execute binary files regardless of permissions.
This can be useful on systems like Windows, where the operating system
doesn't happen to honor the permission bits in certain cases; or in
cases where you want to associate an interpreter with a particular
kind of script file, but the language won't let you but a '#!'
interpreter line in the file, and you don't want to make it executable
since nothing else but Eshell will be able to understand
`eshell-interpreter-alist'."
  :type 'boolean
  :group 'eshell-ext)

(defun eshell-search-path (name)
  "Search the environment path for NAME."
  (if (file-name-absolute-p name)
      name
    (let ((list (eshell-parse-colon-path eshell-path-env))
	  suffixes n1 n2 file)
      (while list
	(setq n1 (concat (car list) name))
	(setq suffixes eshell-binary-suffixes)
	(while suffixes
	  (setq n2 (concat n1 (car suffixes)))
	  (if (and (or (file-executable-p n2)
		       (and eshell-force-execution
			    (file-readable-p n2)))
		   (not (file-directory-p n2)))
	      (setq file n2 suffixes nil list nil))
	  (setq suffixes (cdr suffixes)))
	(setq list (cdr list)))
      file)))

;; This file provides itself then eval-when-compile loads files that require it.
;; This causes spurious "might not be defined at runtime" warnings.
(declare-function eshell-search-path "esh-ext" (name))

(defcustom eshell-windows-shell-file
  (if (eshell-under-windows-p)
      (if (string-match "\\(cmdproxy\\|sh\\)\\.\\(com\\|exe\\)"
			shell-file-name)
	  (or (eshell-search-path "cmd.exe")
	      (eshell-search-path "command.com"))
	shell-file-name))
  "The name of the shell command to use for DOS/Windows batch files.
This defaults to nil on non-Windows systems, where this variable is
wholly ignored."
  :type '(choice file (const nil))
  :group 'eshell-ext)

(autoload 'eshell-parse-command "esh-cmd")

(defsubst eshell-invoke-batch-file (&rest args)
  "Invoke a .BAT or .CMD file on DOS/Windows systems."
  ;; since CMD.EXE can't handle forward slashes in the initial
  ;; argument...
  (setcar args (subst-char-in-string ?/ ?\\ (car args)))
  (throw 'eshell-replace-command
	 (eshell-parse-command
	  (eshell-quote-argument eshell-windows-shell-file)
	  (cons "/c" args))))

(defcustom eshell-interpreter-alist
  (if (eshell-under-windows-p)
      '(("\\.\\(bat\\|cmd\\)\\'" . eshell-invoke-batch-file)))
  "An alist defining interpreter substitutions.
Each member is a cons cell of the form:

  (MATCH . INTERPRETER)

MATCH should be a regexp, which is matched against the command
name, or a function of arity 2 receiving the COMMAND and its
ARGS (a list).  If either returns a non-nil value, then
INTERPRETER will be used for that command.

If INTERPRETER is a string, it will be called as the command name,
with the original command name passed as the first argument, with all
subsequent arguments following.  If INTERPRETER is a function, it will
be called with all of those arguments.  Note that interpreter
functions should throw `eshell-replace-command' with the alternate
command form, or they should return a value compatible with the
possible return values of `eshell-external-command', which see."
  :type '(repeat (cons (choice regexp (function :tag "Predicate"))
		       (choice string (function :tag "Interpreter"))))
  :group 'eshell-ext)

(defcustom eshell-alternate-command-hook nil
  "A hook run whenever external command lookup fails.
If a functions wishes to provide an alternate command, they must throw
it using the tag `eshell-replace-command'.  This is done because the
substituted command need not be external at all, and therefore must be
passed up to a higher level for re-evaluation.

Or, if the function returns a filename, that filename will be invoked
with the current command arguments rather than the command specified
by the user on the command line."
  :type 'hook
  :group 'eshell-ext)

(defcustom eshell-command-interpreter-max-length 256
  "The maximum length of any command interpreter string, plus args."
  :type 'integer
  :group 'eshell-ext)

(defcustom eshell-explicit-command-char ?*
  "If this char occurs before a command name, call it externally.
That is, although `vi' may be an alias, `\vi' will always call the
external version."
  :type 'character
  :group 'eshell-ext)

;;; Functions:

(defun eshell-ext-initialize ()
  "Initialize the external command handling code."
  (add-hook 'eshell-named-command-hook 'eshell-explicit-command nil t))

(defun eshell-explicit-command (command args)
  "If a command name begins with `*', call it externally always.
This bypasses all Lisp functions and aliases."
  (when (and (> (length command) 1)
	     (eq (aref command 0) eshell-explicit-command-char))
    (let ((cmd (eshell-search-path (substring command 1))))
      (if cmd
	  (or (eshell-external-command cmd args)
	      (error "%s: external command failed" cmd))
	(error "%s: external command not found"
	       (substring command 1))))))

(autoload 'eshell-close-handles "esh-io")

(defun eshell-remote-command (command args)
  "Insert output from a remote COMMAND, using ARGS.
A remote command is something that executes on a different machine.
An external command simply means external to Emacs.

Note that this function is very crude at the moment.  It gathers up
all the output from the remote command, and sends it all at once,
causing the user to wonder if anything's really going on..."
  (let ((outbuf (generate-new-buffer " *eshell remote output*"))
	(errbuf (generate-new-buffer " *eshell remote error*"))
	(command (or (file-remote-p command 'localname) command))
	(exitcode 1))
    (unwind-protect
	(progn
	  (setq exitcode
		(shell-command
		 (mapconcat 'shell-quote-argument
			    (append (list command) args) " ")
		 outbuf errbuf))
	  (eshell-print (with-current-buffer outbuf (buffer-string)))
	  (eshell-error (with-current-buffer errbuf (buffer-string))))
      (eshell-close-handles exitcode 'nil)
      (kill-buffer outbuf)
      (kill-buffer errbuf))))

(defun eshell-external-command (command args)
  "Insert output from an external COMMAND, using ARGS."
  (setq args (eshell-stringify-list (eshell-flatten-list args)))
  (let ((interp (eshell-find-interpreter
		 command
		 args
		 ;; `eshell-find-interpreter' does not work correctly
		 ;; for Tramp file name syntax.  But we don't need to
		 ;; know the interpreter in that case, therefore the
		 ;; check is suppressed.
		 (or (and (stringp command) (file-remote-p command))
		     (file-remote-p default-directory)))))
    (cl-assert interp)
    (if (functionp (car interp))
	(apply (car interp) (append (cdr interp) args))
      (eshell-gather-process-output
       (car interp) (append (cdr interp) args)))))

(defun eshell/addpath (&rest args)
  "Add a set of paths to PATH."
  (eshell-eval-using-options
   "addpath" args
   '((?b "begin" nil prepend "add path element at beginning")
     (?h "help" nil nil  "display this usage message")
     :usage "[-b] PATH
Adds the given PATH to $PATH.")
   (if args
       (progn
	 (setq eshell-path-env (getenv "PATH")
	       args (mapconcat 'identity args path-separator)
	       eshell-path-env
	       (if prepend
		   (concat args path-separator eshell-path-env)
		 (concat eshell-path-env path-separator args)))
	 (setenv "PATH" eshell-path-env))
     (dolist (dir (parse-colon-path (getenv "PATH")))
       (eshell-printn dir)))))

(put 'eshell/addpath 'eshell-no-numeric-conversions t)

(defun eshell-script-interpreter (file)
  "Extract the script to run from FILE, if it has #!<interp> in it.
Return nil, or a list of the form:

  (INTERPRETER [ARGS] FILE)"
  (let ((maxlen eshell-command-interpreter-max-length))
    (if (and (file-readable-p file)
	     (file-regular-p file))
	(with-temp-buffer
	  (insert-file-contents-literally file nil 0 maxlen)
	  (if (looking-at "#![ \t]*\\([^ \r\t\n]+\\)\\([ \t]+\\(.+\\)\\)?")
	      (if (match-string 3)
		  (list (match-string 1)
			(match-string 3)
			file)
		(list (match-string 1)
		      file)))))))

(defun eshell-find-interpreter (file args &optional no-examine-p)
  "Find the command interpreter with which to execute FILE.
If NO-EXAMINE-P is non-nil, FILE will not be inspected for a script
line of the form #!<interp>."
  (let ((finterp
	 (catch 'found
	   (ignore
	    (dolist (possible eshell-interpreter-alist)
	      (cond
	       ((functionp (car possible))
		(let ((fn (car possible)))
		  (and (funcall fn file args)
		       (throw 'found (cdr possible)))))
	       ((stringp (car possible))
		(and (string-match (car possible) file)
		     (throw 'found (cdr possible))))
	       (t
		(error "Invalid interpreter-alist test"))))))))
    (if finterp                         ; first check
	(list finterp file)
      (let ((fullname (if (file-name-directory file) file
			(eshell-search-path file)))
	    (suffixes eshell-binary-suffixes))
	(if (and fullname (not (or eshell-force-execution
				   (file-executable-p fullname))))
	    (while suffixes
	      (let ((try (concat fullname (car suffixes))))
		(if (or (file-executable-p try)
			(and eshell-force-execution
			     (file-readable-p try)))
		    (setq fullname try suffixes nil)
		  (setq suffixes (cdr suffixes))))))
	(cond ((not (and fullname (file-exists-p fullname)))
	       (let ((name (or fullname file)))
		 (unless (setq fullname
			       (run-hook-with-args-until-success
				'eshell-alternate-command-hook file))
		   (error "%s: command not found" name))))
	      ((not (or eshell-force-execution
			(file-executable-p fullname)))
	       (error "%s: Permission denied" fullname)))
	(let (interp)
	  (unless no-examine-p
	    (setq interp (eshell-script-interpreter fullname))
	    (if interp
		(setq interp
		      (cons (car (eshell-find-interpreter (car interp) args t))
			    (cdr interp)))))
	  (or interp (list fullname)))))))

;;; esh-ext.el ends here
Commit	Line	Data
ae5e4c48	1	;;; esh-ext.el --- commands external to Eshell -- lexical-binding:t --
affbf647	2
ba318903	3	;; Copyright (C) 1999-2014 Free Software Foundation, Inc.
affbf647	4
7de5b421 GM	5	;; Author: John Wiegley <johnw@gnu.org>
7de5b421 GM	6
affbf647 GM	7	;; This file is part of GNU Emacs.
affbf647 GM	8
4ee57b2a	9	;; GNU Emacs is free software: you can redistribute it and/or modify
affbf647	10	;; it under the terms of the GNU General Public License as published by
4ee57b2a GM	11	;; the Free Software Foundation, either version 3 of the License, or
4ee57b2a GM	12	;; (at your option) any later version.
affbf647 GM	13
	14	;; GNU Emacs is distributed in the hope that it will be useful,
	15	;; but WITHOUT ANY WARRANTY; without even the implied warranty of
	16	;; MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
	17	;; GNU General Public License for more details.
	18
	19	;; You should have received a copy of the GNU General Public License
4ee57b2a	20	;; along with GNU Emacs. If not, see <http://www.gnu.org/licenses/>.
affbf647	21
affbf647 GM	22	;;; Commentary:
	23
	24	;; To force a command to invoked external, either provide an explicit
	25	;; pathname for the command argument, or prefix the command name with
	26	;; an asterix character. Example:
	27	;;
	28	;; grep ; make invoke `grep' Lisp function, or `eshell/grep'
	29	;; /bin/grep ; will definitely invoke /bin/grep
	30	;; *grep ; will also invoke /bin/grep
	31
8c7309fe GM	32	;;; Code:
8c7309fe GM	33
4e6cc05c GM	34	(provide 'esh-ext)
4e6cc05c GM	35
f87b1284 GM	36	(require 'esh-util)
f87b1284 GM	37
4e6cc05c	38	(eval-when-compile
a464a6c7	39	(require 'cl-lib)
f87b1284	40	(require 'esh-io)
4e6cc05c	41	(require 'esh-cmd))
a464a6c7	42	(require 'esh-opt)
4e6cc05c GM	43
	44	(defgroup eshell-ext nil
	45	"External commands are invoked when operating system executables are
	46	loaded into memory, thus beginning a new process."
	47	:tag "External commands"
	48	:group 'eshell)
	49
affbf647 GM	50	;;; User Variables:
affbf647 GM	51
d783d303	52	(defcustom eshell-ext-load-hook nil
ec60da52	53	"A hook that gets run when `eshell-ext' is loaded."
d783d303	54	:version "24.1" ; removed eshell-ext-initialize
affbf647 GM	55	:type 'hook
	56	:group 'eshell-ext)
	57
194c8d98	58	(defcustom eshell-binary-suffixes exec-suffixes
ec60da52	59	"A list of suffixes used when searching for executable files."
affbf647 GM	60	:type '(repeat string)
	61	:group 'eshell-ext)
	62
	63	(defcustom eshell-force-execution nil
ec60da52	64	"If non-nil, try to execute binary files regardless of permissions.
affbf647 GM	65	This can be useful on systems like Windows, where the operating system
	66	doesn't happen to honor the permission bits in certain cases; or in
	67	cases where you want to associate an interpreter with a particular
	68	kind of script file, but the language won't let you but a '#!'
	69	interpreter line in the file, and you don't want to make it executable
	70	since nothing else but Eshell will be able to understand
	71	`eshell-interpreter-alist'."
	72	:type 'boolean
	73	:group 'eshell-ext)
	74
	75	(defun eshell-search-path (name)
	76	"Search the environment path for NAME."
	77	(if (file-name-absolute-p name)
	78	name
605a20a9	79	(let ((list (eshell-parse-colon-path eshell-path-env))
affbf647 GM	80	suffixes n1 n2 file)
	81	(while list
	82	(setq n1 (concat (car list) name))
	83	(setq suffixes eshell-binary-suffixes)
	84	(while suffixes
	85	(setq n2 (concat n1 (car suffixes)))
	86	(if (and (or (file-executable-p n2)
	87	(and eshell-force-execution
	88	(file-readable-p n2)))
	89	(not (file-directory-p n2)))
	90	(setq file n2 suffixes nil list nil))
	91	(setq suffixes (cdr suffixes)))
	92	(setq list (cdr list)))
	93	file)))
	94
2ada368a GM	95	;; This file provides itself then eval-when-compile loads files that require it.
	96	;; This causes spurious "might not be defined at runtime" warnings.
	97	(declare-function eshell-search-path "esh-ext" (name))
	98
affbf647 GM	99	(defcustom eshell-windows-shell-file
affbf647 GM	100	(if (eshell-under-windows-p)
6283a7d3	101	(if (string-match "\\(cmdproxy\\\|sh\\)\\.\\(com\\\|exe\\)"
affbf647 GM	102	shell-file-name)
affbf647 GM	103	(or (eshell-search-path "cmd.exe")
b0c9a334	104	(eshell-search-path "command.com"))
affbf647	105	shell-file-name))
ec60da52	106	"The name of the shell command to use for DOS/Windows batch files.
affbf647 GM	107	This defaults to nil on non-Windows systems, where this variable is
affbf647 GM	108	wholly ignored."
f569d4c4	109	:type '(choice file (const nil))
affbf647 GM	110	:group 'eshell-ext)
affbf647 GM	111
f87b1284 GM	112	(autoload 'eshell-parse-command "esh-cmd")
f87b1284 GM	113
affbf647 GM	114	(defsubst eshell-invoke-batch-file (&rest args)
	115	"Invoke a .BAT or .CMD file on DOS/Windows systems."
	116	;; since CMD.EXE can't handle forward slashes in the initial
	117	;; argument...
6b0e3e4d	118	(setcar args (subst-char-in-string ?/ ?\\ (car args)))
affbf647	119	(throw 'eshell-replace-command
93376c5b CY	120	(eshell-parse-command
	121	(eshell-quote-argument eshell-windows-shell-file)
	122	(cons "/c" args))))
affbf647 GM	123
	124	(defcustom eshell-interpreter-alist
	125	(if (eshell-under-windows-p)
	126	'(("\\.\\(bat\\\|cmd\\)\\'" . eshell-invoke-batch-file)))
ec60da52	127	"An alist defining interpreter substitutions.
affbf647 GM	128	Each member is a cons cell of the form:
	129
	130	(MATCH . INTERPRETER)
	131
d105b0e2 TH	132	MATCH should be a regexp, which is matched against the command
	133	name, or a function of arity 2 receiving the COMMAND and its
	134	ARGS (a list). If either returns a non-nil value, then
	135	INTERPRETER will be used for that command.
affbf647 GM	136
	137	If INTERPRETER is a string, it will be called as the command name,
	138	with the original command name passed as the first argument, with all
	139	subsequent arguments following. If INTERPRETER is a function, it will
	140	be called with all of those arguments. Note that interpreter
	141	functions should throw `eshell-replace-command' with the alternate
	142	command form, or they should return a value compatible with the
	143	possible return values of `eshell-external-command', which see."
	144	:type '(repeat (cons (choice regexp (function :tag "Predicate"))
	145	(choice string (function :tag "Interpreter"))))
	146	:group 'eshell-ext)
	147
	148	(defcustom eshell-alternate-command-hook nil
ec60da52	149	"A hook run whenever external command lookup fails.
affbf647 GM	150	If a functions wishes to provide an alternate command, they must throw
	151	it using the tag `eshell-replace-command'. This is done because the
	152	substituted command need not be external at all, and therefore must be
	153	passed up to a higher level for re-evaluation.
	154
	155	Or, if the function returns a filename, that filename will be invoked
	156	with the current command arguments rather than the command specified
	157	by the user on the command line."
	158	:type 'hook
	159	:group 'eshell-ext)
	160
	161	(defcustom eshell-command-interpreter-max-length 256
ec60da52	162	"The maximum length of any command interpreter string, plus args."
affbf647 GM	163	:type 'integer
	164	:group 'eshell-ext)
	165
1228240f	166	(defcustom eshell-explicit-command-char ?*
ec60da52	167	"If this char occurs before a command name, call it externally.
451eaf8d RS	168	That is, although `vi' may be an alias, `\vi' will always call the
451eaf8d RS	169	external version."
1228240f JW	170	:type 'character
	171	:group 'eshell-ext)
	172
affbf647 GM	173	;;; Functions:
	174
	175	(defun eshell-ext-initialize ()
	176	"Initialize the external command handling code."
affbf647 GM	177	(add-hook 'eshell-named-command-hook 'eshell-explicit-command nil t))
	178
	179	(defun eshell-explicit-command (command args)
	180	"If a command name begins with `*', call it externally always.
	181	This bypasses all Lisp functions and aliases."
	182	(when (and (> (length command) 1)
1228240f	183	(eq (aref command 0) eshell-explicit-command-char))
affbf647 GM	184	(let ((cmd (eshell-search-path (substring command 1))))
	185	(if cmd
	186	(or (eshell-external-command cmd args)
	187	(error "%s: external command failed" cmd))
	188	(error "%s: external command not found"
	189	(substring command 1))))))
	190
f87b1284 GM	191	(autoload 'eshell-close-handles "esh-io")
f87b1284 GM	192
605a20a9	193	(defun eshell-remote-command (command args)
affbf647 GM	194	"Insert output from a remote COMMAND, using ARGS.
	195	A remote command is something that executes on a different machine.
	196	An external command simply means external to Emacs.
	197
	198	Note that this function is very crude at the moment. It gathers up
	199	all the output from the remote command, and sends it all at once,
	200	causing the user to wonder if anything's really going on..."
	201	(let ((outbuf (generate-new-buffer " eshell remote output"))
	202	(errbuf (generate-new-buffer " eshell remote error"))
8477cc7a	203	(command (or (file-remote-p command 'localname) command))
affbf647 GM	204	(exitcode 1))
	205	(unwind-protect
	206	(progn
	207	(setq exitcode
605a20a9 MA	208	(shell-command
	209	(mapconcat 'shell-quote-argument
	210	(append (list command) args) " ")
	211	outbuf errbuf))
937e6a56 SM	212	(eshell-print (with-current-buffer outbuf (buffer-string)))
937e6a56 SM	213	(eshell-error (with-current-buffer errbuf (buffer-string))))
affbf647 GM	214	(eshell-close-handles exitcode 'nil)
	215	(kill-buffer outbuf)
	216	(kill-buffer errbuf))))
	217
	218	(defun eshell-external-command (command args)
	219	"Insert output from an external COMMAND, using ARGS."
	220	(setq args (eshell-stringify-list (eshell-flatten-list args)))
c2c43c23 MA	221	(let ((interp (eshell-find-interpreter
c2c43c23 MA	222	command
d105b0e2	223	args
7b2fbe3b MA	224	;; `eshell-find-interpreter' does not work correctly
	225	;; for Tramp file name syntax. But we don't need to
	226	;; know the interpreter in that case, therefore the
	227	;; check is suppressed.
c2c43c23 MA	228	(or (and (stringp command) (file-remote-p command))
c2c43c23 MA	229	(file-remote-p default-directory)))))
a464a6c7	230	(cl-assert interp)
605a20a9 MA	231	(if (functionp (car interp))
	232	(apply (car interp) (append (cdr interp) args))
	233	(eshell-gather-process-output
	234	(car interp) (append (cdr interp) args)))))
affbf647 GM	235
	236	(defun eshell/addpath (&rest args)
	237	"Add a set of paths to PATH."
	238	(eshell-eval-using-options
	239	"addpath" args
	240	'((?b "begin" nil prepend "add path element at beginning")
	241	(?h "help" nil nil "display this usage message")
	242	:usage "[-b] PATH
	243	Adds the given PATH to $PATH.")
	244	(if args
	245	(progn
e296d94b GM	246	(setq eshell-path-env (getenv "PATH")
	247	args (mapconcat 'identity args path-separator)
	248	eshell-path-env
	249	(if prepend
	250	(concat args path-separator eshell-path-env)
	251	(concat eshell-path-env path-separator args)))
5eaeacb5 GM	252	(setenv "PATH" eshell-path-env))
	253	(dolist (dir (parse-colon-path (getenv "PATH")))
	254	(eshell-printn dir)))))
affbf647	255
127fd3c2 JW	256	(put 'eshell/addpath 'eshell-no-numeric-conversions t)
127fd3c2 JW	257
affbf647 GM	258	(defun eshell-script-interpreter (file)
	259	"Extract the script to run from FILE, if it has #!<interp> in it.
	260	Return nil, or a list of the form:
	261
	262	(INTERPRETER [ARGS] FILE)"
	263	(let ((maxlen eshell-command-interpreter-max-length))
	264	(if (and (file-readable-p file)
	265	(file-regular-p file))
	266	(with-temp-buffer
	267	(insert-file-contents-literally file nil 0 maxlen)
30104690	268	(if (looking-at "#![ \t]*\\([^ \r\t\n]+\\)\\([ \t]+\\(.+\\)\\)?")
affbf647 GM	269	(if (match-string 3)
	270	(list (match-string 1)
	271	(match-string 3)
	272	file)
	273	(list (match-string 1)
	274	file)))))))
	275
d105b0e2	276	(defun eshell-find-interpreter (file args &optional no-examine-p)
affbf647 GM	277	"Find the command interpreter with which to execute FILE.
	278	If NO-EXAMINE-P is non-nil, FILE will not be inspected for a script
	279	line of the form #!<interp>."
	280	(let ((finterp
	281	(catch 'found
	282	(ignore
a9eeff78	283	(dolist (possible eshell-interpreter-alist)
affbf647 GM	284	(cond
affbf647 GM	285	((functionp (car possible))
d105b0e2 TH	286	(let ((fn (car possible)))
	287	(and (funcall fn file args)
	288	(throw 'found (cdr possible)))))
affbf647 GM	289	((stringp (car possible))
	290	(and (string-match (car possible) file)
	291	(throw 'found (cdr possible))))
	292	(t
	293	(error "Invalid interpreter-alist test"))))))))
	294	(if finterp ; first check
	295	(list finterp file)
	296	(let ((fullname (if (file-name-directory file) file
	297	(eshell-search-path file)))
	298	(suffixes eshell-binary-suffixes))
	299	(if (and fullname (not (or eshell-force-execution
	300	(file-executable-p fullname))))
	301	(while suffixes
	302	(let ((try (concat fullname (car suffixes))))
	303	(if (or (file-executable-p try)
	304	(and eshell-force-execution
	305	(file-readable-p try)))
	306	(setq fullname try suffixes nil)
	307	(setq suffixes (cdr suffixes))))))
	308	(cond ((not (and fullname (file-exists-p fullname)))
	309	(let ((name (or fullname file)))
	310	(unless (setq fullname
	311	(run-hook-with-args-until-success
	312	'eshell-alternate-command-hook file))
	313	(error "%s: command not found" name))))
	314	((not (or eshell-force-execution
	315	(file-executable-p fullname)))
	316	(error "%s: Permission denied" fullname)))
	317	(let (interp)
	318	(unless no-examine-p
	319	(setq interp (eshell-script-interpreter fullname))
	320	(if interp
	321	(setq interp
d105b0e2	322	(cons (car (eshell-find-interpreter (car interp) args t))
affbf647 GM	323	(cdr interp)))))
	324	(or interp (list fullname)))))))
	325
affbf647	326	;;; esh-ext.el ends here